Exemple #1
0
static void *_elim_request_authorise ( PurpleAccount *account      ,
                                       const char    *remote_user  ,
                                       const char    *id           ,
                                       const char    *alias        ,
                                       const char    *message      ,
                                       gboolean       on_list      ,
                                       PARA_CB        authorize_cb ,
                                       PARA_CB        deny_cb      ,
                                       void          *user_data    )
{
    CB_HANDLER *cbh   = g_new0( CB_HANDLER, 1 );
    AUI_RESP   *resp  = g_new0( AUI_RESP  , 1 );
    xmlnode    *alist = xnode_new( "alist" );
    char       *ID    = new_elim_id();
    fprintf( stderr, "(_elim_request_authorise)\n" );

    AL_STR ( alist, "user"        , remote_user  );
    AL_STR ( alist, "id"          , id           );
    AL_STR ( alist, "alias"       , alias        );
    AL_BOOL( alist, "on-list"     , on_list      );
    AL_STR ( alist, "message"     , message      );
    AL_PTR ( alist, "account-uid" , account      );
    AL_STR ( alist, "account-name", purple_account_get_username   ( account ) );
    AL_STR ( alist, "im-protocol" , purple_account_get_protocol_id( account ) );
    resp->ok   = authorize_cb;
    resp->nok  = deny_cb;
    resp->id   = ID;
    resp->data = user_data;
    cbh ->func = _elim_request_authorise_cb;
    cbh ->data = resp;
    store_cb_data( ID, cbh );
    xmlnode *mcall = func_call( "elim-account-request-auth", ID, alist );
    add_outbound_sexp( mcall );
    return cbh;
}
static void _elim_write_conv ( PurpleConversation *conv    ,
                               const char         *name    ,
                               const char         *alias   ,
                               const char         *message ,
                               PurpleMessageFlags  flags   ,
                               time_t mtime                )
{
    char    *msg   = NULL;
    char    *ID    = new_elim_id();
    xmlnode *args  = xnode_new( "alist" );
    xmlnode *mcall = func_call( "elim-conv-write-sys", ID, args );
    g_free( ID );
    fprintf( stderr, "(_elim_write_conv)\n" );

    if( _elim_strippable( conv, flags ) )
        msg = purple_markup_strip_html( message );

    _elim_conv_args( args, conv );
    AL_STR ( args, "who"  , (name  ? name  : (alias ? alias : "")) );
    AL_STR ( args, "alias", (alias ? alias : (name  ? name  : "")) );
    AL_STR ( args, "text" , msg ? msg : message );
    AL_ENUM( args, "flags", flags , ":message-flags" );
    AL_INT ( args, "time" , mtime );

    if( msg ) g_free( msg );
    fprintf( stderr, "(elim-debug _elim_write_conv:DONE)\n" );
    add_outbound_sexp( mcall );
}
int main(){
    int x = func_call();
    //float x = func_call();
    printf("Success returning int \n");
    //printf("Failure returning float \n");
    return 0;
}
static void _elim_connect_progress        ( PurpleConnection *gc ,
                                            const char     *text ,
                                            size_t          step ,
                                            size_t    step_count )
{
    PurpleAccount *acct = purple_connection_get_account( gc );
    fprintf( stderr, "(_elim_connect_progress)\n" );

    if( acct )
    {
        char       *ID    = new_elim_id();
        xmlnode    *alist = xnode_new( "alist" );
        xmlnode    *mcall = func_call( "elim-connection-progress", ID, alist );
        const char *aname = purple_account_get_username   ( acct );
        const char *proto = purple_account_get_protocol_id( acct );
        int         state = purple_connection_get_state   ( gc   );
        g_free( ID );

        AL_PTR ( alist, "account-uid" , acct       );
        AL_STR ( alist, "account-name", aname      );
        AL_STR ( alist, "im-protocol" , proto      );
        AL_INT ( alist, "step"        , step       );
        AL_INT ( alist, "step-count"  , step_count );        
        AL_STR ( alist, "message"     , text       );
        AL_ENUM( alist, "state"       , state      , ":connection-state" );

        add_outbound_sexp( mcall );
    }

}
static void _elim_report_disconnect_reason( PurpleConnection     *conn   ,
                                            PurpleConnectionError reason ,
                                            const char           *text   )
{
    PurpleAccount *acct = purple_connection_get_account( conn );
    if( acct )
    {
        char       *ID    = new_elim_id();
        xmlnode    *alist = xnode_new( "alist" );
        fprintf( stderr, "(_elim_report_disconnect_reason)\n" );

        xmlnode    *mcall = func_call( "elim-disconnect-reason", ID, alist );
        const char *aname = purple_account_get_username   ( acct );
        const char *proto = purple_account_get_protocol_id( acct );
        int         state = purple_connection_get_state   ( conn );
        g_free( ID );

        AL_PTR ( alist, "account-uid" , acct  );
        AL_STR ( alist, "account-name", aname );
        AL_STR ( alist, "im-protocol" , proto );
        AL_STR ( alist, "message"     , text  );
        AL_ENUM( alist, "reason-code" , reason, ":connection-error" );
        AL_ENUM( alist, "state"       , state , ":connection-state" );

        add_outbound_sexp( mcall );
    }
}
static void _elim_chat_add_users       ( PurpleConversation *conv         ,
                                         GList              *cbuddies     ,
                                         gboolean            new_arrivals )
{
    char    *ID    = new_elim_id();
    xmlnode *args  = xnode_new( "alist" );
    xmlnode *list  = xnode_new( "list"  );
    xmlnode *mcall = func_call( "elim-chat-add-users", ID, args );
    g_free( ID );
    fprintf( stderr, "(_elim_chat_add_users)\n" );

    _elim_conv_args( args, conv );
    AL_BOOL( args, "new-arrivals" , new_arrivals );
    AL_NODE( args, "participants" , list         );

    fprintf( stderr, "(_elim_chat_add_users)\n" );

    for( ; cbuddies; cbuddies = cbuddies->next )
    {
        xmlnode             *cbuddy = xnode_new( "alist" );
        PurpleConvChatBuddy *pccb   = cbuddies->data;

        AL_STR ( cbuddy, "name"     , pccb->name      ? pccb->name      : "" );
        AL_STR ( cbuddy, "alias"    , pccb->alias     ? pccb->alias     : "" );
        AL_STR ( cbuddy, "alias-key", pccb->alias_key ? pccb->alias_key : "" );
        AL_ENUM( cbuddy, "flags"    , pccb->flags , ":conv-chat-buddy-flags" );
        AL_BOOL( cbuddy, "on-blist" , pccb->buddy );

        xnode_insert_child( list, cbuddy );
    }

    add_outbound_sexp( mcall );
    fprintf( stderr, "(_elim_chat_add_users:DONE)\n" );
}
static void _elim_network    ( const char *call )
{
    char       *ID    = new_elim_id();
    xmlnode    *mcall = func_call( call , ID, NULL );
    fprintf( stderr, "(_elim_network)\n" );

    g_free( ID );
    add_outbound_sexp( mcall );
}
Exemple #8
0
static void method(struct context *context, struct byte_array *program, bool really)
{
    struct variable *indexable=NULL, *index;
    if (context->runtime) {
        indexable = variable_pop(context);
        index = variable_pop(context);
        lookup(context, indexable, index, really);
    }
    func_call(context, VM_MET, program, indexable);
}
static void _elim_destroy_conversation ( PurpleConversation *conv )
{
    char    *ID    = new_elim_id();
    xmlnode *args  = xnode_new( "alist" );
    xmlnode *mcall = func_call( "elim-conv-destroy", ID, args );
    g_free( ID );
    fprintf( stderr, "(_elim_destroy_conversation)\n" );
    _elim_conv_args( args, conv );
    add_outbound_sexp( mcall );
}
Exemple #10
0
static void _elim_roomlist_add ( PurpleRoomlist     *list ,
                                 PurpleRoomlistRoom *room )
{
    g_return_if_fail( list && room );

    xmlnode *alist  = xnode_new( "alist" );
    char    *ID     = new_elim_id();

    __roomlist_insert_account( list->account, alist );
    AL_PTR ( alist , "roomlist-id" , list          );
    AL_STR ( alist , "room-name"   , room->name    );
    AL_ENUM( alist , "room-type"   , room->type    , ":roomlist-room-type" );
    AL_PTR ( alist , "room-parent" , room->parent  );
    AL_BOOL( alist , "room-expanded-once", room->expanded_once );

    xmlnode *fields = xnode_new_child( alist, "alist" );
    xnode_set_attrib( fields, "name", "fields" );

    GList *listf = g_list_first( list->fields );
    GList *roomf = g_list_first( room->fields );

#define NNEXTT( a, b ) a = g_list_next( a ), b = g_list_next( b )
#define PTR_TO_BOOL(_p) (_p != NULL)

    for( ; listf && roomf ; NNEXTT( listf, roomf ) )
    {
        PurpleRoomlistField *f = (PurpleRoomlistField*) listf->data;
        switch( f->type )
        {
          case PURPLE_ROOMLIST_FIELD_BOOL:
            AL_BOOL( fields, f->name, PTR_TO_BOOL( roomf->data ) );
            break;

          case PURPLE_ROOMLIST_FIELD_INT:
            AL_INT ( fields, f->name, roomf->data );
            break;

          case PURPLE_ROOMLIST_FIELD_STRING:
            AL_STR ( fields, f->name, roomf->data );
            break;

          default:
            fprintf( stderr, "unsupported room list field type.\n" );
            break;
        }
    }

    xmlnode *mcall = func_call( "elim-roomlist-add", ID, alist );
    g_free( ID );
    add_outbound_sexp( mcall );
}
Exemple #11
0
static void _elim_roomlist_destroy ( PurpleRoomlist *list )
{
    g_return_if_fail( list );

    xmlnode *alist = xnode_new( "alist" );
    char     *ID   = new_elim_id();

    __roomlist_insert_account( list->account, alist );
    AL_PTR ( alist , "roomlist-id", list );

    xmlnode *mcall = func_call( "elim-roomlist-destroy", ID, alist );
    g_free( ID );
    add_outbound_sexp( mcall );
}
Exemple #12
0
static void _elim_roomlist_in_progress ( PurpleRoomlist *list ,
                                         gboolean        flag )
{
    g_return_if_fail( list );

    xmlnode *alist = xnode_new( "alist" );
    char    *ID    = new_elim_id();

    __roomlist_insert_account( list->account, alist );
    AL_PTR ( alist , "roomlist-id", list );
    AL_BOOL( alist , "in-progress", flag );

    xmlnode *mcall = func_call( "elim-roomlist-in-progress", ID, alist );
    g_free( ID );
    add_outbound_sexp( mcall );
}
Exemple #13
0
static void _elim_roomlist_create ( PurpleRoomlist *list )
{
    g_return_if_fail( list );

    xmlnode    *alist = xnode_new( "alist" );
    char       *ID    = new_elim_id();    
    
    __roomlist_insert_account( list->account, alist );
    AL_PTR ( alist, "roomlist-id", list );

    xmlnode *flist = xnode_new_child( alist, "alist" );
    xnode_set_attrib( flist, "name", "fields" );
    g_list_foreach( list->fields, __roomlist_add_list_field, flist );

    xmlnode *mcall = func_call( "elim-roomlist-create", ID, alist );
    g_free( ID );
    add_outbound_sexp( mcall );
}
static void _elim_chat_rename_user     ( PurpleConversation *conv      , 
                                         const char         *old_name  ,
                                         const char         *new_name  , 
                                         const char         *new_alias )
{
    char    *ID    = new_elim_id();
    xmlnode *args  = xnode_new( "alist" );
    xmlnode *mcall = func_call( "elim-chat-rename-user", ID, args );
    g_free( ID );
    fprintf( stderr, "(_elim_chat_rename_user)\n" );

    _elim_conv_args( args, conv );
    AL_STR( args, "old-name" , old_name  );
    AL_STR( args, "new-name" , new_name  );
    AL_STR( args, "new-alias", new_alias );
    
    add_outbound_sexp( mcall );
}
Exemple #15
0
static void _elim_notify_added ( PurpleAccount *account    ,
                                 const char    *remote_user,
                                 const char    *id         ,
                                 const char    *alias      ,
                                 const char    *message    )
{
    xmlnode *alist = xnode_new( "alist" );
    char    *ID    = new_elim_id();
    fprintf( stderr, "(_elim_notify_added)\n" );

    AL_STR( alist, "user"         , remote_user  );
    AL_STR( alist, "alias"        , alias        );
    AL_STR( alist, "message"      , message      );
    AL_PTR( alist, "account-uid"  , account      );
    AL_STR( alist, "account-name" , purple_account_get_username   ( account ) );
    AL_STR( alist, "im-protocol"  , purple_account_get_protocol_id( account ) );
    xmlnode *mcall = func_call( "elim-account-notify-added", ID, alist );
    g_free( ID );
    add_outbound_sexp( mcall );
}
Exemple #16
0
static void _elim_notice ( PurpleConnection *conn, const char *msg )
{
    PurpleAccount *acct = purple_connection_get_account( conn );
    if( acct )
    {
        char       *ID    = new_elim_id();
        xmlnode    *alist = xnode_new( "alist" );
        xmlnode    *mcall = func_call( "elim-connection-state", ID, alist );
        const char *aname = purple_account_get_username   ( acct );
        const char *proto = purple_account_get_protocol_id( acct );
        int         state = purple_connection_get_state   ( conn );
        g_free( ID );

        AL_PTR ( alist, "account-uid" , acct  );
        AL_STR ( alist, "account-name", aname );
        AL_STR ( alist, "im-protocol" , proto );
        AL_STR ( alist, "message"     , msg   );
        AL_ENUM( alist, "state"       , state , ":connection-state" );

        add_outbound_sexp( mcall );
    }
}
Exemple #17
0
static void _elim_status_changed ( PurpleAccount *account ,
                                   PurpleStatus  *status  )
{
    xmlnode              *alist = xnode_new( "alist" );
    char                 *ID    = new_elim_id();
    fprintf( stderr, "(_elim_status_changed)\n" );

    PurpleStatusType     *type  = purple_status_get_type( status );
    PurpleStatusPrimitive statp = purple_status_type_get_primitive( type ); 

    AL_PTR ( alist, "account-uid" , account );
    AL_STR ( alist, "account-name", purple_account_get_username   ( account ) );
    AL_STR ( alist, "im-protocol" , purple_account_get_protocol_id( account ) );
    AL_STR ( alist, "status-name" , purple_status_get_name        ( status  ) );
    AL_ENUM( alist, "status-type" , statp, ":status-primitive" );
    AL_BOOL( alist, "connected"   , purple_account_is_connected   ( account ) );

    xmlnode *mcall = func_call( "elim-account-status-changed", ID, alist );

    g_free( ID );
    add_outbound_sexp( mcall );
}
static void _elim_chat_remove_users    ( PurpleConversation *conv  , 
                                         GList              *users )
{
    char    *ID    = new_elim_id();
    xmlnode *args  = xnode_new( "alist" );
    xmlnode *mcall = func_call( "elim-chat-remove-users", ID, args );
    xmlnode *list  = xnode_new( "list" );
    g_free( ID );
    fprintf( stderr, "(_elim_chat_remove_users)\n" );

    _elim_conv_args( args, conv );
    for( ; users; users = users->next )
    {
        xmlnode *user = xnode_new_child( list, "string" );
        xnode_insert_data( user, users->data ? users->data : "", -1 );
    }

    AL_NODE( args, "participants", list );

    fprintf( stderr, "(_elim_chat_remove_users:DONE)\n" );
    add_outbound_sexp( mcall );
}
Exemple #19
0
int main(int argc, char** argv){

	// Get time of mininmal function call in C
	clock_gettime(CLOCK_ID,&func_start);
	func_call();
	clock_gettime(CLOCK_ID,&func_end);
	func_time = get_time(func_start, func_end);

	// Get time of minimal system call in C
	clock_gettime(CLOCK_ID,&sys_start);
	sys_call();
	clock_gettime(CLOCK_ID,&sys_end);
	sys_time = get_time(sys_start,sys_end);

	// Calculate the time difference between the two calls
	time_diff = sys_time - func_time;

	// Print the time difference
	printf("The time it takes to do a minimum function call in C: %llu(ns)\n", (long long unsigned int) func_time);
	printf("The time it takes to do a minimum system call in C: %llu(ns)\n", (long long unsigned int) sys_time);
	printf("The time difference between a system call and a function call in C: %llu(ns)\n", (long long unsigned int) time_diff);

	exit(EXIT_SUCCESS);
} 
int
main ()
{
  int x = 17;
  int *xP, **xPP;
  char buf[200];
  char *s;
  int *ai;
  float *af;

  func_intptr(&x);

  func_intptr_ret(&x);

  func_string("zero\0xxxxxxxxxxxxxx");
  func_strlen(buf);

  extern int func_arg0(char *);
  func_arg0(buf);

  printf("%s\n", buf);

  func_strfixed(buf);
  printf("%s\n", buf);

  x = 80;
  xP = &x;
  xPP = &xP;
  func_ppp(&xPP);

  s = (char*) malloc(100);
  strcpy(s, "Dude");
  func_stringp(&s);

  func_enum(BLUE);

  func_short(-8, -9);
  func_ushort(33, 34);
  float f = func_float(3.4, -3.4);
  double d = func_double(3.4, -3.4);

  func_typedef(BLUE);

  ai = (int*) calloc(sizeof(int), 8);
  for (x = 0; x < 8; x++)
    ai[x] = 10 + x;
  func_arrayi(ai, 8);
  func_arrayi(ai, 2);

  af = (float*) calloc(sizeof(float), 8);
  for (x = 0; x < 8; x++)
    af[x] = 10.1 + x;
  func_arrayf(af, 8);
  func_arrayf(af, 2);

  {
    struct {
      int simple;
      int alen;
      int slen;
      struct { int a; int b; }* array;
      struct { int a; int b; } seq[3];
      char* str;
    } x;

    x.simple = 89;

    x.alen = 2;
    x.array = malloc(800);
    x.array[0].a = 1;
    x.array[0].b = 10;
    x.array[1].a = 3;
    x.array[1].b = 30;

    x.seq[0].a = 4;
    x.seq[0].b = 40;
    x.seq[1].a = 5;
    x.seq[1].b = 50;
    x.seq[2].a = 6;
    x.seq[2].b = 60;

    x.slen = 3;
    x.str = "123junk";

    func_struct(&x);
  }

  {
    char x[10] = {};
    char y[10] = {};
    func_call(x, y, call_func_work);
  }

  struct S2 {
    float f;
    char a;
    char b;
  };
  struct S3 {
    char a[6];
    float f;
  };
  struct S2 func_struct_2(int, struct S3 s3, double d);
  func_struct_2(17, (struct S3){ "ABCDE", 0.25 }, 0.5);
Exemple #21
0
gint snoop()
{
	switch(in_state)
	{
	case STATE_CMD:
		if((cmd_in_cnt < 3 && cmd_in_cnt > 0 && cmd_in_need) || cmd_in_cnt == 0)
		{
			/*
			  modifiers set here
			*/

			cmd_in_buf[cmd_in_cnt].keyval = key_event->keyval;
			cmd_in_buf[cmd_in_cnt].keyval_type = KT_SINGLE;

			int found;
			found = shortcut_find(cmd_in_buf);

			cmd_in_cnt++;

			if(found >= 0)
			{
				/* this is not parameter */
				if(!cmd_current)
				{
					/* function does not have any parameters */
					if(commands[found]->param_type==PT_NONE)
					{
						func_call(commands[found],cmd_repeat_cnt,NULL);
					}
					/* this cmd is parameter for function */
					else
					{
						in_state = commands[found]->param_type;
						cmd_current = commands[found];
					}
				}
				/* this is a parameter */
				else
				{
					cmd_param_data = malloc(sizeof(emacs_keybinding));
					*cmd_param_data = commands[found];

					func_call(commands[found],cmd_repeat_cnt,cmd_param_data);
				}

				input_reset();
				return TRUE;
			}
			else if(found == -2) //maybe found
			{
				cmd_in_need = TRUE;
				return TRUE;
			}
			else if(found == -1) //not found
			{
				input_reset();
				return FALSE;
			}
		}//if(cmd_in_cmd < 3 && ...
		break;

	case STATE_KEY:
		emacs_hotkey cur_key;
		cur_key.keyval = event->keyval;
		//k.alt = ...
		/* modifiers set here */

		cmd_param_data = malloc(sizeof(emacs_hotkey));
		*cmd_param_data = cur_key;

		func_call(cmd_current,cmd_repeat_cnt,cmd_param_data);
		input_reset();
		break;

	case STATE_INT:
		if(!cmd_param_data)
		{
			cmd_param_data = malloc(sizeof(int));
			*cmd_param_data = 0;
		}

		param_in_cnt++;

		gint data = *cmd_param_data;
		data  = keyval2int(event->keyval)*pow(param_in_cnt,10) + data;
		*cmd_param_data = data;

		break;
	case STATE_STR:
		if(!cmd_param_data)
		{
			cmd_param_data  = malloc(sizeof(gchar)*PARAM_STR_MAX);
		}

		param_in_cnt++;

		gchar data = cmd_param_data[param_in_cnt];
		data = keyval2char(event->keyval);
		cmd_param_data[param_in_cnt];
		break;

	}
}
Exemple #22
0
bool run(struct context *context,
         struct byte_array *program,
         struct map *env,
         bool in_context)
{
    null_check(context);
    null_check(program);
    program = byte_array_copy(program);
    program->current = program->data;
    struct program_state *state = NULL;
    enum Opcode inst = VM_NIL;
    if (context->runtime) {
        if (in_context) {
            if (!state)
                state = (struct program_state*)stack_peek(context->program_stack, 0);
            env = state->named_variables; // use the caller's variable set in the new state
        }
        else
            state = program_state_new(context, env);
    }

    while (program->current < program->data + program->length) {
        inst = (enum Opcode)*program->current;
        bool really = inst & VM_RLY;
        inst &= ~VM_RLY;
#ifdef DEBUG
        display_program_counter(context, program);
#endif
        program->current++; // increment past the instruction
        int32_t pc_offset = 0;

        switch (inst) {
            case VM_COM:
            case VM_ITR:    if (iterate(context, inst, state, program)) goto done;  break;
            case VM_RET:    if (ret(context, program))                  goto done;  break;
            case VM_TRO:    if (tro(context))                           goto done;  break;
            case VM_TRY:    if (vm_trycatch(context, program))          goto done;  break;
            case VM_EQU:
            case VM_MUL:
            case VM_DIV:
            case VM_ADD:
            case VM_SUB:
            case VM_NEQ:
            case VM_GTN:
            case VM_LTN:
            case VM_GRQ:
            case VM_LEQ:
            case VM_BND:
            case VM_BOR:
            case VM_MOD:
            case VM_XOR:
            case VM_INV:
            case VM_RSF:
            case VM_LSF:    binary_op(context, inst);                       break;
            case VM_ORR:
            case VM_AND:    pc_offset = boolean_op(context, program, inst); break;
            case VM_NEG:
            case VM_NOT:    unary_op(context, inst);                        break;
            case VM_SRC:    src(context, inst, program);                    break;
            case VM_DST:    dst(context, really);                           break;
            case VM_STX:
            case VM_SET:    set(context, inst, state, program);             break;
            case VM_JMP:    pc_offset = jump(context, program);             break;
            case VM_IFF:    pc_offset = iff(context, program);              break;
            case VM_CAL:    func_call(context, inst, program, NULL);        break;
            case VM_LST:    push_list(context, program);                    break;
            case VM_MAP:    push_map(context, program);                     break;
            case VM_NIL:    push_nil(context);                              break;
            case VM_INT:    push_int(context, program);                     break;
            case VM_FLT:    push_float(context, program);                   break;
            case VM_BUL:    push_bool(context, program);                    break;
            case VM_STR:    push_str(context, program);                     break;
            case VM_VAR:    push_var(context, program);                     break;
            case VM_FNC:    push_fnc(context, program);                     break;
            case VM_GET:    list_get(context, really);                      break;
            case VM_PTX:
            case VM_PUT:    list_put(context, inst, really);                break;
            case VM_MET:    method(context, program, really);               break;
            default:
                vm_exit_message(context, ERROR_OPCODE);
                return false;
        }
        program->current += pc_offset;
    }

    if (!context->runtime)
        return false;
done:
    if (!in_context)
        stack_pop(context->program_stack);
    return inst == VM_RET;
}