[doldaconnect.git] / lib / guile / dolcon-guile.c

#include <stdlib.h>
#include <stdio.h>
#include <sys/poll.h>
#include <errno.h>
#include <libguile.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <doldaconnect/uilib.h>
#include <doldaconnect/uimisc.h>
#include <doldaconnect/utils.h>

struct respsmob
{
    struct dc_response *resp;
};

struct scmcb
{
    SCM subr;
};

static int fd = -1;
static scm_bits_t resptype;

static SCM scm_dc_connect(SCM host, SCM port)
{
    int cport;
    
    SCM_ASSERT(SCM_STRINGP(host), host, SCM_ARG1, "dc-connect");
    if(port == SCM_UNDEFINED)
    {
	cport = -1;
    } else {
	SCM_ASSERT(SCM_INUMP(port), port, SCM_ARG2, "dc-connect");
	cport = SCM_INUM(port);
    }
    if(fd >= 0)
	dc_disconnect();
    if((fd = dc_connect(SCM_STRING_CHARS(host), cport)) < 0)
	scm_syserror("dc-connect");
    return(SCM_MAKINUM(fd));
}

static SCM scm_dc_disconnect(void)
{
    dc_disconnect();
    return(SCM_MAKINUM(0));
}

static SCM scm_dc_connected(void)
{
    return((fd == -1)?SCM_BOOL_F:SCM_BOOL_T);
}

static SCM scm_dc_select(SCM timeout)
{
    struct pollfd pfd;
    int cto, ret, enob;
    
    if(timeout == SCM_UNDEFINED)
    {
	cto = -1;
    } else {
	SCM_ASSERT(SCM_INUMP(timeout), timeout, SCM_ARG1, "dc-select");
	cto = SCM_INUM(timeout);
    }
    if(fd < 0)
	scm_syserror_msg("dc-select", "Not connected", SCM_EOL, ENOTCONN);
    pfd.fd = fd;
    pfd.events = POLLIN;
    if(dc_wantwrite())
	pfd.events |= POLLOUT;
    if((ret = poll(&pfd, 1, cto)) < 0)
    {
	if(errno == EINTR)
	    return(SCM_BOOL_F);
	enob = errno;
	dc_disconnect();
	errno = enob;
	scm_syserror("dc-select");
    }
    if(((pfd.revents & POLLIN) && dc_handleread()) || ((pfd.revents & POLLOUT) && dc_handlewrite()))
    {
	if(errno == 0)
	{
	    fd = -1;
	    return(SCM_BOOL_F);
	}
	scm_syserror("dc-select");
    }
    return(ret?SCM_BOOL_T:SCM_BOOL_F);
}

static SCM makerespsmob(struct dc_response *resp)
{
    struct respsmob *data;
    
    data = scm_must_malloc(sizeof(*data), "respsmob");
    data->resp = resp;
    SCM_RETURN_NEWSMOB(resptype, data);
}

static SCM scm_dc_getresp(SCM tag)
{
    struct dc_response *resp;
    SCM ret;
    
    if(tag == SCM_UNDEFINED)
    {
	if((resp = dc_getresp()) == NULL)
	    return(SCM_BOOL_F);
    } else {
	SCM_ASSERT(SCM_INUMP(tag), tag, SCM_ARG1, "dc-getresp");
	if((resp = dc_gettaggedresp(SCM_INUM(tag))) == NULL)
	    return(SCM_BOOL_F);
    }
    ret = makerespsmob(resp);
    return(ret);
}

