static int
l_update (lua_State *L) {
const char *path = (lua_gettop (L) < 1 || lua_isnil (L, 1)) ? "" : luaL_checkstring (L, 1);
svn_opt_revision_t revision;
if (lua_gettop (L) < 2 || lua_isnil (L, 2)) {
revision.kind = svn_opt_revision_head;
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 2);
}
svn_boolean_t recursive = TRUE;
svn_boolean_t ignore_externals = FALSE;
int itable = 3;
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "recursive");
if (lua_isboolean (L, -1)) {
recursive = lua_toboolean (L, -1);
}
lua_getfield (L, itable, "ignore_externals");
if (lua_isboolean (L, -1)) {
ignore_externals = lua_toboolean (L, -1);
}
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
apr_array_header_t *array;
array = apr_array_make (pool, 1, sizeof (const char *));
(*((const char **) apr_array_push (array))) = path;
apr_array_header_t *result_revs = NULL;
err = svn_client_update2 (&result_revs, array, &revision, recursive, ignore_externals, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
if (result_revs == NULL) {
lua_pushnil (L);
} else {
int rev = (int) ((int **) (result_revs->elts))[0];
lua_pushinteger (L, rev);
}
svn_pool_destroy (pool);
return 1;
}
void onGameModeToggled(bool is_starting)
{
if (is_starting)
{
if (!m_library)
{
m_library = Library::create(m_library_path, m_allocator);
if (!m_library->load())
{
g_log_error.log("script") << "Could not load " << m_library_path.c_str();
Library::destroy(m_library);
m_library = NULL;
return;
}
m_update_function = (UpdateFunction)m_library->resolve("update");
m_done_function = (DoneFunction)m_library->resolve("done");
m_serialize_function = (SerializeFunction)m_library->resolve("serialize");
m_deserialize_function = (DeserializeFunction)m_library->resolve("deserialize");
InitFunction init_function = (InitFunction)m_library->resolve("init");
if (!m_update_function || !init_function)
{
g_log_error.log("script") << "Script interface in " << m_library_path.c_str() << " is not complete";
}
if (init_function)
{
init_function(this);
}
}
}
else
{
unloadLibrary();
}
}
Module::Module(const std::string& name) {
char * error;
int rv;
int (*init_function)();
this->module_handle = dlopen(name.c_str(), RTLD_NOW);
if(!this->module_handle){
// TODO throw exception;
std::cerr << std::string(dlerror()) << std::endl;
return;
}
init_function = (int (*)())dlsym(this->module_handle, "init_module");
if((error = dlerror()) != NULL){
// TODO throw exception
std::cerr << std::string(error) << std::endl;
return;
}
this->module_name = name;
rv = init_function();
if(rv){
// TODO throw exception
std::cerr << "Init function failed, returned: " << rv << std::endl;
return;
}
return;
}
static int
l_list (lua_State *L) {
const char *path = (lua_gettop (L) < 1 || lua_isnil (L, 1)) ? "" : luaL_checkstring (L, 1);
svn_opt_revision_t revision;
svn_opt_revision_t peg_revision;
peg_revision.kind = svn_opt_revision_unspecified;
if (lua_gettop (L) < 2 || lua_isnil (L, 2)) {
revision.kind = get_revision_kind (path);
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 2);
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
lua_newtable (L);
err = svn_client_list (path, &peg_revision, &revision, TRUE, SVN_DIRENT_ALL,
TRUE, list_func, L, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 1;
}
static int machine_add_machine( int (*init_function)( fuse_machine_info *machine ) )
{
fuse_machine_info *machine;
int error;
machine_count++;
machine_types =
libspectrum_realloc( machine_types,
machine_count * sizeof( fuse_machine_info* ) );
machine_types[ machine_count - 1 ] = malloc( sizeof( fuse_machine_info ) );
if( !machine_types[ machine_count - 1 ] ) {
ui_error( UI_ERROR_ERROR, "out of memory at %s:%d", __FILE__, __LINE__ );
return 1;
}
machine = machine_types[ machine_count - 1 ];
error = init_function( machine ); if( error ) return error;
machine_set_const_timings( machine );
machine->capabilities = libspectrum_machine_capabilities( machine->machine );
return 0;
}
static int
l_move (lua_State *L) {
const char *src_path = luaL_checkstring (L, 1);
const char *dest_path = luaL_checkstring (L, 2);
const char *message = (lua_gettop (L) < 3 || lua_isnil (L, 3)) ? "" : luaL_checkstring (L, 3);
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
src_path = svn_path_canonicalize (src_path, pool);
dest_path = svn_path_canonicalize (dest_path, pool);
svn_commit_info_t *commit_info = NULL;
if (svn_path_is_url (dest_path)) {
make_log_msg_baton (&(ctx->log_msg_baton2), message, NULL, ctx->config, pool, L);
ctx->log_msg_func2 = log_msg_func2;
}
err = svn_client_move4 (&commit_info, src_path, dest_path, FALSE, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
if (commit_info == NULL) {
lua_pushnil (L);
} else {
lua_pushinteger (L, commit_info->revision);
}
svn_pool_destroy (pool);
return 1;
}
static int
l_propset (lua_State *L) {
const char *path = luaL_checkstring (L, 1);
const char *propname = luaL_checkstring (L, 2);
const char *propval = lua_isnil (L, 3) ? NULL : luaL_checkstring (L, 3);
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
const char *propname_utf8;
err = svn_utf_cstring_to_utf8 (&propname_utf8, propname, pool);
IF_ERROR_RETURN (err, pool, L);
if (propval != NULL) {
svn_string_t *sstring = svn_string_create (propval, pool);
err = svn_client_propset2 (propname_utf8, sstring, path, TRUE, FALSE, ctx, pool);
} else {
err = svn_client_propset2 (propname_utf8, NULL, path, TRUE, FALSE, ctx, pool);
}
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 0;
}
virtual void afterScriptCompiled() override
{
if (!m_library && m_reload_after_compile)
{
m_library = Library::create(m_library_path, m_allocator);
if (!m_library->load())
{
g_log_error.log("script") << "Could not load " << m_library_path.c_str();
Library::destroy(m_library);
m_library = NULL;
return;
}
m_update_function = (UpdateFunction)m_library->resolve("update");
m_done_function = (DoneFunction)m_library->resolve("done");
m_serialize_function = (SerializeFunction)m_library->resolve("serialize");
m_deserialize_function = (DeserializeFunction)m_library->resolve("deserialize");
InitFunction init_function = (InitFunction)m_library->resolve("init");
if (!m_update_function || !init_function)
{
g_log_error.log("script") << "Script interface in " << m_library_path.c_str() << " is not complete";
}
if (init_function)
{
init_function(this);
}
}
m_is_compiling = false;
}
static int dev_release(struct inode *inodep, struct file *filep)
{
unsigned long flags;
data_packet_list_node *dp = getNodeFromActiveList();
isConnectedToProcess = false;
if(wait_queue_flag == true)
{
wait_queue_flag = false;
wake_up_interruptible(&wait_queue);
}
spin_lock_irqsave(&dp_list_lock, flags);
while(dp != NULL)
{
kfree(dp);
dp = getNodeFromActiveList();
}
dp = getNodeFromStorageList(false);
while(dp != NULL)
{
kfree(dp);
dp = getNodeFromStorageList(false);
}
spin_unlock_irqrestore(&dp_list_lock, flags);
init_function(NULL);
printk(KERN_INFO "SYSMON: Device successfully closed\n");
return 0;
}
static int
l_propget (lua_State *L) {
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
apr_hash_t *props;
const char *propname_utf8;
const void *key;
void *val;
apr_hash_index_t *hi;
svn_opt_revision_t peg_revision;
svn_opt_revision_t revision;
const char *path = luaL_checkstring (L, 1);
const char *propname = luaL_checkstring (L, 2);
int itable = 4;
svn_boolean_t recursive = FALSE;
peg_revision.kind = svn_opt_revision_unspecified;
if (lua_gettop (L) < 3 || lua_isnil (L, 3)) {
revision.kind = svn_opt_revision_unspecified;
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 3);
}
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "recursive");
if (lua_isboolean (L, -1)) {
recursive = lua_toboolean (L, -1);
}
}
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
err = svn_utf_cstring_to_utf8 (&propname_utf8, propname, pool);
IF_ERROR_RETURN (err, pool, L);
err = svn_client_propget2 (&props, propname_utf8, path, &peg_revision, &revision, recursive, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
lua_newtable (L);
for (hi = apr_hash_first (pool, props); hi; hi = apr_hash_next (hi)) {
svn_string_t *s;
apr_hash_this (hi, &key, NULL, &val);
s = (svn_string_t *) val;
lua_pushstring (L, s->data);
lua_setfield (L, -2, (char *) key);
}
svn_pool_destroy (pool);
return 1;
}
static int
l_revprop_list (lua_State *L) {
const char *url = luaL_checkstring (L, 1);
svn_opt_revision_t revision;
if (lua_gettop (L) < 2 || lua_isnil (L, 2)) {
revision.kind = get_revision_kind (url);
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 2);
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
url = svn_path_canonicalize (url, pool);
apr_hash_t *entries;
apr_hash_index_t *hi;
void *val;
const void *key;
svn_revnum_t rev;
err = svn_client_revprop_list (&entries, url, &revision, &rev, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
lua_newtable (L);
for (hi = apr_hash_first (pool, entries); hi; hi = apr_hash_next (hi)) {
const char *pname;
svn_string_t *pval;
apr_hash_this (hi, &key, NULL, &val);
pname = key;
pval = (svn_string_t *) val;
if (svn_prop_needs_translation (pname)) {
err = svn_subst_translate_string (&pval, pval, APR_LOCALE_CHARSET, pool);
IF_ERROR_RETURN (err, pool, L);
}
err = svn_cmdline_cstring_from_utf8 (&pname, pname, pool);
IF_ERROR_RETURN (err, pool, L);
lua_pushstring (L, pval->data);
lua_setfield (L, -2, pname);
}
svn_pool_destroy (pool);
return 1;
}
static int
l_revprop_set (lua_State *L) {
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
svn_opt_revision_t revision;
svn_revnum_t rev;
const char *url = luaL_checkstring (L, 1);
const char *propname = luaL_checkstring (L, 2);
const char *propval = lua_isnil (L, 3) ? NULL : luaL_checkstring (L, 3);
const char *propname_utf8 = NULL;
int itable = 5;
svn_boolean_t force = FALSE;
if (lua_gettop (L) < 4 || lua_isnil (L, 4)) {
revision.kind = get_revision_kind (url);
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 4);
}
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "force");
if (lua_isboolean (L, -1)) {
force = lua_toboolean (L, -1);
}
}
init_function (&ctx, &pool, L);
url = svn_path_canonicalize (url, pool);
err = svn_utf_cstring_to_utf8 (&propname_utf8, propname, pool);
IF_ERROR_RETURN (err, pool, L);
if (propval != NULL) {
svn_string_t *sstring = svn_string_create (propval, pool);
if (svn_prop_needs_translation (propname_utf8)) {
err = svn_subst_translate_string (&sstring, sstring, APR_LOCALE_CHARSET, pool);
IF_ERROR_RETURN (err, pool, L);
}
err = svn_client_revprop_set (propname_utf8, sstring, url, &revision, &rev, force, ctx, pool);
} else {
err = svn_client_revprop_set (propname_utf8, NULL, url, &revision, &rev, force, ctx, pool);
}
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 0;
}
static int
l_checkout (lua_State *L) {
const char *path = luaL_checkstring (L, 1);
const char *dir = luaL_checkstring (L, 2);
svn_opt_revision_t revision;
svn_opt_revision_t peg_revision;
peg_revision.kind = svn_opt_revision_unspecified;
if (lua_gettop (L) < 3 || lua_isnil (L, 3)) {
revision.kind = svn_opt_revision_head;
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 3);
}
svn_boolean_t recursive = TRUE;
svn_boolean_t ignore_externals = FALSE;
int itable = 4;
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "recursive");
if (lua_isboolean (L, -1)) {
recursive = lua_toboolean (L, -1);
}
lua_getfield (L, itable, "ignore_externals");
if (lua_isboolean (L, -1)) {
ignore_externals = lua_toboolean (L, -1);
}
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
dir = svn_path_canonicalize (dir, pool);
svn_revnum_t rev;
err = svn_client_checkout2 (&rev, path, dir, &peg_revision, &revision, recursive, ignore_externals, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
lua_pushinteger (L, rev);
svn_pool_destroy (pool);
return 1;
}
/**
* Dynamically loads the plugin and runs the plugin's init function.
*
* @param[in] plugin_file Name of plugin dll/dylib/so. TODO:DOC is this correct? see .h
* @return 0 if successful, APR error code or error code from the plugin's init function on failure.
*/
int LLPluginInstance::load(const std::string& plugin_dir, std::string &plugin_file)
{
pluginInitFunction init_function = NULL;
if ( plugin_dir.length() )
{
#if LL_WINDOWS
// VWR-21275:
// *SOME* Windows systems fail to load the Qt plugins if the current working
// directory is not the same as the directory with the Qt DLLs in.
// This should not cause any run time issues since we are changing the cwd for the
// plugin shell process and not the viewer.
// Changing back to the previous directory is not necessary since the plugin shell
// quits once the plugin exits.
_chdir( plugin_dir.c_str() );
#endif
};
int result = apr_dso_load(&mDSOHandle,
plugin_file.c_str(),
gAPRPoolp);
if(result != APR_SUCCESS)
{
char buf[1024];
apr_dso_error(mDSOHandle, buf, sizeof(buf));
LL_WARNS("PluginInstance") << "apr_dso_load of " << plugin_file << " failed with error " << result << " , additional info string: " << buf << LL_ENDL;
}
if(result == APR_SUCCESS)
{
result = apr_dso_sym((apr_dso_handle_sym_t*)&init_function,
mDSOHandle,
PLUGIN_INIT_FUNCTION_NAME);
if(result != APR_SUCCESS)
{
LL_WARNS("PluginInstance") << "apr_dso_sym failed with error " << result << LL_ENDL;
}
}
if(result == APR_SUCCESS)
{
result = init_function(staticReceiveMessage, (void*)this, &mPluginSendMessageFunction, &mPluginUserData);
if((result != APR_SUCCESS) || (mPluginUserData == NULL))
{
LL_WARNS("PluginInstance") << "call to init function failed with error " << result << LL_ENDL;
}
}
return (int)result;
}
static int
l_commit (lua_State *L) {
const char *path = (lua_gettop (L) < 1 || lua_isnil (L, 1)) ? "" : luaL_checkstring (L, 1);
const char *message = (lua_gettop (L) < 2 || lua_isnil (L, 2)) ? "" : luaL_checkstring (L, 2);
svn_boolean_t recursive = TRUE;
svn_boolean_t keep_locks = FALSE;
int itable = 3;
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "recursive");
if (lua_isboolean (L, -1)) {
recursive = lua_toboolean (L, -1);
}
lua_getfield (L, itable, "keep_locks");
if (lua_isboolean (L, -1)) {
keep_locks = lua_toboolean (L, -1);
}
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
apr_array_header_t *array;
svn_commit_info_t *commit_info = NULL;
array = apr_array_make (pool, 1, sizeof (const char *));
(*((const char **) apr_array_push (array))) = path;
make_log_msg_baton (&(ctx->log_msg_baton2), message, path, ctx->config, pool, L);
ctx->log_msg_func2 = log_msg_func2;
err = svn_client_commit3 (&commit_info, array, recursive, keep_locks, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
if (commit_info == NULL) {
lua_pushnil (L);
} else {
lua_pushinteger (L, commit_info->revision);
}
svn_pool_destroy (pool);
return 1;
}
static int
l_propset (lua_State *L) {
const char *path = luaL_checkstring (L, 1);
const char *propname = luaL_checkstring (L, 2);
const char *propval = lua_isnil (L, 3) ? NULL : luaL_checkstring (L, 3);
svn_boolean_t recursive = FALSE;
svn_boolean_t force = FALSE;
int itable = 4;
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "recursive");
if (lua_isboolean (L, -1)) {
recursive = lua_toboolean (L, -1);
}
lua_getfield (L, itable, "force");
if (lua_isboolean (L, -1)) {
force = lua_toboolean (L, -1);
}
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
const char *propname_utf8;
err = svn_utf_cstring_to_utf8 (&propname_utf8, propname, pool);
IF_ERROR_RETURN (err, pool, L);
if (propval != NULL) {
svn_string_t *sstring = svn_string_create (propval, pool);
err = svn_client_propset2 (propname_utf8, sstring, path, recursive, force, ctx, pool);
} else {
err = svn_client_propset2 (propname_utf8, NULL, path, recursive, force, ctx, pool);
}
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 0;
}
static int
l_merge (lua_State *L) {
const char *source1 = luaL_checkstring (L, 1);
svn_opt_revision_t rev1;
if (lua_isnil (L, 2)) {
rev1.kind = svn_opt_revision_head;
} else {
rev1.kind = svn_opt_revision_number;
rev1.value.number = lua_tointeger (L, 2);
}
const char *source2 = luaL_checkstring (L, 3);
svn_opt_revision_t rev2;
if (lua_isnil (L, 4)) {
rev2.kind = svn_opt_revision_head;
} else {
rev2.kind = svn_opt_revision_number;
rev2.value.number = lua_tointeger (L, 4);
}
const char *wcpath;
if (lua_gettop (L) < 5 || lua_isnil (L, 5)) {
wcpath = "";
} else {
wcpath = luaL_checkstring (L, 5);
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
source1 = svn_path_canonicalize (source1, pool);
source2 = svn_path_canonicalize (source2, pool);
wcpath = svn_path_canonicalize (wcpath, pool);
err = svn_client_merge2 (source1, &rev1, source2, &rev2, wcpath,
TRUE, FALSE, FALSE, FALSE, NULL, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 0;
}
static int
l_import (lua_State *L) {
const char *path = lua_isnil (L, 1) ? "" : luaL_checkstring (L, 1);
const char *url = luaL_checkstring (L, 2);
const char *message = (lua_gettop (L) < 3 || lua_isnil (L, 3)) ? "" : luaL_checkstring (L, 3);
svn_boolean_t recursive = TRUE;
svn_boolean_t no_ignore = FALSE;
int itable = 4;
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "recursive");
if (lua_isboolean (L, -1)) {
recursive = lua_toboolean (L, -1);
}
lua_getfield (L, itable, "no_ignore");
if (lua_isboolean (L, -1)) {
no_ignore = lua_toboolean (L, -1);
}
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
url = svn_path_canonicalize (url, pool);
svn_commit_info_t *commit_info = NULL;
make_log_msg_baton (&(ctx->log_msg_baton2), message, NULL, ctx->config, pool, L);
ctx->log_msg_func2 = log_msg_func2;
err = svn_client_import2 (&commit_info, path, url, !recursive, no_ignore, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
if (commit_info == NULL) {
lua_pushnil (L);
} else {
lua_pushinteger (L, commit_info->revision);
}
svn_pool_destroy (pool);
return 1;
}
static int
l_list (lua_State *L) {
const char *path = (lua_gettop (L) < 1 || lua_isnil (L, 1)) ? "" : luaL_checkstring (L, 1);
svn_opt_revision_t revision;
svn_opt_revision_t peg_revision;
peg_revision.kind = svn_opt_revision_unspecified;
if (lua_gettop (L) < 2 || lua_isnil (L, 2)) {
revision.kind = get_revision_kind (path);
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 2);
}
svn_boolean_t recursive = FALSE;
svn_boolean_t fetch_locks = FALSE;
int itable = 3;
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "recursive");
if (lua_isboolean (L, -1)) {
recursive = lua_toboolean (L, -1);
}
lua_getfield (L, itable, "fetch_locks");
if (lua_isboolean (L, -1)) {
fetch_locks = lua_toboolean (L, -1);
}
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
lua_newtable (L);
err = svn_client_list (path, &peg_revision, &revision, recursive, SVN_DIRENT_ALL,
fetch_locks, list_func, L, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 1;
}
static int
l_log (lua_State *L) {
const char *path = (lua_gettop (L) < 1 || lua_isnil (L, 1)) ? "" : luaL_checkstring (L, 1);
svn_opt_revision_t start, end;
svn_opt_revision_t peg_revision;
peg_revision.kind = svn_opt_revision_unspecified;
start.kind = svn_opt_revision_number;
if (lua_gettop (L) < 2 || lua_isnil (L, 2)) {
start.value.number = 0;
} else {
start.value.number = lua_tointeger (L, 2);
}
if (lua_gettop (L) < 3 || lua_isnil (L, 3)) {
end.kind = get_revision_kind (path);
} else {
end.kind = svn_opt_revision_number;
end.value.number = lua_tointeger (L, 3);
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
apr_array_header_t *array;
array = apr_array_make (pool, 1, sizeof (const char *));
(*((const char **) apr_array_push (array))) = path;
const int limit = 0;
lua_newtable (L);
err = svn_client_log3 (array, &peg_revision, &start, &end, limit,
FALSE, FALSE, log_receiver, L, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 1;
}
static int
l_delete (lua_State *L) {
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
apr_array_header_t *array;
const char *path = luaL_checkstring (L, 1);
const char *message = (lua_gettop (L) < 2 || lua_isnil (L, 2)) ? "" : luaL_checkstring (L, 2);
int itable = 3;
svn_boolean_t force = FALSE;
svn_commit_info_t *commit_info = NULL;
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "force");
if (lua_isboolean (L, -1)) {
force = lua_toboolean (L, -1);
}
}
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
array = apr_array_make (pool, 1, sizeof (const char *));
(*((const char **) apr_array_push (array))) = path;
lua_newtable (L);
if (svn_path_is_url (path)) {
make_log_msg_baton (&(ctx->log_msg_baton2), message, NULL, ctx->config, pool, L);
ctx->log_msg_func2 = log_msg_func2;
}
err = svn_client_delete2 (&commit_info, array, force, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
if (commit_info == NULL) {
lua_pushnil (L);
} else {
lua_pushinteger (L, commit_info->revision);
}
svn_pool_destroy (pool);
return 1;
}
static int
l_revprop_get (lua_State *L) {
const char *url = luaL_checkstring (L, 1);
const char *propname = luaL_checkstring (L, 2);
svn_opt_revision_t revision;
if (lua_gettop (L) < 3 || lua_isnil (L, 3)) {
revision.kind = get_revision_kind (url);
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 3);
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
url = svn_path_canonicalize (url, pool);
const char *propname_utf8;
err = svn_utf_cstring_to_utf8 (&propname_utf8, propname, pool);
IF_ERROR_RETURN (err, pool, L);
svn_string_t *propval;
svn_revnum_t rev;
err = svn_client_revprop_get (propname_utf8, &propval, url, &revision, &rev, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
svn_string_t *printable_val = propval;
if (svn_prop_needs_translation (propname_utf8)) {
err = svn_subst_detranslate_string (&printable_val, propval, TRUE, pool);
IF_ERROR_RETURN (err, pool, L);
}
lua_pushstring (L, printable_val->data);
svn_pool_destroy (pool);
return 1;
}
static int
l_copy (lua_State *L) {
const char *src_path = luaL_checkstring (L, 1);
const char *dest_path = luaL_checkstring (L, 2);
svn_opt_revision_t revision;
if (lua_gettop (L) < 3 || lua_isnil (L, 3)) {
revision.kind = svn_opt_revision_unspecified;
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 3);
}
const char *message = (lua_gettop (L) < 4 || lua_isnil (L, 4)) ? "" : luaL_checkstring (L, 4);
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
src_path = svn_path_canonicalize (src_path, pool);
dest_path = svn_path_canonicalize (dest_path, pool);
svn_commit_info_t *commit_info = NULL;
if (svn_path_is_url (dest_path)) {
make_log_msg_baton (&(ctx->log_msg_baton2), message, NULL, ctx->config, pool, L);
ctx->log_msg_func2 = log_msg_func2;
}
err = svn_client_copy3 (&commit_info, src_path, &revision, dest_path, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
if (commit_info == NULL) {
lua_pushnil (L);
} else {
lua_pushinteger (L, commit_info->revision);
}
svn_pool_destroy (pool);
return 1;
}
static int
l_cleanup (lua_State *L) {
const char *path = (lua_gettop (L) < 1 || lua_isnil (L, 1)) ? "" : luaL_checkstring (L, 1);
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
err = svn_client_cleanup (path, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 0;
}
static int
l_add (lua_State *L) {
const char *path = luaL_checkstring (L, 1);
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
err = svn_client_add3 (path, TRUE, FALSE, FALSE, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 0;
}
static int
l_update (lua_State *L) {
const char *path = (lua_gettop (L) < 1 || lua_isnil (L, 1)) ? "" : luaL_checkstring (L, 1);
svn_opt_revision_t revision;
if (lua_gettop (L) < 2 || lua_isnil (L, 2)) {
revision.kind = svn_opt_revision_head;
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 2);
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
apr_array_header_t *array;
array = apr_array_make (pool, 1, sizeof (const char *));
(*((const char **) apr_array_push (array))) = path;
apr_array_header_t *result_revs = NULL;
err = svn_client_update2 (&result_revs, array, &revision, TRUE, FALSE, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
if (result_revs == NULL) {
lua_pushnil (L);
} else {
int rev = (int) ((int **) (result_revs->elts))[0];
lua_pushinteger (L, rev);
}
svn_pool_destroy (pool);
return 1;
}
static int
l_add (lua_State *L) {
const char *path = luaL_checkstring (L, 1);
svn_boolean_t recursive = TRUE;
svn_boolean_t force = FALSE;
svn_boolean_t no_ignore = FALSE;
int itable = 2;
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "recursive");
if (lua_isboolean (L, -1)) {
recursive = lua_toboolean (L, -1);
}
lua_getfield (L, itable, "force");
if (lua_isboolean (L, -1)) {
force = lua_toboolean (L, -1);
}
lua_getfield (L, itable, "no_ignore");
if (lua_isboolean (L, -1)) {
no_ignore = lua_toboolean (L, -1);
}
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
err = svn_client_add3 (path, recursive, force, no_ignore, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 0;
}
static int
l_cat (lua_State *L) {
const char *path = luaL_checkstring (L, 1);
svn_opt_revision_t peg_revision;
svn_opt_revision_t revision;
peg_revision.kind = svn_opt_revision_unspecified;
if (lua_gettop (L) < 2 || lua_isnil (L, 2)) {
revision.kind = get_revision_kind (path);
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 2);
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
svn_stream_t *stream;
stream = svn_stream_empty (pool);
svn_stream_set_write (stream, write_fn);
svn_stringbuf_t *buffer = svn_stringbuf_create ("\0", pool);
svn_stream_set_baton (stream, buffer);
err = svn_client_cat2 (stream, path, &peg_revision, &revision, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
lua_pushstring (L, buffer->data);
svn_pool_destroy (pool);
return 1;
}
/**
* main:
* @argc:
* @argv:
*
* This function will test all the functions defined at test_suite array.
* DO NOT TOUCH THIS FUNCTION
*
* Return value: 0 if everything was right or -1 if not.
**/
int main(int argc, char **argv)
{
gint i;
init_function ();
for (i = 0; test_suite[i].test_description != NULL; i++) {
if (test_suite[i].test_function ())
g_print (" [ OK ] [%s]: Testing: %s \n", MODULE_TEST_NAME, test_suite[i].test_description);
else {
g_print (" [ FAIL ] [%s]: Testing: %s \n", MODULE_TEST_NAME, test_suite[i].test_description);
exit (-1);
}
}
exit (0);
}
static int machine_add_machine( int (*init_function)( fuse_machine_info *machine ) )
{
fuse_machine_info *machine;
int error;
machine_count++;
machine_types =
libspectrum_renew( fuse_machine_info *, machine_types, machine_count );
machine_types[ machine_count - 1 ] = libspectrum_new( fuse_machine_info, 1 );
machine = machine_types[ machine_count - 1 ];
error = init_function( machine ); if( error ) return error;
machine_set_const_timings( machine );
machine->capabilities = libspectrum_machine_capabilities( machine->machine );
return 0;
}
