static INode *SetUpArguments(KonohaContext *kctx, FuelIRBuilder *builder, kMethod *mtd)
{
kParam *params = kMethod_GetParam(mtd);
unsigned i;
INode *Arg;
INode *Val;
INode *Arg0 = NULL;
if(mtd->typeId != TYPE_void) {
Arg = CreateArgument(builder, 0);
Val = CreateLocal(builder, mtd->typeId);
CreateUpdate(builder, Val, Arg);
INode_setType(Arg, mtd->typeId);
IField_setHash((IField *) Val, 0);
Arg0 = Val;
}
for(i = 0; i < params->psize; ++i) {
enum TypeId type = ConvertToTypeId(kctx, params->paramtypeItems[i].attrTypeId);
Arg = CreateArgument(builder, i+1);
Val = CreateLocal(builder, type);
CreateUpdate(builder, Val, Arg);
INode_setType(Arg, type);
IField_setHash((IField *) Val, i+1);
}
return Arg0;
}
static kbool_t FuelVM_VisitAssignNode(KonohaContext *kctx, KBuilder *builder, kNode *expr, void *thunk)
{
/*
* [LetExpr] := lhs = rhs
* expr->NodeList = [NULL, lhs, rhs]
**/
kNode *left = kNode_At(expr, 1);
kNode *right = kNode_At(expr, 2);
INode *Node;
FuelIRBuilder *flbuilder = BLD(builder);
if(left->node == KNode_Local) {
enum TypeId type = ConvertToTypeId(kctx, left->attrTypeId);
if((Node = IRBuilder_FindLocalVarByHash(flbuilder, type, left->index)) == 0) {
Node = CreateLocal(flbuilder, type);
IField_setHash((IField *) Node, left->index);
}
SUGAR VisitNode(kctx, builder, right, thunk);
INode *RHS = FuelVM_getExpression(builder);
//if(RHS->Type != Node->Type) {
// INode_setType(Node, RHS->Type);
//}
CreateUpdate(flbuilder, Node, RHS);
}
//else if(left->node == TEXPR_STACKTOP) {
// enum TypeId type = ConvertToTypeId(kctx, left->attrTypeId);
// uintptr_t Hash = (uintptr_t) left;
// if((Node = IRBuilder_FindLocalVarByHash(flbuilder, type, Hash)) == 0) {
// Node = CreateLocal(flbuilder, type);
// IField_setHash((IField *) Node, Hash);
// ARRAY_add(INodePtr, &BLD(builder)->Stack, Node);
// }
// SUGAR VisitNode(kctx, builder, right, thunk);
// INode *RHS = FuelVM_getExpression(builder);
// if(RHS->Type != Node->Type)
// INode_setType(Node, RHS->Type);
// CreateUpdate(BLD(builder), Node, RHS);
//}
else{
assert(left->node == KNode_Field);
SUGAR VisitNode(kctx, builder, right, thunk);
kshort_t index = (kshort_t)left->index;
kshort_t xindex = (kshort_t)(left->index >> (sizeof(kshort_t)*8));
INode *Left;
if((Left = IRBuilder_FindLocalVarByHash(BLD(builder), TYPE_Object, index)) == 0) {
Left = CreateLocal(BLD(builder), TYPE_Object);
IField_setHash((IField *) Left, index);
}
enum TypeId type = ConvertToTypeId(kctx, left->attrTypeId);
Node = CreateField(BLD(builder), FieldScope, type, Left, xindex);
SUGAR VisitNode(kctx, builder, right, thunk);
CreateUpdate(BLD(builder), Node, FuelVM_getExpression(builder));
}
builder->Value = Node;
return true;
}
zx_status_t MerkleTree::CreateFinalInternal(const void* data, void* tree, Digest* root) {
zx_status_t rc;
// Must call CreateInit first. Must call CreateUpdate with all data first.
if (!initialized_ || (level_ == 0 && offset_ != length_)) {
return ZX_ERR_BAD_STATE;
}
// Must have root to write and a tree to fill if expecting more than one
// digest.
if (!root || (!tree && length_ > kNodeSize)) {
return ZX_ERR_INVALID_ARGS;
}
// Special case: the level is empty.
if (length_ == 0) {
if ((rc = DigestInit(&digest_, 0, 0)) != ZX_OK) {
return rc;
}
DigestFinal(&digest_, 0);
}
// Consume padding if needed.
const uint8_t* tail = static_cast<const uint8_t*>(data) + offset_;
if ((rc = CreateUpdate(tail, length_ - offset_, tree)) != ZX_OK) {
return rc;
}
initialized_ = false;
// If the top, save the digest as the Merkle tree root and return.
if (length_ <= kNodeSize) {
*root = digest_.AcquireBytes();
digest_.ReleaseBytes();
return ZX_OK;
}
// Finalize the next level up.
uint8_t* next = static_cast<uint8_t*>(tree) + NextAligned(length_);
return next_->CreateFinalInternal(tree, next, root);
}
static void CreateCond(KonohaContext *kctx, KBuilder *builder, kNode *expr, enum ConditionalOp Op, void *thunk)
{
kNode *LHS = kNode_At(expr, 1);
kNode *RHS = kNode_At(expr, 2);
Block *HeadBB = CreateBlock(BLD(builder));
Block *ThenBB = CreateBlock(BLD(builder));
Block *MergeBB = CreateBlock(BLD(builder));
/* [CondExpr]
* LogicalAnd case
* | goto Head
* Head | let bval = LHS
* | if(bval) { goto Then } else { goto Merge }
* Then | bval = RHS
* | goto Merge
* Merge | ...
*/
INode *Node;
IRBuilder_JumpTo(BLD(builder), HeadBB);
{ /* Head */
IRBuilder_setBlock(BLD(builder), HeadBB);
Node = CreateLocal(BLD(builder), TYPE_boolean);
SUGAR VisitNode(kctx, builder, LHS, thunk);
INode *Left = FuelVM_getExpression(builder);
CreateUpdate(BLD(builder), Node, Left);
if(Op == LogicalAnd) {
CreateBranch(BLD(builder), Left, ThenBB, MergeBB);
} else {
CreateBranch(BLD(builder), Left, MergeBB, ThenBB);
}
}
{ /* Then */
IRBuilder_setBlock(BLD(builder), ThenBB);
SUGAR VisitNode(kctx, builder, RHS, thunk);
INode *Right = FuelVM_getExpression(builder);
CreateUpdate(BLD(builder), Node, Right);
IRBuilder_JumpTo(BLD(builder), MergeBB);
}
IRBuilder_setBlock(BLD(builder), MergeBB);
builder->Value = Node;
}
static void CreateCond(KonohaContext *kctx, KBuilder *builder, kUntypedNode *expr, enum ConditionalOp Op, void *thunk)
{
intptr_t cond;
kUntypedNode *LHS = kUntypedNode_At(expr, 1);
kUntypedNode *RHS = kUntypedNode_At(expr, 2);
bblock_t HeadBB = new_BasicBlockLABEL(kctx);
bblock_t ThenBB = new_BasicBlockLABEL(kctx);
bblock_t MergeBB = new_BasicBlockLABEL(kctx);
/* [CondExpr]
* LogicalAnd case
* | goto Head
* Head | let bval = LHS
* | if(bval) { goto Then } else { goto Merge }
* Then | bval = RHS
* | goto Merge
* Merge | ...
*/
MiniVMBuilder_JumpTo(kctx, builder, HeadBB);
cond = builder->stackbase;
builder->stackbase += 1;
{ /* Head */
MiniVMBuilder_setBlock(kctx, builder, HeadBB);
KLIB VisitNode(kctx, builder, LHS, thunk);
CreateUpdate(kctx, builder, KType_Boolean, cond, MiniVM_getExpression(builder));
if(Op == LogicalAnd)
CreateBranch(kctx, builder, cond, ThenBB, MergeBB, false);
else {
CreateBranch(kctx, builder, cond, ThenBB, MergeBB, true);
}
}
{ /* Then */
MiniVMBuilder_setBlock(kctx, builder, ThenBB);
KLIB VisitNode(kctx, builder, RHS, thunk);
CreateUpdate(kctx, builder, KType_Boolean, cond, MiniVM_getExpression(builder));
MiniVMBuilder_JumpTo(kctx, builder, MergeBB);
}
MiniVMBuilder_setBlock(kctx, builder, MergeBB);
builder->stackbase -= 1;
builder->Value = builder->stackbase;
}
int ProxyInst::InitProxy()
{
if (-1==CreateUpdate())
return -1;
NDListener *pLis = GetDeftListener() ;
nd_assert(pLis) ;
nd_handle h_listen = pLis->GetHandle() ;
nd_hook_data(h_listen, listen_data_handle);
read_remote_proxy(NDInstanceSrv::config_file, &g_remote_proxy ) ;
return 0;
}
static kbool_t MiniVM_VisitAssignNode(KonohaContext *kctx, KBuilder *builder, kUntypedNode *node, void *thunk)
{
/*
* [LetExpr] := lhs = rhs
* expr->NodeList = [NULL, lhs, rhs]
**/
intptr_t dst = -1;
kUntypedNode *left = kUntypedNode_At(node, 1);
kUntypedNode *right = kUntypedNode_At(node, 2);
ktypeattr_t type = left->typeAttr;
ksymbol_t symbol;
assert(IS_Token(left->TermToken));
symbol = left->TermToken->symbol;
if(kUntypedNode_node(left) == KNode_Local) {
if((dst = MiniVMBuilder_FindLocalVar(kctx, builder, symbol, type, left->index)) == -1) {
dst = AddLocal(kctx, builder, left->index, symbol, type);
}
KLIB VisitNode(kctx, builder, right, thunk);
CreateUpdate(kctx, builder, type, dst, MiniVM_getExpression(builder));
builder->Value = dst;
}
else {
khalfword_t index = (khalfword_t)left->index;
khalfword_t xindex = (khalfword_t)(left->index >> (sizeof(khalfword_t)*8));
KClass *lhsClass = KClass_(left->typeAttr);
KClass *rhsClass = KClass_(right->typeAttr);
assert(kUntypedNode_node(left) == KNode_Field);
if((dst = MiniVMBuilder_FindLocalVar(kctx, builder, symbol, KType_Object, index)) == -1) {
dst = AddLocal(kctx, builder, index, symbol, KType_Object);
}
KLIB VisitNode(kctx, builder, right, thunk);
ASM(XNMOV, OC_(index), xindex, TC_(MiniVM_getExpression(builder), rhsClass), lhsClass);
if(node->typeAttr != KType_void) {
builder->Value = builder->stackbase;
ASM(NMOVx, TC_(builder->stackbase, rhsClass), OC_(index), xindex, lhsClass);
}
}
return true;
}
static kbool_t FuelVM_VisitFunctionNode(KonohaContext *kctx, KBuilder *builder, kNode *expr, void *thunk)
{
/*
* [FunctionExpr] := new Function(method, env1, env2, ...)
* expr->NodeList = [method, defObj, env1, env2, ...]
**/
enum TypeId Type;
kMethod *mtd = CallNode_getMethod(expr);
kObject *obj = expr->NodeList->ObjectItems[1];
INode *MtdObj = CreateObject(BLD(builder), KType_Method, (void *) mtd);
Type = ConvertToTypeId(kctx, kObject_class(obj)->typeId);
INode *NewEnv = CreateNew(BLD(builder), 0, Type);
size_t i, ParamSize = kArray_size(expr->NodeList)-2;
for(i = 0; i < ParamSize; i++) {
kNode *envN = kNode_At(expr, i+2);
enum TypeId FieldType = ConvertToTypeId(kctx, envN->attrTypeId);
INode *Node = CreateField(BLD(builder), FieldScope, FieldType, NewEnv, i);
SUGAR VisitNode(kctx, builder, envN, thunk);
CreateUpdate(BLD(builder), Node, FuelVM_getExpression(builder));
}
Type = ConvertToTypeId(kctx, expr->attrTypeId);
INode *NewFunc = CreateNew(BLD(builder), 0, Type);
kNameSpace *ns = kNode_ns(expr);
mtd = KLIB kNameSpace_GetMethodByParamSizeNULL(kctx, ns, KClass_Func, KMethodName_("_Create"), 2, KMethodMatch_NoOption);
INode *CallMtd = CreateObject(BLD(builder), KType_Method, (void *) mtd);
INode *Params[4];
Params[0] = CallMtd;
Params[1] = NewFunc;
Params[2] = NewEnv;
Params[3] = MtdObj;
builder->Value = CreateICall(BLD(builder), Type, DefaultCall, kNode_uline(expr), Params, 4);
return true;
}
void *srv_thread_function(void *arg) {
printf("server thread started!\n"); // hooray
// initializing variables
ptsrv_thread_args targs = (ptsrv_thread_args) arg;
sim = targs->sim;
int PORT = targs->port;
int socketfd; /* Socket file descriptor */
struct sockaddr_in server_name; /* server socket's address */
struct sockaddr_in client_name; /* client socket's address */
fd_set active_fd_set, read_fd_set; /* Array of file descriptors */
int nbytes;
char buffer[BUFFER_SIZE];
int socketdest;
char* pacote;
char str_aux[80];
FILE* motd;
char name[150]; //robot name buffer
table = start_table();
/* Create the socket.
socket (NAMESPACE, STYLE, PROTOCOL)
- namespace: local, other, internet: PF_INET || PF_INET6
- style: SOCK_STREAM, SOCK_DGRAM
- protocol: 0 means 'auto' */
socketfd = socket (PF_INET, SOCK_STREAM, 0);
if (socketfd < 0)
fatal ();
/* Give the socket a name. */
server_name.sin_family = AF_INET; /* Ineternet family */
server_name.sin_port = htons (PORT); /* set port */
server_name.sin_addr.s_addr = htonl (INADDR_ANY); /* Any internetface */
/* Bind the socket to the port. */
if (bind (socketfd, (struct sockaddr *) &server_name, sizeof (server_name)) < 0)
fatal ();
// 23 apr 2010 - Disabling Nagle algorithm in the protocol stack, so it sends packages
// immeadiately, without waiting for more bytes to be available to send, which is more
// appropriate for this real-time program,
char flag = 1;
setsockopt(socketfd, IPPROTO_TCP, 1, (char *) &flag, sizeof(int));
/* Tell the OS to start to listen to the socket. */
if (listen (socketfd, 1) < 0)
fatal ();
/* Initialize the set of active sockets. */
FD_ZERO (&active_fd_set);
FD_SET (socketfd, &active_fd_set);
for (;;) {
int i,j;
/* Block until there is activity in the socket. */
read_fd_set = active_fd_set;
if (select (FD_SETSIZE, &read_fd_set, NULL, NULL, NULL) < 0)
fatal ();
/* Service all the sockets with input pending. */
for (i = 0; i < FD_SETSIZE; ++i) {
if (FD_ISSET (i, &read_fd_set)) {
if (i == socketfd) { /* Connection request on original socket. */
int new_socket;
socklen_t size;
/* Accept the the connection and associate it
with a new socket. */
size = sizeof (client_name);
new_socket = accept (socketfd, (struct sockaddr *) &client_name, &size);
if (new_socket < 0)
fatal ();
fprintf (stderr, "Server: connect from host %s, port %hd.\n", inet_ntoa (client_name.sin_addr), ntohs (client_name.sin_port));
FD_SET (new_socket, &active_fd_set); /* Add the new socket to the set of active fd */
// adding new user to the table
//add_user (table, inet_ntoa (client_name.sin_addr), new_socket);
add_user (table, new_socket);
}
else { /* Data arriving on an already-connected socket. */
nbytes = read (i, buffer, BUFFER_SIZE);
buffer[nbytes-1] = 0;
if (nbytes ==0) { /* Cient ended the transmission */
printf ("Client disconnected.\n");
remove_user (table, i);
print_table (table);
close (i);
FD_CLR (i, &active_fd_set);
}
else if (nbytes < 0) { /* Read error */
fprintf (stderr, "Read error, client disconnected.\n");
remove_user (table, i);
print_table (table);
close (i);
FD_CLR (i, &active_fd_set);
}
else { // client message
//debug
//printf("%s\n", buffer);
if (IsPackageValid(buffer, nbytes)) {
if (NewRobot(buffer, name)) { //new robot connected, get name
printf("New robot added: %s\n", name);
set_id(table, i, name); //add the new name to the table
strcpy(sim->robotnames[sim->num_available_clients], name);
sim->num_available_clients++;
print_table (table);
sim->clientlist_update = true;
//CreateUpdate(buffer, &nbytes, sim->GetRobot(get_id(table, i)));
//write(i, buffer, nbytes);
} else {
//update settings for this robot
if (GetUpdate(buffer, nbytes, sim->GetRobot(get_id(table, i))) ) {
//printf("got update from %s\n", sim->GetRobot(get_id(table, i))->robot_name);
CreateUpdate(buffer, &nbytes, sim->GetRobot(get_id(table, i)));
write(i, buffer, nbytes);
} else {
//printf("pacote de ok\n");
CreateUpdate(buffer, &nbytes, sim->GetRobot(get_id(table, i)));
write(i, buffer, nbytes);
}
}
}
//nbytes = write (i, buffer, strlen(buffer) + 1);
/*switch (get_tipo(buffer)) {
case 2: // mensagem privada;
nome = get_dest(buffer);
socketdest = busca_usuario(tabela, nome);
if (socketdest) {
nbytes = write (socketdest, buffer, strlen(buffer) + 1);
nbytes = write (i, buffer, strlen(buffer) + 1);
}
free(nome);
break;
case 3: //mensagem de sauda��o de novo usuario
nome = get_rem(buffer);
adiciona_usuario(tabela, nome, i);
imprime_tabela(tabela);
free(nome);
if ((motd = fopen("motd", "r")) != NULL) { // abre o Message Of The Day
while (fgets(str_aux,79, motd)) {
pacote = monta_pacote_sis(str_aux, nome);
nbytes = write (i, pacote, pacote[0]);
usleep(2000);
}
fclose(motd);
}
default: // mensagem comum (tambem repassa para todos os usuarios a mensagem de saudacao - case 3 nao tem break)
for (j = 3; j < FD_SETSIZE; ++j) {
if (j != socketfd) nbytes = write (j, buffer, strlen(buffer) + 1);
}
break;
case 4: // mensagens do sistema
switch (get_sis(buffer)) {
case 'l': // cliente requisitando a listagem de usuarios conectados
reset_iterator(tabela);
nome = get_rem(buffer);
strcpy(str_aux, "Usuarios conectados:\n");
pacote = monta_pacote_sis(str_aux, nome);
nbytes = write (i, pacote, pacote[0]);
free(pacote);
do {
usleep(2000);
strcpy(str_aux, get_next_nome(tabela));
strcat(str_aux, "\n");
pacote = monta_pacote_sis(str_aux, nome);
nbytes = write (i, pacote, pacote[0]);
free(pacote);
} while (! iterator_finished(tabela));
usleep(2000);
strcpy(str_aux, "Fim da listagem.\n");
pacote = monta_pacote_sis(str_aux, nome);
nbytes = write (i, pacote, pacote[0]);
free(pacote);
break;
}
break;
}*/
}
}
}
}
}
}
bool Location::SetRadius(iDataConnection* db, float radius)
{
SetRadius(radius);
return CreateUpdate(db);
}