static SCM scm_dc_extract(SCM scm_resp)
{
    int i, o;
    struct dc_response *resp;
    SCM ret, l, w;
    
    SCM_ASSERT(SCM_SMOB_PREDICATE(resptype, scm_resp), scm_resp, SCM_ARG1, "dc-extract");
    resp = ((struct respsmob *)SCM_SMOB_DATA(scm_resp))->resp;
    ret = SCM_EOL;
    ret = scm_cons(scm_cons(scm_str2symbol("cmd"), scm_makfrom0str(icswcstombs(resp->cmdname, "UTF-8", NULL))), ret);
    ret = scm_cons(scm_cons(scm_str2symbol("code"), SCM_MAKINUM(resp->code)), ret);
    ret = scm_cons(scm_cons(scm_str2symbol("tag"), SCM_MAKINUM(resp->tag)), ret);
    l = SCM_EOL;
    for(i = resp->numlines - 1; i >= 0; i--)
    {
	w = SCM_EOL;
	for(o = resp->rlines[i].argc - 1; o >= 0; o--)
	    w = scm_cons(scm_makfrom0str(icswcstombs(resp->rlines[i].argv[o], "UTF-8", NULL)), w);
	l = scm_cons(w, l);
    }
    ret = scm_cons(scm_cons(scm_str2symbol("resp"), l), ret);
    return(ret);
}

static SCM scm_dc_intresp(SCM scm_resp)
{
    int i;
    struct dc_response *resp;
    struct dc_intresp *ires;
    SCM ret;
    
    SCM_ASSERT(SCM_SMOB_PREDICATE(resptype, scm_resp), scm_resp, SCM_ARG1, "dc-intresp");
    resp = ((struct respsmob *)SCM_SMOB_DATA(scm_resp))->resp;
    if((ires = dc_interpret(resp)) == NULL)
	return(SCM_BOOL_F);
    ret = SCM_EOL;
    for(i = ires->argc - 1; i >= 0; i--)
    {
	switch(ires->argv[i].type)
	{
	case 1:
	    ret = scm_cons(scm_makfrom0str(icswcstombs(ires->argv[i].val.str, "UTF-8", NULL)), ret);
	    break;
	case 2:
	    ret = scm_cons(scm_int2num(ires->argv[i].val.num), ret);
	    break;
	case 3:
	    ret = scm_cons(scm_double2num(ires->argv[i].val.flnum), ret);
	    break;
	}
    }
    dc_freeires(ires);
    return(ret);
}

static int qcmd_scmcb(struct dc_response *resp)
{
    struct scmcb *scmcb;
    
    scmcb = resp->data;
    scm_apply(scmcb->subr, scm_cons(makerespsmob(resp), SCM_EOL), SCM_EOL);
    scm_gc_unprotect_object(scmcb->subr);
    free(scmcb);
    return(2);
}

static SCM scm_dc_qcmd(SCM argv, SCM callback)
{
    int tag, enob;
    wchar_t **toks, *tok, *cmd;
    size_t tokssize, toksdata;
    SCM port;
    struct scmcb *scmcb;
    
    SCM_ASSERT(SCM_CONSP(argv), argv, SCM_ARG1, "dc-qcmd");
    if(callback != SCM_UNDEFINED)
	SCM_ASSERT(SCM_CLOSUREP(callback), callback, SCM_ARG2, "dc-qcmd");
    cmd = NULL;
    toks = NULL;
    tokssize = toksdata = 0;
    for(; argv != SCM_EOL; argv = SCM_CDR(argv))
    {
	port = scm_open_output_string();
	scm_display(SCM_CAR(argv), port);
	if((tok = icmbstowcs(SCM_STRING_CHARS(scm_get_output_string(port)), "UTF-8")) == NULL)
	{
	    enob = errno;
	    addtobuf(toks, NULL);
	    dc_freewcsarr(toks);
	    if(cmd != NULL)
		free(cmd);
	    errno = enob;
	    scm_syserror("dc-qcmd");
	}
	if(cmd == NULL)
	    cmd = tok;
	else
	    addtobuf(toks, tok);
    }
    addtobuf(toks, NULL);
    if(callback == SCM_UNDEFINED)
    {
	tag = dc_queuecmd(NULL, NULL, cmd, L"%%a", toks, NULL);
    } else {
	scmcb = scm_must_malloc(sizeof(*scmcb), "scmcb");
	scm_gc_protect_object(scmcb->subr = callback);
	tag = dc_queuecmd(qcmd_scmcb, scmcb, cmd, L"%%a", toks, NULL);
    }
    dc_freewcsarr(toks);
    if(cmd != NULL)
	free(cmd);
    return(SCM_MAKINUM(tag));
}

