f8_status alloc_blk_reg_list(IBlk * b, HREG_LIST *h)
{
CRegRequirementList * req;
f8_status code;
req = new CRegRequirementList;
if(!req){
return F8_LOW_MEMORY;
}
_traverse(b, _alloc_var_proc, (__uint)req);
if(F8_FAILED(req->m_errcode)){
*h = 0;
code = req->m_errcode;
delete req;
return code;
}
_traverse(b, _alloc_reg_proc, (__uint)req);
if(F8_FAILED(req->m_errcode)){
*h = 0;
code = req->m_errcode;
delete req;
return code;
}
*h = (HREG_LIST)req;
return F8_SUCCESS;
}
/*
reconstruct register usage map.
called upon opening project and uploading project
*/
__bool build_reg_map()
{
CRegRequirementList req;
req.m_bGatherForDelete = false;
_traverse(sections, _gather_reg_usage, (__uint)&req);
if(F8_FAILED(req.m_errcode)){
utils_error("Warning : _gather_reg_usage failed %d(%s).\n", req.m_errcode, _errmsg(req.m_errcode));
}
req.Commit(__true);
return __true;
}
KPROXY_API f8_int kproxy_shell_ex(
const char * cmd,
__uint timeout,
void * reserved
)
{
f8_uuid oldUuid;
struct proxy_shell_param psp;
int code;
CArgsExA a;
int i;
oldUuid = sections->h.uuid;
a.parse(cmd, ";", 256, strlen(cmd) + 1, __true);
for(i=0; i<a.argc; i++){
psp.timeout = timeout;
if(!shell_execute_ex(g_shell, a.argv[i], &psp, &code)){
code = F8_UNKNOWN_COMMAND;
}
}
if(F8_FAILED(code)){
utils_error(
"<* PROXY_SHELL:`%s' returns %d(%s) *>\n",
cmd,
code,
_errmsg(code)
);
}else if(!proxy_silent){
utils_debug(
"<* PROXY_SHELL:`%s' returns %d(%s) *>\n",
cmd,
code,
_errmsg(code)
);
}
/* if executing inside on_play(), no autosave is made as that will
degrade performance */
if(!proxy_silent)
autoSave(0,0);
if(oldUuid != sections->h.uuid){
move_resource(&oldUuid, §ions->h.uuid);
}
return code;
}
f8_status ki_load_var_table(f8_uint count, struct blk_var_t * defs)
{
f8_uint i;
f8_status code;
struct blk_var_t *v;
v = defs;
ki_reset_var_table();
for(i=0; i<count; i++, v++){
code = ki_add_var(v);
if(F8_FAILED(code)){
return code;
}
}
return F8_SUCCESS;
}
__bool CRegRequirementList::Alloc(struct blk_var_t * v)
{
var_item item;
if(m_vlist.find(v->uuid) != m_vlist.end()){
m_errcode = F8_NAME_DUPLICATE;
return __false;
}
m_errcode = define_variable(v, &v);
if(F8_FAILED(m_errcode)){
return __false;
}
item.blk_id = v->blk->uuid;
item.var = v;
item.ref_count = 0;
m_vlist[v->uuid] = item;
return __true;
}
/*
load resource from stream, but in another name.
again, the reference count is not affected.
*/
F8RES_API __bool load_res_stream_as(
IF8Stream * s,
const f8_uuid * newId
)
{
F8_RESOURCE *h;
int ret;
h = _load_res_stream(s);
if(!h){
return __false;
}
ret = copy_resource(&h->id, newId);
if(F8_FAILED(ret)){
return __false;
}
/*
to be compatible with load_res_stream, we
remove a reference count from the one incremented
by copy_resource
*/
h = _get_res(newId);
h->refcount--;
return __true;
}
/*
primary site fsm
*/
LOCAL void primary_on_packet(struct peer_cmd_t * tp, int len)
{
char * data;
int dataLen;
static int bytesLeft;
data = (char*)&tp[1];
dataLen = len - sizeof(*tp);
if(dataLen < 0){
return;
}
if(tp->cmd == Pr_connect || tp->cmd == Pr_send_volatile){
tp->cmd = Pr_abort;
tp->code = F8_COLLISION;
tp->time = ke_get_time();
peer_write(tp, sizeof *tp);
set_state(hsp_s_collision);
return;
}
/* switch-case structure is the classical form of a software fsm
implementation.
*/
switch(get_state()){
case hsp_s_connecting:
if(tp->cmd == (Pr_connect | Pr_ack)){
if(dataLen >= sizeof(g_kernel.peer_status)){
memcpy(&g_kernel.peer_status, data, sizeof g_kernel.peer_status);
}
if(F8_FAILED(tp->code)){
if(tp->code == F8_COLLISION){
set_state(hsp_s_collision);
}else{
set_state(hsp_s_aborted);
}
break;
}
/* connection accepted, send first data packet */
tp->cmd = Pr_send_volatile;
tp->code = F8_SUCCESS;
tp->seq = 0;
tp->ack = 0;
bytesLeft = peerHdr.zipped_data_len;
if(bytesLeft < PEER_RTU - sizeof *tp){
lastFrameLength = bytesLeft;
}else{
lastFrameLength = PEER_RTU - sizeof *tp;
}
tp->params[0] = lastFrameOffset = 0;
tp->params[1] = lastFrameLength;
tp->time = ke_get_time();
if(peer_write2(tp, sizeof(*tp),peerDataZipped,lastFrameLength) == 0){
set_state(hsp_s_active);
}else{
set_state(hsp_s_linedown);
}
hsp_log(("connection built, sending first packet %d bytes.\n", lastFrameLength));
}
break;
case hsp_s_active:
/* */
if(tp->cmd == (Pr_send_volatile | Pr_ack)){
if(tp->params[0] != lastFrameOffset){
/* out of sync */
hsp_log(("out of sync, bad offset %08x, expected %08x\n", tp->params[0], lastFrameOffset));
peerCounters[4] = tp->params[0];
set_state(hsp_s_out_of_sync);
break;
}
lastFrameOffset += lastFrameLength;
tp->params[0] = lastFrameOffset;
bytesLeft -= lastFrameLength;
if(!bytesLeft){
tp->cmd = Pr_disconnect;
tp->code = F8_SUCCESS;
tp->time = ke_get_time();
/* tp->seq = 0x12345678; magic */
peer_write(tp, sizeof(*tp));
set_state(hsp_s_complete);
peerCounters[2]++;
break;
}
if(bytesLeft < PEER_RTU - sizeof *tp){
lastFrameLength = bytesLeft;
}else{
lastFrameLength = PEER_RTU - sizeof *tp;
}
tp->cmd = Pr_send_volatile;
tp->code = F8_SUCCESS;
tp->params[1] = lastFrameLength;
tp->time = ke_get_time();
if(peer_write2(tp,sizeof(*tp),peerDataZipped+lastFrameOffset,lastFrameLength) < 0){
set_state(hsp_s_linedown);
}
}else if(tp->cmd == Pr_abort){
if(tp->code == F8_COLLISION){
set_state(hsp_s_collision);
}else{
set_state(hsp_s_aborted);
}
}else{
hsp_log(("out of sync, bad command %04x\n", tp->cmd));
set_state(hsp_s_out_of_sync);
}
break;
default:
/* only query_status cmd is processed, other cmds are ignored */
;
break;
}
}
