/* This callback function catches the data passed by libcurl and sends
it back as a scheme string */
static size_t
write_callback (void *ptr, size_t size, size_t nmemb, void *userdata)
{
size_t length1, length2;
SCM data1, data2;
struct scm_flag *sf;
sf = (struct scm_flag *) userdata;
data1 = sf->scm;
#if SCM_MAJOR_VERSION == 2
if (sf->flag)
length1 = scm_c_bytevector_length (data1);
else
length1 = scm_c_string_length (data1);
#else
length1 = scm_c_string_length (data1);
#endif
length2 = size * nmemb;
/* printf ("In write_callback\n"); */
#if SCM_MAJOR_VERSION == 2
if (sf->flag)
{
data2 = scm_c_make_bytevector (length1 + length2);
memcpy (SCM_BYTEVECTOR_CONTENTS (data2),
SCM_BYTEVECTOR_CONTENTS (data1),
length1);
memcpy (SCM_BYTEVECTOR_CONTENTS (data2) + length1,
ptr,
length2);
}
else
{
data2 = scm_c_make_string (length1 + length2, SCM_MAKE_CHAR('\0'));
for (size_t i = 0; i < length1; i ++)
{
scm_c_string_set_x (data2, i, scm_c_string_ref (data1, i));
}
for (size_t i = 0; i < length2; i ++)
{
scm_c_string_set_x (data2, i + length1,
SCM_MAKE_CHAR (((char *)ptr)[i]));
}
}
#else
data2 = scm_c_make_string (length1 + length2, SCM_MAKE_CHAR('\0'));
memcpy (SCM_STRING_CHARS (data2),
SCM_STRING_CHARS (data1),
length1);
memcpy (SCM_STRING_CHARS (data2) + length1,
ptr,
length2);
#endif
sf->scm = data2;
return length2;
}
SCM DLL_PUBLIC
cl_easy_perform (SCM handle, SCM bvflag, SCM headerflag)
{
handle_post_t *c_handle;
SCM data;
CURLcode status;
struct scm_flag body_sf, header_sf;
SCM_ASSERT (_scm_is_handle (handle), handle, SCM_ARG1, "%curl-easy-perform");
c_handle = _scm_to_handle (handle);
body_sf.flag = scm_is_true (bvflag);
#if SCM_MAJOR_VERSION == 2
if (body_sf.flag)
data = scm_c_make_bytevector (0);
else
data = scm_c_make_string (0, SCM_MAKE_CHAR('\n'));
#else
data = scm_c_make_string (0, SCM_MAKE_CHAR('\n'));
#endif
body_sf.scm = data;
header_sf.flag = 0;
#if SCM_MAJOR_VERSION == 2
if (header_sf.flag)
data = scm_c_make_bytevector (0);
else
data = scm_c_make_string (0, SCM_MAKE_CHAR('\n'));
#else
data = scm_c_make_string (0, SCM_MAKE_CHAR('\n'));
#endif
header_sf.scm = data;
if (scm_is_true (headerflag))
{
curl_easy_setopt (c_handle->handle, CURLOPT_HEADERFUNCTION, write_callback);
curl_easy_setopt (c_handle->handle, CURLOPT_HEADERDATA, &header_sf);
curl_easy_setopt (c_handle->handle, CURLOPT_ERRORBUFFER, error_string);
}
curl_easy_setopt (c_handle->handle, CURLOPT_WRITEFUNCTION, write_callback);
curl_easy_setopt (c_handle->handle, CURLOPT_WRITEDATA, &body_sf);
curl_easy_setopt (c_handle->handle, CURLOPT_ERRORBUFFER, error_string);
/* Do the transfer, and fill c_str with the result */
status = curl_easy_perform (c_handle->handle);
if (status != CURLE_OK)
{
error_code = status;
return (SCM_BOOL_F);
}
if (scm_is_true (headerflag))
return (scm_list_2 (header_sf.scm, body_sf.scm));
return (body_sf.scm);
}
/*------------------------------------------------------------
* Vport puts
*/
static void vport_puts(ScmString *s, ScmPort *p)
{
vport *data = (vport*)p->src.vt.data;
const ScmStringBody *b = SCM_STRING_BODY(s);
SCM_ASSERT(data != NULL);
if (!SCM_FALSEP(data->puts_proc)) {
Scm_ApplyRec(data->puts_proc, SCM_LIST1(SCM_OBJ(s)));
} else if (SCM_STRING_BODY_INCOMPLETE_P(b)
|| (SCM_FALSEP(data->putc_proc)
&& !SCM_FALSEP(data->putb_proc))) {
/* we perform binary output */
vport_putz(SCM_STRING_BODY_START(b), SCM_STRING_BODY_SIZE(b), p);
} else if (!SCM_FALSEP(data->putc_proc)) {
ScmChar c;
int i;
const char *cp = SCM_STRING_BODY_START(b);
for (i=0; i < (int)SCM_STRING_BODY_LENGTH(b); i++) {
SCM_CHAR_GET(cp, c);
cp += SCM_CHAR_NFOLLOWS(*cp)+1;
Scm_ApplyRec(data->putc_proc, SCM_LIST1(SCM_MAKE_CHAR(c)));
}
} else {
Scm_PortError(p, SCM_PORT_ERROR_OTHER,
"cannot perform output to the port %S", p);
}
}
int parse_options(int argc, char *argv[])
{
int c;
while ((c = getopt(argc, argv, "+be:E:ip:ql:L:m:u:Vr:F:f:I:A:-")) >= 0) {
switch (c) {
case 'b': batch_mode = TRUE; break;
case 'i': interactive_mode = TRUE; break;
case 'q': load_initfile = FALSE; break;
case 'V': version(); break;
case 'f': further_options(optarg); break;
case 'p': profiler_options(optarg); break;
case 'F': feature_options(optarg); break;
case 'm':
main_module = Scm_Intern(SCM_STRING(SCM_MAKE_STR_COPYING(optarg)));
break;
case 'r': /*FALLTHROUGH*/;
case 'u': /*FALLTHROUGH*/;
case 'l': /*FALLTHROUGH*/;
case 'L': /*FALLTHROUGH*/;
case 'I': /*FALLTHROUGH*/;
case 'A': /*FALLTHROUGH*/;
case 'e': /*FALLTHROUGH*/;
case 'E': /*FALLTHROUGH*/;
pre_cmds = Scm_Acons(SCM_MAKE_CHAR(c),
SCM_MAKE_STR_COPYING(optarg), pre_cmds);
break;
case '-': break;
case '?': usage(); break;
}
}
return optind;
}
ScmObj Scm_UngottenCharsUnsafe(ScmPort *p)
#endif
{
VMDECL;
SHORTCUT(p, return Scm_UngottenCharsUnsafe(p));
LOCK(p);
ScmChar ch = p->ungotten;
UNLOCK(p);
if (ch == SCM_CHAR_INVALID) {
return SCM_NIL;
} else {
return SCM_LIST1(SCM_MAKE_CHAR(ch));
}
}
/********************************************************************\
* gnc_split_scm_set_reconcile_state *
* set the reconcile state of a scheme split. *
* *
* Args: split_scm - the scheme split *
* reconcile_state - the reconcile state to set *
* Returns: Nothing *
\********************************************************************/
void
gnc_split_scm_set_reconcile_state(SCM split_scm, char reconcile_state)
{
SCM arg;
initialize_scm_functions();
if (!gnc_is_split_scm(split_scm))
return;
arg = SCM_MAKE_CHAR(reconcile_state);
scm_call_2(setters.split_scm_reconcile_state, split_scm, arg);
}
/*------------------------------------------------------------
* Vport putb
*/
static void vport_putb(ScmByte b, ScmPort *p)
{
vport *data = (vport*)p->src.vt.data;
SCM_ASSERT(data != NULL);
if (SCM_FALSEP(data->putb_proc)) {
if (!SCM_FALSEP(data->putc_proc)
&& SCM_CHAR_NFOLLOWS(b) == 0) {
/* This byte is a single-byte character, so we can use putc. */
Scm_ApplyRec(data->putc_proc, SCM_LIST1(SCM_MAKE_CHAR(b)));
} else {
/* Given byte is a part of multibyte sequence. We don't
handle it for the time being. */
Scm_PortError(p, SCM_PORT_ERROR_UNIT,
"cannot perform binary output to the port %S", p);
}
} else {
Scm_ApplyRec(data->putb_proc, SCM_LIST1(SCM_MAKE_INT(b)));
}
}
/*------------------------------------------------------------
* Vport putc
*/
static void vport_putc(ScmChar c, ScmPort *p)
{
vport *data = (vport*)p->src.vt.data;
SCM_ASSERT(data != NULL);
if (SCM_FALSEP(data->putc_proc)) {
if (SCM_FALSEP(data->putb_proc)) {
Scm_PortError(p, SCM_PORT_ERROR_OTHER,
"cannot perform output to the port %S", p);
} else {
unsigned char buf[SCM_CHAR_MAX_BYTES];
int i, n=SCM_CHAR_NBYTES(c);
SCM_CHAR_PUT(buf, c);
for (i=0; i<n; i++) {
Scm_ApplyRec(data->putb_proc, SCM_LIST1(SCM_MAKE_INT(buf[i])));
}
}
} else {
Scm_ApplyRec(data->putc_proc, SCM_LIST1(SCM_MAKE_CHAR(c)));
}
}
/*! \brief Register some libgeda variables with scheme.
* \par Function Description
* Define some variables to be visible to Scheme.
*/
void g_register_libgeda_vars (void)
{
scm_c_define("geda-rc-path",
scm_from_utf8_string (s_path_sys_config ()));
scm_c_define("geda-data-path",
scm_from_utf8_string (s_path_sys_data ()));
scm_c_define("path-sep",
scm_from_utf8_string(G_DIR_SEPARATOR_S));
scm_c_define("OBJ_LINE", SCM_MAKE_CHAR((unsigned char) OBJ_LINE));
scm_c_define("OBJ_BOX", SCM_MAKE_CHAR((unsigned char) OBJ_BOX));
scm_c_define("OBJ_PICTURE", SCM_MAKE_CHAR((unsigned char) OBJ_PICTURE));
scm_c_define("OBJ_CIRCLE", SCM_MAKE_CHAR((unsigned char) OBJ_CIRCLE));
scm_c_define("OBJ_NET", SCM_MAKE_CHAR((unsigned char) OBJ_NET));
scm_c_define("OBJ_BUS", SCM_MAKE_CHAR((unsigned char) OBJ_BUS));
scm_c_define("OBJ_COMPLEX", SCM_MAKE_CHAR((unsigned char) OBJ_COMPLEX));
scm_c_define("OBJ_TEXT", SCM_MAKE_CHAR((unsigned char) OBJ_TEXT));
scm_c_define("OBJ_PIN", SCM_MAKE_CHAR((unsigned char) OBJ_PIN));
scm_c_define("OBJ_ARC", SCM_MAKE_CHAR((unsigned char) OBJ_ARC));
scm_c_define("OBJ_PLACEHOLDER", SCM_MAKE_CHAR((unsigned char) OBJ_PLACEHOLDER));
scm_c_define("OBJ_PATH", SCM_MAKE_CHAR((unsigned char) OBJ_PATH));
}