static void login_scmcb(int err, wchar_t *reason, struct scmcb *scmcb)
{
    SCM errsym;
    
    switch(err)
    {
    case DC_LOGIN_ERR_SUCCESS:
	errsym = scm_str2symbol("success");
	break;
    case DC_LOGIN_ERR_NOLOGIN:
	errsym = scm_str2symbol("nologin");
	break;
    case DC_LOGIN_ERR_SERVER:
	errsym = scm_str2symbol("server");
	break;
    case DC_LOGIN_ERR_USER:
	errsym = scm_str2symbol("user");
	break;
    case DC_LOGIN_ERR_CONV:
	errsym = scm_str2symbol("conv");
	break;
    case DC_LOGIN_ERR_AUTHFAIL:
	errsym = scm_str2symbol("authfail");
	break;
    }
    scm_apply(scmcb->subr, scm_cons(errsym, scm_cons((reason == NULL)?SCM_BOOL_F:scm_makfrom0str(icswcstombs(reason, "UTF-8", NULL)), SCM_EOL)), SCM_EOL);
    scm_gc_unprotect_object(scmcb->subr);
    free(scmcb);
}

static SCM scm_dc_loginasync(SCM callback, SCM useauthless, SCM username)
{
    struct scmcb *scmcb;
    
    SCM_ASSERT(SCM_CLOSUREP(callback), callback, SCM_ARG1, "dc-loginasync");
    scmcb = scm_must_malloc(sizeof(*scmcb), "scmcb");
    scm_gc_protect_object(scmcb->subr = callback);
    dc_loginasync(SCM_STRINGP(username)?SCM_STRING_CHARS(username):NULL, SCM_NFALSEP(useauthless), NULL, (void (*)(int, wchar_t *, void *))login_scmcb, scmcb);
    return(SCM_BOOL_T);
}

static SCM scm_dc_lexsexpr(SCM sexpr)
{
    SCM ret;
    wchar_t **arr, **ap, *buf;
    
    SCM_ASSERT(SCM_STRINGP(sexpr), sexpr, SCM_ARG1, "dc-lexsexpr");
    if((buf = icmbstowcs(SCM_STRING_CHARS(sexpr), NULL)) == NULL)
	scm_syserror("dc-lexsexpr");
    arr = dc_lexsexpr(buf);
    free(buf);
    ret = SCM_EOL;
    if(arr != NULL)
    {
	for(ap = arr; *ap != NULL; ap++)
	    ret = scm_cons(scm_makfrom0str(icswcstombs(*ap, "UTF-8", NULL)), ret);
	dc_freewcsarr(arr);
    }
    return(scm_reverse(ret));
}

static size_t resp_free(SCM respsmob)
{
    struct respsmob *data;
    
    data = (struct respsmob *)SCM_SMOB_DATA(respsmob);
    dc_freeresp(data->resp);
    free(data);
    return(sizeof(*data));
}

static int resp_print(SCM respsmob, SCM port, scm_print_state *pstate)
{
    struct respsmob *data;
    
    data = (struct respsmob *)SCM_SMOB_DATA(respsmob);
    scm_puts("#<dc-response ", port);
    scm_display(SCM_MAKINUM(data->resp->tag), port);
    scm_puts(" ", port);
    scm_puts(icswcstombs(data->resp->cmdname, "UTF-8", NULL), port);
    scm_puts(" ", port);
    scm_display(SCM_MAKINUM(data->resp->code), port);
    scm_puts(">", port);
    return(1);
}

