Error ResourceSaver::save(const String &p_path,const RES& p_resource,uint32_t p_flags) {
String extension=p_path.extension();
Error err=ERR_FILE_UNRECOGNIZED;
for (int i=0;i<saver_count;i++) {
if (!saver[i]->recognize(p_resource))
continue;
List<String> extensions;
bool recognized=false;
saver[i]->get_recognized_extensions(p_resource,&extensions);
for (List<String>::Element *E=extensions.front();E;E=E->next()) {
if (E->get().nocasecmp_to(extension.extension())==0)
recognized=true;
}
if (!recognized)
continue;
String old_path=p_resource->get_path();
String local_path=Globals::get_singleton()->localize_path(p_path);
RES rwcopy = p_resource;
if (p_flags&FLAG_CHANGE_PATH)
rwcopy->set_path(local_path);
err = saver[i]->save(p_path,p_resource,p_flags);
if (err == OK ) {
#ifdef TOOLS_ENABLED
((Resource*)p_resource.ptr())->set_edited(false);
if (timestamp_on_save) {
uint64_t mt = FileAccess::get_modified_time(p_path);
((Resource*)p_resource.ptr())->set_last_modified_time(mt);
}
#endif
if (p_flags&FLAG_CHANGE_PATH)
rwcopy->set_path(old_path);
if (save_callback && p_path.begins_with("res://"))
save_callback(p_path);
return OK;
} else {
}
}
return err;
}
/*
* This is the RPC `scheduler' (or rather, the finite state machine).
*/
static int
__rpc_execute(struct rpc_task *task)
{
unsigned long oldflags;
int status = 0;
dprintk("RPC: %4d rpc_execute flgs %x\n",
task->tk_pid, task->tk_flags);
if (!RPC_IS_RUNNING(task)) {
printk(KERN_WARNING "RPC: rpc_execute called for sleeping task!!\n");
return 0;
}
while (1) {
/*
* Execute any pending callback.
*/
if (task->tk_flags & RPC_TASK_CALLBACK) {
/* Define a callback save pointer */
void (*save_callback)(struct rpc_task *);
task->tk_flags &= ~RPC_TASK_CALLBACK;
/*
* If a callback exists, save it, reset it,
* call it.
* The save is needed to stop from resetting
* another callback set within the callback handler
* - Dave
*/
if (task->tk_callback) {
save_callback=task->tk_callback;
task->tk_callback=NULL;
save_callback(task);
}
}
/*
* No handler for next step means exit.
*/
if (!task->tk_action)
break;
/*
* Perform the next FSM step.
* tk_action may be NULL when the task has been killed
* by someone else.
*/
if (RPC_IS_RUNNING(task) && task->tk_action)
task->tk_action(task);
/*
* Check whether task is sleeping.
* Note that if the task may go to sleep in tk_action,
* and the RPC reply arrives before we get here, it will
* have state RUNNING, but will still be on schedq.
*/
save_flags(oldflags); cli();
if (RPC_IS_RUNNING(task)) {
if (task->tk_rpcwait == &schedq)
rpc_remove_wait_queue(task);
} else while (!RPC_IS_RUNNING(task)) {
if (RPC_IS_ASYNC(task)) {
restore_flags(oldflags);
return 0;
}
/* sync task: sleep here */
dprintk("RPC: %4d sync task going to sleep\n",
task->tk_pid);
if (current->pid == rpciod_pid)
printk(KERN_ERR "RPC: rpciod waiting on sync task!\n");
sleep_on(&task->tk_wait);
/*
* When the task received a signal, remove from
* any queues etc, and make runnable again.
*/
if (signalled())
__rpc_wake_up(task);
dprintk("RPC: %4d sync task resuming\n",
task->tk_pid);
}
restore_flags(oldflags);
/*
* When a sync task receives a signal, it exits with
* -ERESTARTSYS. In order to catch any callbacks that
* clean up after sleeping on some queue, we don't
* break the loop here, but go around once more.
*/
if (!RPC_IS_ASYNC(task) && signalled()) {
dprintk("RPC: %4d got signal\n", task->tk_pid);
rpc_exit(task, -ERESTARTSYS);
}
}
dprintk("RPC: %4d exit() = %d\n", task->tk_pid, task->tk_status);
if (task->tk_exit) {
status = task->tk_status;
task->tk_exit(task);
}
return status;
}