void init_guiledc(void)
{
    scm_c_define_gsubr("dc-connect", 1, 1, 0, scm_dc_connect);
    scm_c_define_gsubr("dc-disconnect", 0, 0, 0, scm_dc_disconnect);
    scm_c_define_gsubr("dc-connected", 0, 0, 0, scm_dc_connected);
    scm_c_define_gsubr("dc-select", 0, 1, 0, scm_dc_select);
    scm_c_define_gsubr("dc-getresp", 0, 1, 0, scm_dc_getresp);
    scm_c_define_gsubr("dc-extract", 1, 0, 0, scm_dc_extract);
    scm_c_define_gsubr("dc-intresp", 1, 0, 0, scm_dc_intresp);
    scm_c_define_gsubr("dc-qcmd", 1, 1, 0, scm_dc_qcmd);
    scm_c_define_gsubr("dc-loginasync", 2, 1, 0, scm_dc_loginasync);
    scm_c_define_gsubr("dc-lexsexpr", 1, 0, 0, scm_dc_lexsexpr);
    resptype = scm_make_smob_type("dc-resp", sizeof(struct respsmob));
    scm_set_smob_free(resptype, resp_free);
    scm_set_smob_print(resptype, resp_print);
    dc_init();
}
Commit	Line	Data
	1	#include <stdlib.h>
	2	#include <stdio.h>
	3	#include <sys/poll.h>
	4	#include <errno.h>
	5	#include <libguile.h>
	6
	7	#ifdef HAVE_CONFIG_H
	8	#include <config.h>
	9	#endif
	10	#include <doldaconnect/uilib.h>
	11	#include <doldaconnect/uimisc.h>
	12	#include <doldaconnect/utils.h>
	13
	14	struct respsmob
	15	{
	16	struct dc_response *resp;
	17	};
	18
	19	struct scmcb
	20	{
	21	SCM subr;
	22	};
	23
	24	static int fd = -1;
	25	static scm_bits_t resptype;
	26
	27	static SCM scm_dc_connect(SCM host, SCM port)
	28	{
	29	int cport;
	30
	31	SCM_ASSERT(SCM_STRINGP(host), host, SCM_ARG1, "dc-connect");
	32	if(port == SCM_UNDEFINED)
	33	{
	34	cport = -1;
	35	} else {
	36	SCM_ASSERT(SCM_INUMP(port), port, SCM_ARG2, "dc-connect");
	37	cport = SCM_INUM(port);
	38	}
	39	if(fd >= 0)
	40	dc_disconnect();
	41	if((fd = dc_connect(SCM_STRING_CHARS(host), cport)) < 0)
	42	scm_syserror("dc-connect");
	43	return(SCM_MAKINUM(fd));
	44	}
	45
	46	static SCM scm_dc_disconnect(void)
	47	{
	48	dc_disconnect();
	49	return(SCM_MAKINUM(0));
	50	}
	51
	52	static SCM scm_dc_connected(void)
	53	{
	54	return((fd == -1)?SCM_BOOL_F:SCM_BOOL_T);
	55	}
	56
	57	static SCM scm_dc_select(SCM timeout)
	58	{
	59	struct pollfd pfd;
	60	int cto, ret, enob;
	61
	62	if(timeout == SCM_UNDEFINED)
	63	{
	64	cto = -1;
	65	} else {
	66	SCM_ASSERT(SCM_INUMP(timeout), timeout, SCM_ARG1, "dc-select");
	67	cto = SCM_INUM(timeout);
	68	}
	69	if(fd < 0)
	70	scm_syserror_msg("dc-select", "Not connected", SCM_EOL, ENOTCONN);
	71	pfd.fd = fd;
	72	pfd.events = POLLIN;
	73	if(dc_wantwrite())
	74	pfd.events \|= POLLOUT;
	75	if((ret = poll(&pfd, 1, cto)) < 0)
	76	{
	77	if(errno == EINTR)
	78	return(SCM_BOOL_F);
	79	enob = errno;
	80	dc_disconnect();
	81	errno = enob;
	82	scm_syserror("dc-select");
	83	}
	84	if(((pfd.revents & POLLIN) && dc_handleread()) \|\| ((pfd.revents & POLLOUT) && dc_handlewrite()))
	85	{
	86	if(errno == 0)
	87	{
	88	fd = -1;
	89	return(SCM_BOOL_F);
	90	}
	91	scm_syserror("dc-select");
	92	}
	93	return(ret?SCM_BOOL_T:SCM_BOOL_F);
	94	}
	95
	96	static SCM makerespsmob(struct dc_response *resp)
	97	{
	98	struct respsmob *data;
	99
	100	data = scm_must_malloc(sizeof(*data), "respsmob");
	101	data->resp = resp;
	102	SCM_RETURN_NEWSMOB(resptype, data);
	103	}
	104
	105	static SCM scm_dc_getresp(SCM tag)
	106	{
	107	struct dc_response *resp;
	108	SCM ret;
	109
	110	if(tag == SCM_UNDEFINED)
	111	{
	112	if((resp = dc_getresp()) == NULL)
	113	return(SCM_BOOL_F);
	114	} else {
	115	SCM_ASSERT(SCM_INUMP(tag), tag, SCM_ARG1, "dc-getresp");
	116	if((resp = dc_gettaggedresp(SCM_INUM(tag))) == NULL)
	117	return(SCM_BOOL_F);
	118	}
	119	ret = makerespsmob(resp);
	120	return(ret);
	121	}
	122
	123	static SCM scm_dc_extract(SCM scm_resp)
	124	{
	125	int i, o;
	126	struct dc_response *resp;
	127	SCM ret, l, w;
	128
	129	SCM_ASSERT(SCM_SMOB_PREDICATE(resptype, scm_resp), scm_resp, SCM_ARG1, "dc-extract");
	130	resp = ((struct respsmob *)SCM_SMOB_DATA(scm_resp))->resp;
	131	ret = SCM_EOL;
	132	ret = scm_cons(scm_cons(scm_str2symbol("cmd"), scm_makfrom0str(icswcstombs(resp->cmdname, "UTF-8", NULL))), ret);
	133	ret = scm_cons(scm_cons(scm_str2symbol("code"), SCM_MAKINUM(resp->code)), ret);
	134	ret = scm_cons(scm_cons(scm_str2symbol("tag"), SCM_MAKINUM(resp->tag)), ret);
	135	l = SCM_EOL;
	136	for(i = resp->numlines - 1; i >= 0; i--)
	137	{
	138	w = SCM_EOL;
	139	for(o = resp->rlines[i].argc - 1; o >= 0; o--)
	140	w = scm_cons(scm_makfrom0str(icswcstombs(resp->rlines[i].argv[o], "UTF-8", NULL)), w);
	141	l = scm_cons(w, l);
	142	}
	143	ret = scm_cons(scm_cons(scm_str2symbol("resp"), l), ret);
	144	return(ret);
	145	}
	146
	147	static SCM scm_dc_intresp(SCM scm_resp)
	148	{
	149	int i;
	150	struct dc_response *resp;
	151	struct dc_intresp *ires;
	152	SCM ret;
	153
	154	SCM_ASSERT(SCM_SMOB_PREDICATE(resptype, scm_resp), scm_resp, SCM_ARG1, "dc-intresp");
	155	resp = ((struct respsmob *)SCM_SMOB_DATA(scm_resp))->resp;
	156	if((ires = dc_interpret(resp)) == NULL)
	157	return(SCM_BOOL_F);
	158	ret = SCM_EOL;
	159	for(i = ires->argc - 1; i >= 0; i--)
	160	{
	161	switch(ires->argv[i].type)
	162	{
	163	case 1:
	164	ret = scm_cons(scm_makfrom0str(icswcstombs(ires->argv[i].val.str, "UTF-8", NULL)), ret);
	165	break;
	166	case 2:
	167	ret = scm_cons(scm_int2num(ires->argv[i].val.num), ret);
	168	break;
	169	case 3:
	170	ret = scm_cons(scm_double2num(ires->argv[i].val.flnum), ret);
	171	break;
	172	}
	173	}
	174	dc_freeires(ires);
	175	return(ret);
	176	}
	177
	178	static int qcmd_scmcb(struct dc_response *resp)
	179	{
	180	struct scmcb *scmcb;
	181
	182	scmcb = resp->data;
	183	scm_apply(scmcb->subr, scm_cons(makerespsmob(resp), SCM_EOL), SCM_EOL);
	184	scm_gc_unprotect_object(scmcb->subr);
	185	free(scmcb);
	186	return(2);
	187	}
	188
	189	static SCM scm_dc_qcmd(SCM argv, SCM callback)
	190	{
	191	int tag, enob;
	192	wchar_t *toks, tok, *cmd;
	193	size_t tokssize, toksdata;
	194	SCM port;
	195	struct scmcb *scmcb;
	196
	197	SCM_ASSERT(SCM_CONSP(argv), argv, SCM_ARG1, "dc-qcmd");
	198	if(callback != SCM_UNDEFINED)
	199	SCM_ASSERT(SCM_CLOSUREP(callback), callback, SCM_ARG2, "dc-qcmd");
	200	cmd = NULL;
	201	toks = NULL;
	202	tokssize = toksdata = 0;
	203	for(; argv != SCM_EOL; argv = SCM_CDR(argv))
	204	{
	205	port = scm_open_output_string();
	206	scm_display(SCM_CAR(argv), port);
	207	if((tok = icmbstowcs(SCM_STRING_CHARS(scm_get_output_string(port)), "UTF-8")) == NULL)
	208	{
	209	enob = errno;
	210	addtobuf(toks, NULL);
	211	dc_freewcsarr(toks);
	212	if(cmd != NULL)
	213	free(cmd);
	214	errno = enob;
	215	scm_syserror("dc-qcmd");
	216	}
	217	if(cmd == NULL)
	218	cmd = tok;
	219	else
	220	addtobuf(toks, tok);
	221	}
	222	addtobuf(toks, NULL);
	223	if(callback == SCM_UNDEFINED)
	224	{
	225	tag = dc_queuecmd(NULL, NULL, cmd, L"%%a", toks, NULL);
	226	} else {
	227	scmcb = scm_must_malloc(sizeof(*scmcb), "scmcb");
	228	scm_gc_protect_object(scmcb->subr = callback);
	229	tag = dc_queuecmd(qcmd_scmcb, scmcb, cmd, L"%%a", toks, NULL);
	230	}
	231	dc_freewcsarr(toks);
	232	if(cmd != NULL)
	233	free(cmd);
	234	return(SCM_MAKINUM(tag));
	235	}
	236
	237	static void login_scmcb(int err, wchar_t reason, struct scmcb scmcb)
	238	{
	239	SCM errsym;
	240
	241	switch(err)
	242	{
	243	case DC_LOGIN_ERR_SUCCESS:
	244	errsym = scm_str2symbol("success");
	245	break;
	246	case DC_LOGIN_ERR_NOLOGIN:
	247	errsym = scm_str2symbol("nologin");
	248	break;
	249	case DC_LOGIN_ERR_SERVER:
	250	errsym = scm_str2symbol("server");
	251	break;
	252	case DC_LOGIN_ERR_USER:
	253	errsym = scm_str2symbol("user");
	254	break;
	255	case DC_LOGIN_ERR_CONV:
	256	errsym = scm_str2symbol("conv");
	257	break;
	258	case DC_LOGIN_ERR_AUTHFAIL:
	259	errsym = scm_str2symbol("authfail");
	260	break;
	261	}
	262	scm_apply(scmcb->subr, scm_cons(errsym, scm_cons((reason == NULL)?SCM_BOOL_F:scm_makfrom0str(icswcstombs(reason, "UTF-8", NULL)), SCM_EOL)), SCM_EOL);
	263	scm_gc_unprotect_object(scmcb->subr);
	264	free(scmcb);
	265	}
	266
	267	static SCM scm_dc_loginasync(SCM callback, SCM useauthless, SCM username)
	268	{
	269	struct scmcb *scmcb;
	270
	271	SCM_ASSERT(SCM_CLOSUREP(callback), callback, SCM_ARG1, "dc-loginasync");
	272	scmcb = scm_must_malloc(sizeof(*scmcb), "scmcb");
	273	scm_gc_protect_object(scmcb->subr = callback);
	274	dc_loginasync(SCM_STRINGP(username)?SCM_STRING_CHARS(username):NULL, SCM_NFALSEP(useauthless), NULL, (void ()(int, wchar_t , void *))login_scmcb, scmcb);
	275	return(SCM_BOOL_T);
	276	}
	277
	278	static SCM scm_dc_lexsexpr(SCM sexpr)
	279	{
	280	SCM ret;
	281	wchar_t arr, ap, *buf;
	282
	283	SCM_ASSERT(SCM_STRINGP(sexpr), sexpr, SCM_ARG1, "dc-lexsexpr");
	284	if((buf = icmbstowcs(SCM_STRING_CHARS(sexpr), NULL)) == NULL)
	285	scm_syserror("dc-lexsexpr");
	286	arr = dc_lexsexpr(buf);
	287	free(buf);
	288	ret = SCM_EOL;
	289	if(arr != NULL)
	290	{
	291	for(ap = arr; *ap != NULL; ap++)
	292	ret = scm_cons(scm_makfrom0str(icswcstombs(*ap, "UTF-8", NULL)), ret);
	293	dc_freewcsarr(arr);
	294	}
	295	return(scm_reverse(ret));
	296	}
	297
	298	static size_t resp_free(SCM respsmob)
	299	{
	300	struct respsmob *data;
	301
	302	data = (struct respsmob *)SCM_SMOB_DATA(respsmob);
	303	dc_freeresp(data->resp);
	304	free(data);
	305	return(sizeof(*data));
	306	}
	307
	308	static int resp_print(SCM respsmob, SCM port, scm_print_state *pstate)
	309	{
	310	struct respsmob *data;
	311
	312	data = (struct respsmob *)SCM_SMOB_DATA(respsmob);
	313	scm_puts("#<dc-response ", port);
	314	scm_display(SCM_MAKINUM(data->resp->tag), port);
	315	scm_puts(" ", port);
	316	scm_puts(icswcstombs(data->resp->cmdname, "UTF-8", NULL), port);
	317	scm_puts(" ", port);
	318	scm_display(SCM_MAKINUM(data->resp->code), port);
	319	scm_puts(">", port);
	320	return(1);
	321	}
	322
	323	void init_guiledc(void)
	324	{
	325	scm_c_define_gsubr("dc-connect", 1, 1, 0, scm_dc_connect);
	326	scm_c_define_gsubr("dc-disconnect", 0, 0, 0, scm_dc_disconnect);
	327	scm_c_define_gsubr("dc-connected", 0, 0, 0, scm_dc_connected);
	328	scm_c_define_gsubr("dc-select", 0, 1, 0, scm_dc_select);
	329	scm_c_define_gsubr("dc-getresp", 0, 1, 0, scm_dc_getresp);
	330	scm_c_define_gsubr("dc-extract", 1, 0, 0, scm_dc_extract);
	331	scm_c_define_gsubr("dc-intresp", 1, 0, 0, scm_dc_intresp);
	332	scm_c_define_gsubr("dc-qcmd", 1, 1, 0, scm_dc_qcmd);
	333	scm_c_define_gsubr("dc-loginasync", 2, 1, 0, scm_dc_loginasync);
	334	scm_c_define_gsubr("dc-lexsexpr", 1, 0, 0, scm_dc_lexsexpr);
	335	resptype = scm_make_smob_type("dc-resp", sizeof(struct respsmob));
	336	scm_set_smob_free(resptype, resp_free);
	337	scm_set_smob_print(resptype, resp_print);
	338	dc_init();
	339	}