/*! @decl mapping(string:float) get_point(int point)
*/
static void f_path_element_get_point(INT32 args)
{
int i;
get_all_args("get_point", args, "%d", &i);
i++; // index includes header
if (i > 0 && i < THIS->element->header.length)
{
push_text( "x" );
push_float(THIS->element[i].point.x);
push_text( "y" );
push_float(THIS->element[i].point.y);
f_aggregate_mapping(4);
}
else
push_undefined();
}
static void pextsFatalError(void *ctx, const char *msg, ...)
{
char *vmsg;
va_list ap;
DBG_FUNC_ENTER();
if (CB_ABSENT(fatalErrorSAX)) {
DBG_FUNC_LEAVE();
return;
}
THIS->ctxt = (xmlParserCtxtPtr)ctx;
push_object(this_object());
/* I'm being lazy here :> */
vmsg = NULL;
va_start(ap, msg);
if (vasprintf(&vmsg, msg, ap) < -1)
push_int(0);
else {
push_text(vmsg);
free(vmsg);
}
push_svalue(&THIS->user_data);
CB_CALL(fatalErrorSAX, 3);
pop_stack();
DBG_FUNC_LEAVE();
}
/*! @decl string bindtextdomain(string|void domainname, string|void dirname)
*!
*! Binds the path predicate for a message @[domainname] domainname to
*! the directory name specified by @[dirname].
*!
*! If @[domainname] is a non-empty string and has not been bound
*! previously, bindtextdomain() binds @[domainname] with @[dirname].
*!
*! If @[domainname] is a non-empty string and has been bound previously,
*! bindtextdomain() replaces the old binding with @[dirname].
*!
*! The @[dirname] argument can be an absolute or relative pathname
*! being resolved when @[gettext()], @[dgettext()] or @[dcgettext()]
*! are called.
*!
*! If @[domainname] is zero or an empty string, @[bindtextdomain()]
*! returns 0.
*!
*! User defined domain names cannot begin with the string @expr{"SYS_"@}.
*! Domain names beginning with this string are reserved for system use.
*!
*! @returns
*! The return value from @[bindtextdomain()] is a string containing
*! @[dirname] or the directory binding associated with @[domainname] if
*! @[dirname] is unspecified. If no binding is found, the default locale
*! path is returned. If @[domainname] is unspecified or is an empty string,
*! @[bindtextdomain()] takes no action and returns a 0.
*!
*! @seealso
*! @[textdomain], @[gettext], @[setlocale], @[localeconv]
*/
void f_bindtextdomain(INT32 args)
{
char *returnstring;
const char *domain = NULL, *dirname = NULL;
get_all_args (NULL, args, ".%C%C", &domain, &dirname);
if (!domain || !*domain)
returnstring = NULL;
else {
#ifdef BINDTEXTDOMAIN_HANDLES_NULL
returnstring = bindtextdomain (domain, dirname);
#else
if (dirname)
returnstring = bindtextdomain (domain, dirname);
else
/* Awkward, but not much we can do. Still better than a
* coredump.. */
Pike_error ("Pike has been compiled with a version of libintl "
"that doesn't support NULL as directory name.\n");
#endif
}
pop_n_elems(args);
if(returnstring == NULL)
push_int(0);
else
push_text(returnstring);
}
static void f_extension( INT32 args ) {
int i, found=0;
struct pike_string *src;
char *orig, *ptr;
if(Pike_sp[-1].type != T_STRING)
SIMPLE_BAD_ARG_ERROR("Caudium.extension", 1, "string");
src = Pike_sp[-1].u.string;
if(src->size_shift) {
Pike_error("Caudium.extension(): Only 8-bit strings allowed.\n");
}
orig = src->str;
for(i = src->len-1; i >= 0; i--) {
if(orig[i] == 0x2E) {
found = 1;
i++;
break;
}
}
if(found) {
int len = src->len - i;
switch(orig[src->len-1]) {
case '#': case '~':
/* Remove unix backup extension */
len--;
}
pop_n_elems(args);
push_string(make_shared_binary_string(orig+i, len));
} else {
pop_n_elems(args);
push_text("");
}
}
void pgtk2_index_stack(char *what) {
push_text(what);
f_index(2);
#ifdef PIKE_DEBUG
if (Pike_sp[-1].type==PIKE_T_INT)
Pike_error("Internal indexing error.\n");
#endif
}
void push_headers(HEADER *header) {
int num;
ADDRESS *adr;
push_text("subject"); PUSH_TEXT(header->env->real_subj);
push_text("message_id"); PUSH_TEXT(header->env->message_id);
push_text("type"); PUSH_TEXT( TYPE(header->content) );
push_text("subtype"); PUSH_TEXT(header->content->subtype);
push_text("encoding"); PUSH_TEXT( ENCODING(header->content->encoding) );
push_text("length"); push_int(header->content->length);
PUSH_MAPPING_si("lines", header->lines);
PUSH_MAPPING_si("mime", header->mime);
PUSH_MAPPING_si("flagged", header->flagged);
PUSH_MAPPING_si("tagged", header->tagged);
PUSH_MAPPING_si("deleted", header->deleted);
PUSH_MAPPING_si("replied", header->replied);
PUSH_MAPPING_si("date_sent", header->date_sent);
PUSH_MAPPING_si("date_received", header->received);
push_text("env");
PUSH_ADDRESS("from",from);
PUSH_ADDRESS_LIST("to",to);
PUSH_ADDRESS_LIST("cc",cc);
PUSH_ADDRESS_LIST("bcc",bcc);
PUSH_ADDRESS("sender",sender);
PUSH_ADDRESS("reply_to",reply_to);
PUSH_ADDRESS("return_path",return_path);
f_aggregate_mapping(14);
f_aggregate_mapping(30);
}
/* string get_word(void) */
static void f_get_word(INT32 args)
{
char *word;
if (args)
Pike_error("Too many arguments to Count->get_word()\n");
word = avs_count_getword(PIKE_COUNT->handle);
push_text(word);
}
/*! @decl string gettext(string msg)
*! @decl string gettext(string msg, string domain)
*! @decl string gettext(string msg, string domain, int category)
*!
*! @param msg
*! Message to be translated.
*!
*! @param domain
*! Domain from within the message should be translated.
*! Defaults to the current domain.
*!
*! @param category
*! Category from which the translation should be taken.
*! Defaults to @[Locale.Gettext.LC_MESSAGES].
*!
*! Return a translated version of @[msg] within the context
*! of the specified @[domain] and current locale. If there is no
*! translation available, @[msg] is returned.
*!
*! @seealso
*! @[bindtextdomain], @[textdomain], @[setlocale], @[localeconv]
*/
void f_gettext(INT32 args)
{
const char *domain = NULL, *msg;
int cat = 0;
get_all_args(NULL, args, "%c.%C%D", &msg, &domain, &cat);
if (domain) {
if (args > 2 && SUBTYPEOF(Pike_sp[2-args]) == NUMBER_NUMBER)
push_text(dcgettext(domain, msg, cat));
else
push_text(dgettext(domain, msg));
}
else
push_text(gettext(msg));
stack_pop_n_elems_keep_top(args);
}
/*! @decl string dgettext(string domain, string msg)
*!
*! Return a translated version of @[msg] within the context
*! of the specified @[domain] and current locale. If there is
*! no translation available, @[msg] is returned.
*!
*! @note
*! Obsoleted by @[gettext()] in Pike 7.3.
*!
*! @seealso
*! @[bindtextdomain], @[textdomain], @[gettext], @[setlocale], @[localeconv]
*/
void f_dgettext(INT32 args)
{
const char *domain, *msg;
get_all_args(NULL, args, "%c%c", &domain, &msg);
push_text(dgettext(domain, msg));
stack_pop_n_elems_keep_top(args);
}
/*! @decl string textdomain(void|string domain)
*!
*! The textdomain() function sets or queries the name of the
*! current domain of the active @[LC_MESSAGES] locale category. The
*! @[domain] argument is a string that can contain only the
*! characters allowed in legal filenames.
*!
*! The domain argument is the unique name of a domain on the
*! system. If there are multiple versions of the same domain on
*! one system, namespace collisions can be avoided by using
*! @[bindtextdomain()]. If textdomain() is not called, a default
*! domain is selected. The setting of domain made by the last
*! valid call to textdomain() remains valid across subsequent
*! calls to @[setlocale()], and @[gettext()].
*!
*! @returns
*! The normal return value from textdomain() is a string
*! containing the current setting of the domain. If domainname is
*! void, textdomain() returns a string containing the current
*! domain. If textdomain() was not previously called and
*! domainname is void, the name of the default domain is
*! returned.
*!
*! @seealso
*! @[bindtextdomain], @[gettext], @[setlocale], @[localeconv]
*/
void f_textdomain(INT32 args)
{
const char *domain = NULL;
char *returnstring;
get_all_args (NULL, args, ".%C", &domain);
returnstring = textdomain(domain);
pop_n_elems(args);
push_text(returnstring);
}
static void image_ttf_face_names(INT32 args)
{
int n,i;
int has[8]={0,0,0,0,0,0,0,0}; /* iso8859=20, unicode=30, any=1 */
char *hasname[8]={"copyright","family","style","full",
"expose","version","postscript","trademark"};
struct array *a,*b;
image_ttf_face__names(args);
if (sp[-1].type!=T_ARRAY)
Pike_error("Image.TTF.Face->names(): internal error, weird _names()\n");
a=sp[-1].u.array;
n=0;
for (i=0; i<a->size; i++)
{
int ihas=1;
int what;
b=a->item[i].u.array;
what=b->item[3].u.integer;
if (what>=8 || what<0) continue; /* weird */
switch (b->item[0].u.integer*100+b->item[1].u.integer)
{
case 301: /* M$: unicode */
case 300: /* M$: unicode (?) */
ihas=30;
break;
case 202: /* ISO: iso-8859-1 */
ihas=20;
break;
}
if (ihas<has[what]) continue; /* worse */
push_text(hasname[what]);
if (ihas==30) /* unicode, M$ but weird enough correct byteorder */
{
ptrdiff_t n = b->item[4].u.string->len/2;
struct pike_string *ps=begin_wide_shared_string(n,1);
p_wchar1 *d=STR1(ps);
p_wchar0 *s=STR0(b->item[4].u.string);
while (n--) *(d++)=((p_wchar1)s[0]<<8)|(p_wchar1)s[1],s+=2;
push_string(end_shared_string(ps));
}
else
push_svalue(b->item+4);
n++;
}
f_aggregate_mapping(n*2);
stack_swap();
pop_stack();
}
/*! @decl string dcgettext(string domain, string msg, int category)
*!
*! Return a translated version of @[msg] within the context of the
*! specified @[domain] and current locale for the specified
*! @[category]. Calling dcgettext with category @[Locale.Gettext.LC_MESSAGES]
*! gives the same result as dgettext.
*!
*! If there is no translation available, @[msg] is returned.
*!
*! @note
*! Obsoleted by @[gettext()] in Pike 7.3.
*!
*! @seealso
*! @[bindtextdomain], @[textdomain], @[gettext], @[setlocale], @[localeconv]
*/
void f_dcgettext(INT32 args)
{
const char *domain, *msg;
int category;
get_all_args(NULL, args, "%c%c%d", &domain, &msg, &category);
push_text(dcgettext(domain, msg, category));
stack_pop_n_elems_keep_top(args);
}
void ChatRoom::on_buttonBox_clicked(QAbstractButton *button)
{
//if(button->text()!="send") return;
QString msg = ui->textEdit->toPlainText();
if (msg.length()>0) {
QString msgid = linphone_chat_room_send_message(cr_,msg.toLocal8Bit());
push_text(get_used_identity(),msg.toLocal8Bit(), msgid, true);
ui->textEdit->clear();
}
}
/*! @decl string default_domain()
*!
*! Returns the default yp-domain.
*/
static void f_default_domain(INT32 args)
{
int err;
char *ret;
err = yp_get_default_domain(&ret);
YPERROR( err );
pop_n_elems( args );
push_text( ret );
}
/*! @decl string server(string map)
*!
*! Returns the hostname of the server serving the map @[map]. @[map]
*! is the YP-map to search in. This must be the full map name.
*! eg @tt{passwd.byname@} instead of just @tt{passwd@}.
*/
static void f_server(INT32 args)
{
int err;
char *ret, *map;
get_all_args(NULL, args, "%s", &map);
err = yp_master(this->domain, map, &ret);
YPERROR( err );
pop_n_elems( args );
push_text( ret );
}
/* string get_docid() */
static void f_get_docid(INT32 args)
{
char *docid;
GET_PIKE_SEARCH();
if (args)
Pike_error("Too many arguments to Search->get_docid()\n");
THREADS_ALLOW();
docid = avs_search_getdocid(search->handle);
THREADS_DISALLOW();
push_text(docid);
}
void pike_module_init(void)
{
#ifdef PEXTS_VERSION
pexts_init();
#endif
struct svalue sv;
/* Starting a new class */
start_new_program();
/* Agrega espacio para los datos internos */
low_add_storage(sizeof(struct mcast_storage) - sizeof(struct udp_storage),
ALIGNOF(struct mcast_storage),0);
/* Hereda Stdio.UDP */
/* NOTA IMPORTANTE
* Aparentemente no se puede heredar un objeto
* escrito en Pike desde aquí... luego, heredo
* el objeto básico (nativo) */
/* Resuelve el objeto (encuentra el archivo) */
push_text("files.UDP");
SAFE_APPLY_MASTER("resolv",1);
if(Pike_sp[-1].type != T_FUNCTION)
Pike_error("Error in resolving of Stdio.UDP!\n");
/* Obtiene el programa */
stdio_udp = program_from_function(&Pike_sp[-1]);
pop_n_elems(1);
/* Hereda */
sv.type = T_PROGRAM;
sv.subtype = 0;
sv.u.program = stdio_udp;
do_inherit( &sv, 0, 0);
/* Agrega los métodos */
ADD_FUNCTION("join",mcast_join,tFunc(tStr,tVoid),0);
ADD_FUNCTION("leave",mcast_leave,tFunc(tStr,tVoid),0);
ADD_FUNCTION("setLoopback",mcast_loopback,tFunc(tInt,tVoid),0);
ADD_FUNCTION("setTTL",mcast_setTTL,tFunc(tInt,tVoid),0);
ADD_FUNCTION("setInterface",mcast_setif,tFunc(tStr,tVoid),0);
/* Llama a "init_mcast" antes de crear los objetos */
set_init_callback(init_mcast);
end_class("MultiCastUDP",0);
}
/*! @decl string query_address()
*!
*! Get the address and port of the local socket end-point.
*!
*! @returns
*! This function returns the address and port of a socket end-point
*! on the form @expr{"x.x.x.x port"@} (IPv4) or
*! @expr{"x:x:x:x:x:x:x:x port"@} (IPv6).
*!
*! If there is some error querying or formatting the address,
*! @expr{0@} (zero) is returned and @[errno()] will return the
*! error code.
*!
*! @throws
*! An error is thrown if the socket isn't bound.
*/
static void socket_query_address(INT32 args)
{
PIKE_SOCKADDR addr;
int i;
char buffer[496];
ACCEPT_SIZE_T len;
if(THIS->box.fd <0)
Pike_error("Stdio.Port->query_address(): Socket not bound yet.\n");
len=sizeof(addr);
i=fd_getsockname(THIS->box.fd,(struct sockaddr *)&addr,&len);
pop_n_elems(args);
if(i < 0 || len < (int)sizeof(addr.ipv4))
{
THIS->my_errno=errno;
push_int(0);
return;
}
#ifdef fd_inet_ntop
if(!fd_inet_ntop(SOCKADDR_FAMILY(addr), SOCKADDR_IN_ADDR(addr),
buffer, sizeof(buffer)-20))
{
THIS->my_errno = errno;
push_int(0);
return;
}
#else
if(SOCKADDR_FAMILY(addr) == AF_INET)
{
char *q = inet_ntoa(*SOCKADDR_IN_ADDR(addr));
strncpy(buffer,q,sizeof(buffer)-20);
buffer[sizeof(buffer)-20]=0;
}else{
#ifdef EAFNOSUPPORT
THIS->my_errno = EAFNOSUPPORT;
#else
THIS->my_errno = EINVAL;
#endif
push_int(0);
return;
}
#endif
sprintf(buffer+strlen(buffer)," %d",(int)(ntohs(addr.ipv4.sin_port)));
push_text(buffer);
}
/* string get_version() */
static void f_get_version(INT32 args)
{
int n;
char version[AVS_SEARCHVERSION_MAXLEN];
GET_PIKE_SEARCH();
if (args)
Pike_error("Too many arguments to Search->get_version()\n");
THREADS_ALLOW();
n = avs_getsearchversion(search->handle, version);
THREADS_DISALLOW();
if (n != AVS_OK)
Pike_error("Search->get_version(): %s\n", avs_errmsg(n));
push_text(version);
}
/*
**! method: string query_name()
**! Get the name of the selected hash routine.
**! name: query_name - Get hash routine name
**! returns:
**! The name of the selected hash routine, zero if none is selected or
**! -1 if the selected hash is invalid.
*/
void f_hash_query_name(INT32 args)
{
char *name;
pop_n_elems(args);
if(THIS->type != -1) {
name = mhash_get_hash_name(THIS->type);
if(name == NULL) {
push_int(-1);
} else {
push_text(name);
free(name);
}
} else {
push_int(0);
}
}
/* array get_term(int term_num) */
static void f_get_term(INT32 args)
{
int n, term_num;
long count;
char *term;
GET_PIKE_SEARCH();
get_all_args("Search->get_term()", args, "%i", &term_num);
THREADS_ALLOW();
n = avs_getsearchterms(search->handle, term_num, &term, &count);
THREADS_DISALLOW();
if (n != AVS_OK)
Pike_error("Search->get_term(): %s\n", avs_errmsg(n));
pop_n_elems(args);
push_text(term);
push_int(count);
f_aggregate(2);
}
/*! @decl string version()
*!
*! Return the version of the module.
*/
static void pipe_version(INT32 args)
{
pop_n_elems(args);
push_text("PIPE ver 2.0");
}
static void image_ttf_face_properties(INT32 args)
{
int res;
TT_Face_Properties prop;
pop_n_elems(args);
res=TT_Get_Face_Properties(THISf->face,&prop);
if (res) my_tt_error("Image.TTF.Face->properties()","",res);
push_text("num_Glyphs"); push_int(prop.num_Glyphs);
push_text("max_Points"); push_int(prop.max_Points);
push_text("max_Contours"); push_int(prop.max_Contours);
push_text("num_Faces"); push_int(prop.num_Faces);
push_text("header");
if (prop.header)
{
push_text("Table_Version"); push_int(prop.header->Table_Version);
push_text("Font_Revision"); push_int(prop.header->Font_Revision);
push_text("CheckSum_Adjust"); push_int(prop.header->CheckSum_Adjust);
push_text("Magic_Number"); push_int(prop.header->Magic_Number);
push_text("Flags"); push_int(prop.header->Flags);
push_text("Units_Per_EM"); push_int(prop.header->Units_Per_EM);
push_text("Created");
push_int(prop.header->Created[0]);
push_int(prop.header->Created[1]);
f_aggregate(2);
push_text("Modified");
push_int(prop.header->Modified[0]);
push_int(prop.header->Modified[1]);
f_aggregate(2);
push_text("xMin"); push_int(prop.header->xMin);
push_text("yMin"); push_int(prop.header->yMin);
push_text("xMax"); push_int(prop.header->xMax);
push_text("yMax"); push_int(prop.header->yMax);
push_text("Mac_Style"); push_int(prop.header->Mac_Style);
push_text("Lowest_Rec_PPEM"); push_int(prop.header->Lowest_Rec_PPEM);
push_text("Font_Direction"); push_int(prop.header->Font_Direction);
push_text("Index_To_Loc_Format");
push_int(prop.header->Index_To_Loc_Format);
push_text("Glyph_Data_Format");
push_int(prop.header->Glyph_Data_Format);
f_aggregate_mapping(17*2);
}
else push_int(0);
push_text("horizontal");
if (prop.horizontal)
{
push_text("Version"); push_int(prop.horizontal->Version);
push_text("Ascender"); push_int(prop.horizontal->Ascender);
push_text("Descender"); push_int(prop.horizontal->Descender);
push_text("Line_Gap"); push_int(prop.horizontal->Line_Gap);
push_text("advance_Width_Max"); push_int(prop.horizontal->advance_Width_Max);
push_text("min_Left_Side_Bearing"); push_int(prop.horizontal->min_Left_Side_Bearing);
push_text("min_Right_Side_Bearing"); push_int(prop.horizontal->min_Right_Side_Bearing);
push_text("xMax_Extent"); push_int(prop.horizontal->xMax_Extent);
push_text("caret_Slope_Rise"); push_int(prop.horizontal->caret_Slope_Rise);
push_text("caret_Slope_Run"); push_int(prop.horizontal->caret_Slope_Run);
push_text("metric_Data_Format"); push_int(prop.horizontal->metric_Data_Format);
push_text("number_Of_HMetrics"); push_int(prop.horizontal->number_Of_HMetrics);
f_aggregate_mapping(13*2);
}
else push_int(0);
push_text("os2");
if (prop.os2)
{
push_text("version"); push_int(prop.os2->version);
push_text("xAvgCharWidth"); push_int(prop.os2->xAvgCharWidth);
push_text("usWeightClass"); push_int(prop.os2->usWeightClass);
push_text("usWidthClass"); push_int(prop.os2->usWidthClass);
push_text("fsType"); push_int(prop.os2->fsType);
push_text("ySubscriptXSize"); push_int(prop.os2->ySubscriptXSize);
push_text("ySubscriptYSize"); push_int(prop.os2->ySubscriptYSize);
push_text("ySubscriptXOffset"); push_int(prop.os2->ySubscriptXOffset);
push_text("ySubscriptYOffset"); push_int(prop.os2->ySubscriptYOffset);
push_text("ySuperscriptXSize"); push_int(prop.os2->ySuperscriptXSize);
push_text("ySuperscriptYSize"); push_int(prop.os2->ySuperscriptYSize);
push_text("ySuperscriptXOffset"); push_int(prop.os2->ySuperscriptXOffset);
push_text("ySuperscriptYOffset"); push_int(prop.os2->ySuperscriptYOffset);
push_text("yStrikeoutSize"); push_int(prop.os2->yStrikeoutSize);
push_text("yStrikeoutPosition"); push_int(prop.os2->yStrikeoutPosition);
push_text("sFamilyClass"); push_int(prop.os2->sFamilyClass);
push_text("panose");
push_string(make_shared_binary_string(prop.os2->panose,10));
push_text("ulUnicodeRange1"); push_int(prop.os2->ulUnicodeRange1);
push_text("ulUnicodeRange2"); push_int(prop.os2->ulUnicodeRange2);
push_text("ulUnicodeRange3"); push_int(prop.os2->ulUnicodeRange3);
push_text("ulUnicodeRange4"); push_int(prop.os2->ulUnicodeRange4);
push_text("achVendID");
push_string(make_shared_binary_string(prop.os2->achVendID,4));
push_text("fsSelection"); push_int(prop.os2->fsSelection);
push_text("usFirstCharIndex"); push_int(prop.os2->usFirstCharIndex);
push_text("usLastCharIndex"); push_int(prop.os2->usLastCharIndex);
push_text("sTypoAscender"); push_int(prop.os2->sTypoAscender);
push_text("sTypoDescender"); push_int(prop.os2->sTypoDescender);
push_text("sTypoLineGap"); push_int(prop.os2->sTypoLineGap);
push_text("usWinAscent"); push_int(prop.os2->usWinAscent);
push_text("usWinDescent"); push_int(prop.os2->usWinDescent);
push_text("ulCodePageRange1"); push_int(prop.os2->ulCodePageRange1);
push_text("ulCodePageRange2"); push_int(prop.os2->ulCodePageRange2);
f_aggregate_mapping(32*2);
}
else push_int(0);
push_text("postscript");
if (prop.postscript)
{
push_text("FormatType"); push_int(prop.postscript->FormatType);
push_text("italicAngle"); push_int(prop.postscript->italicAngle);
push_text("underlinePosition"); push_int(prop.postscript->underlinePosition);
push_text("underlineThickness"); push_int(prop.postscript->underlineThickness);
push_text("isFixedPitch"); push_int(prop.postscript->isFixedPitch);
push_text("minMemType42"); push_int(prop.postscript->minMemType42);
push_text("maxMemType42"); push_int(prop.postscript->maxMemType42);
push_text("minMemType1"); push_int(prop.postscript->minMemType1);
push_text("maxMemType1"); push_int(prop.postscript->maxMemType1);
f_aggregate_mapping(9*2);
}
else push_int(0);
push_text("hdmx");
if (prop.hdmx)
{
int i;
push_text("version"); push_int(prop.hdmx->version);
push_text("num_records"); push_int(prop.hdmx->num_records);
push_text("records");
for (i=0; i<prop.hdmx->num_records; i++)
{
push_text("ppem"); push_int(prop.hdmx->records[i].ppem);
push_text("max_width"); push_int(prop.hdmx->records[i].max_width);
/* push_text("widths"); push_int(prop.hdmx->records[i].widths);*/
f_aggregate_mapping(2*2);
}
f_aggregate(prop.hdmx->num_records);
f_aggregate_mapping(3*2);
}
else push_int(0);
f_aggregate_mapping(9*2);
}
static rgba_group decode_color( struct buffer *s )
{
static struct svalue _parse_color;
static struct svalue *parse_color;
rgba_group res;
res.alpha = 255;
if(!s->len)
{
res.r=res.g=res.b = 0;
return res;
}
if(s->str[0] == '#' && s->len>3)
{
switch(s->len)
{
default:
res.r = hextoint(s->str[1])*0x10;
res.g = hextoint(s->str[2])*0x10;
res.b = hextoint(s->str[3])*0x10;
break;
case 7:
res.r = hextoint(s->str[1])*0x10 + hextoint(s->str[2]);
res.g = hextoint(s->str[3])*0x10 + hextoint(s->str[4]);
res.b = hextoint(s->str[5])*0x10 + hextoint(s->str[6]);
break;
case 13:
res.r = hextoint(s->str[1])*0x10 + hextoint(s->str[2]);
res.g = hextoint(s->str[5])*0x10 + hextoint(s->str[6]);
res.b = hextoint(s->str[9])*0x10 + hextoint(s->str[10]);
break;
}
return res;
}
if(s->len==4&&(!strncmp(s->str,"None",4)||!strncmp(s->str,"none",4)))
{
#ifdef HIDE_WARNINGS
res.r = res.g = res.b = 0;
#endif
res.alpha = 0;
return res;
}
if(!parse_color)
{
push_text("Image.Color");
SAFE_APPLY_MASTER( "resolv_or_error", 1 );
_parse_color = sp[-1];
parse_color = &_parse_color;
sp--;
}
push_svalue( parse_color );
push_string(make_shared_binary_string(s->str,s->len));
f_index( 2 );
if(sp[-1].type != T_OBJECT) {
push_int(0);
stack_swap();
} else {
push_constant_text( "array" );
apply( sp[-2].u.object, "cast", 1 );
}
if(sp[-1].type == T_ARRAY && sp[-1].u.array->size == 3)
{
res.r = sp[-1].u.array->item[0].u.integer;
res.g = sp[-1].u.array->item[1].u.integer;
res.b = sp[-1].u.array->item[2].u.integer;
} else {
res.r = res.g = res.b = 0;
}
pop_stack(); /* array */
pop_stack(); /* object */
return res;
}
/*! @decl mapping|int evaluate(string script, int|void version)
*!
*! Evaluates the passed script (that is, compiles it and then executes)
*! and returns a mapping with the execution results. The passed version is
*! set only for the passed script, it doesn't affect the globally used JS
*! version.
*!
*! @param script
*! Text of the JavaScript program to evaluate.
*!
*! @param version
*! One of the JavaScript version constants.
*!
*! @returns
*! A mapping containing the script output and the return value:
*!
*! @mapping
*! @member string "output"
*! The script output - that is strings output using the write and
*! writeln functions. Might be "" if no output was produced.
*!
*! @member string "result"
*! The script result (the value used in the 'return' JavaScript
*! statement). Might be "" if the script returned no value or an
*! undefined value.
*! @end_mapping
*/
static void ctx_evaluate(INT32 args)
{
JSBool ok;
JSString *str;
jsval rval;
struct pike_string *script;
INT32 version = -1, oldversion = -1;
if (!THIS->ctx) {
pop_n_elems(args);
push_int(0);
return;
}
switch(args) {
case 2:
get_all_args("evaluate", args, "%S%i", &script, &version);
break;
case 1:
get_all_args("evaluate", args, "%S", &script);
break;
default:
Pike_error("Not enough arguments\n");
}
if (version != -1)
oldversion = JS_SetVersion(THIS->ctx, version);
/* TODO: filename should indicate the actual location of the script */
ok = JS_EvaluateScript(THIS->ctx, global,
script->str, script->len,
"Caudium/js", 0, &rval);
if (oldversion != -1)
JS_SetVersion(THIS->ctx, oldversion);
pop_n_elems(args);
if (!ok) {
push_int(-1);
return;
}
push_string(idx_output);
if (THIS->output_buf && THIS->output_buf_last) {
push_text(THIS->output_buf);
memset(THIS->output_buf, 0, THIS->output_buf_len);
THIS->output_buf_last = 0;
} else
push_text("");
push_string(idx_result);
if (!JSVAL_IS_NULL(rval) && !JSVAL_IS_VOID(rval)) {
struct pike_string *ret;
unsigned char *tmp = NULL, *tval;
size_t blen = 0;
str = JS_ValueToString(THIS->ctx, rval);
push_text(JS_GetStringBytes(str));
} else
push_text("");
f_aggregate_mapping(4);
}
static void f_read( INT32 args )
{
char *read_buf;
struct svalue *logfun, *file;
FD f = -1;
int cls, c, my_fd=1, state=0, tzs=0;
char *char_pointer;
INT32 v=0, yy=0, mm=0, dd=0, h=0, m=0, s=0, tz=0;
ptrdiff_t offs0=0, len=0;
struct svalue *old_sp;
/* #define DYNAMIC_BUF */
#ifdef DYNAMIC_BUF
dynamic_buffer buf;
#else
#define BUFSET(X) do { if(bufpos == bufsize) { bufsize *= 2; buf = realloc(buf, bufsize+1); } buf[bufpos++] = c; } while(0)
#define PUSHBUF() do { push_string( make_shared_binary_string( buf,bufpos ) ); bufpos=0; } while(0)
char *buf;
int bufsize=CLF_BLOCK_SIZE, bufpos=0;
#endif
if(args>2 && sp[-1].type == T_INT) {
offs0 = sp[-1].u.integer;
pop_n_elems(1);
--args;
}
old_sp = sp;
get_all_args("CommonLog.read", args, "%*%*", &logfun, &file);
if(logfun->type != T_FUNCTION)
SIMPLE_BAD_ARG_ERROR("CommonLog.read", 1, "function");
if(file->type == T_OBJECT)
{
f = fd_from_object(file->u.object);
if(f == -1)
Pike_error("CommonLog.read: File is not open.\n");
my_fd = 0;
} else if(file->type == T_STRING &&
file->u.string->size_shift == 0) {
#ifdef PIKE_SECURITY
if(!CHECK_SECURITY(SECURITY_BIT_SECURITY))
{
if(!CHECK_SECURITY(SECURITY_BIT_CONDITIONAL_IO))
Pike_error("Permission denied.\n");
push_text("read");
push_int(0);
ref_push_string(file->u.string);
push_text("r");
push_int(00666);
safe_apply(OBJ2CREDS(CURRENT_CREDS)->user,"valid_open",5);
switch(Pike_sp[-1].type)
{
case PIKE_T_INT:
switch(Pike_sp[-1].u.integer)
{
case 0: /* return 0 */
errno=EPERM;
Pike_error("CommonLog.read(): Failed to open file for reading (errno=%d).\n",
errno);
case 2: /* ok */
pop_stack();
break;
case 3: /* permission denied */
Pike_error("CommonLog.read: permission denied.\n");
default:
Pike_error("Error in user->valid_open, wrong return value.\n");
}
break;
default:
Pike_error("Error in user->valid_open, wrong return type.\n");
case PIKE_T_STRING:
/* if(Pike_sp[-1].u.string->shift_size) */
/* file=Pike_sp[-1]; */
pop_stack();
}
}
#endif
do {
THREADS_ALLOW();
f=fd_open((char *)STR0(file->u.string), fd_RDONLY, 0);
THREADS_DISALLOW();
if (f >= 0 || errno != EINTR) break;
check_threads_etc();
} while (1);
if(f < 0)
Pike_error("CommonLog.read(): Failed to open file for reading (errno=%d).\n",
errno);
} else
SIMPLE_BAD_ARG_ERROR("CommonLog.read", 2, "string|Stdio.File");
#ifdef HAVE_LSEEK64
lseek64(f, offs0, SEEK_SET);
#else
fd_lseek(f, offs0, SEEK_SET);
#endif
read_buf = malloc(CLF_BLOCK_SIZE+1);
#ifndef DYNAMIC_BUF
buf = malloc(bufsize);
#endif
while(1) {
do {
THREADS_ALLOW();
len = fd_read(f, read_buf, CLF_BLOCK_SIZE);
THREADS_DISALLOW();
if (len >= 0 || errno != EINTR) break;
check_threads_etc();
} while (1);
if(len == 0)
break; /* nothing more to read. */
if(len < 0)
break;
char_pointer = read_buf;
while(len--) {
offs0++;
c = char_pointer[0] & 0xff;
char_pointer ++;
cls = char_class[c];
#ifdef TRACE_DFA
fprintf(stderr, "DFA(%d): '%c' ", state, (c<32? '.':c));
switch(cls) {
case CLS_WSPACE: fprintf(stderr, "CLS_WSPACE"); break;
case CLS_CRLF: fprintf(stderr, "CLS_CRLF"); break;
case CLS_TOKEN: fprintf(stderr, "CLS_TOKEN"); break;
case CLS_DIGIT: fprintf(stderr, "CLS_DIGIT"); break;
case CLS_QUOTE: fprintf(stderr, "CLS_QUOTE"); break;
case CLS_LBRACK: fprintf(stderr, "CLS_LBRACK"); break;
case CLS_RBRACK: fprintf(stderr, "CLS_RBRACK"); break;
case CLS_SLASH: fprintf(stderr, "CLS_SLASH"); break;
case CLS_COLON: fprintf(stderr, "CLS_COLON"); break;
case CLS_HYPHEN: fprintf(stderr, "CLS_HYPHEN"); break;
case CLS_PLUS: fprintf(stderr, "CLS_PLUS"); break;
default: fprintf(stderr, "???");
}
fprintf(stderr, " %d items on stack\n", sp-old_sp);
#endif
switch(state) {
case 0:
if(sp != old_sp) {
if(sp == old_sp+15) {
f_aggregate(15);
push_int64(offs0);
apply_svalue(logfun, 2);
pop_stack();
} else
pop_n_elems(sp-old_sp);
}
if(cls > CLS_CRLF) {
if(cls == CLS_HYPHEN) {
push_int(0);
state = 2;
break;
}
#ifdef DYNAMIC_BUF
buf.s.str = NULL;
initialize_buf( &buf );
low_my_putchar( c, &buf );
#else
bufpos = 0;
BUFSET(c);
#endif
state=1;
}
break;
case 1:
if(cls > CLS_CRLF) {
#ifdef DYNAMIC_BUF
low_my_putchar( c, &buf );
#else
BUFSET(c);
#endif
break;
}
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) ); /* remotehost */
#else
PUSHBUF();
#endif
state = (cls == CLS_WSPACE? 2:0);
break;
case 2:
if(cls > CLS_CRLF) {
if(cls == CLS_HYPHEN) {
push_int(0);
state = 4;
break;
}
#ifdef DYNAMIC_BUF
buf.s.str = NULL;
initialize_buf( &buf );
low_my_putchar( c, &buf );
#else
bufpos = 0;
BUFSET(c);
#endif
state=3;
} else if(cls == CLS_CRLF)
state=0;
break;
case 3:
if(cls > CLS_CRLF) {
#ifdef DYNAMIC_BUF
low_my_putchar( c, &buf );
#else
BUFSET(c);
#endif
break;
}
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) ); /* rfc931 */
#else
PUSHBUF(); /* rfc931 */
#endif
state = (cls == CLS_WSPACE? 4:0);
break;
case 4:
if(cls > CLS_CRLF) {
if(cls == CLS_HYPHEN) {
push_int(0);
state = 6;
break;
}
#ifdef DYNAMIC_BUF
buf.s.str = NULL;
initialize_buf( &buf );
low_my_putchar( c, &buf );
#else
bufpos = 0;
BUFSET(c);
#endif
state=5;
} else if(cls == CLS_CRLF)
state=0;
break;
case 5:
if(cls > CLS_CRLF) {
#ifdef DYNAMIC_BUF
low_my_putchar( c, &buf );
#else
BUFSET(c);
#endif
break;
}
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) ); /* authuser */
#else
PUSHBUF(); /* authuser */
#endif
state = (cls == CLS_WSPACE? 6:0);
break;
case 6:
if(cls == CLS_LBRACK)
state = 15;
else if(cls == CLS_CRLF)
state = 0;
else if(cls == CLS_HYPHEN) {
push_int(0);
push_int(0);
push_int(0);
state = 7;
}
break;
case 7:
if(cls == CLS_QUOTE) {
#ifdef DYNAMIC_BUF
buf.s.str = NULL;
initialize_buf( &buf );
#else
bufpos = 0;
#endif
state = 31;
} else if(cls == CLS_CRLF)
state = 0;
else if(cls == CLS_HYPHEN) {
push_int(0);
push_int(0);
push_int(0);
state = 10;
}
break;
case 8:
if(cls == CLS_QUOTE)
state = 9;
else if(cls == CLS_CRLF) {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) );
#else
PUSHBUF();
#endif
state = 0;
} else
#ifdef DYNAMIC_BUF
low_my_putchar( c, &buf );
#else
BUFSET(c);
#endif
break;
case 9:
if(cls > CLS_CRLF) {
#ifdef DYNAMIC_BUF
low_my_putchar( '"', &buf);
low_my_putchar( c, &buf);
#else
BUFSET('"');
BUFSET(c);
#endif
state = 8;
break;
}
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) ); /* protocol */
#else
PUSHBUF(); /* protoocl */
#endif
state = (cls == CLS_CRLF? 0 : 10);
break;
case 10:
if(cls == CLS_DIGIT) {
v = c&0xf;
state = 11;
} else if(cls == CLS_CRLF)
state = 0;
else if(cls == CLS_HYPHEN) {
push_int(0);
state = 12;
}
break;
case 11:
if(cls == CLS_DIGIT)
v = v*10+(c&0xf);
else if(cls == CLS_WSPACE) {
push_int(v); /* status */
state = 12;
} else state = 0;
break;
case 12:
if(cls == CLS_DIGIT) {
v = c&0xf;
state = 13;
} else if(cls == CLS_CRLF)
state = 0;
else if(cls == CLS_HYPHEN) {
push_int(0);
state = 14;
}
break;
case 13:
if(cls == CLS_DIGIT)
v = v*10+(c&0xf);
else {
push_int(v); /* bytes */
state = (cls == CLS_CRLF? 0:14);
}
break;
case 14:
if(cls == CLS_CRLF)
state = 0;
break;
case 15:
if(cls == CLS_DIGIT) {
dd = c&0xf;
state = 16;
} else
state = (cls == CLS_CRLF? 0:14);
break;
case 16:
/* getting day */
if(cls == CLS_DIGIT)
dd = dd*10+(c&0xf);
else if(cls == CLS_SLASH)
state = 17;
else
state = (cls == CLS_CRLF? 0:14);
break;
case 17:
if(cls == CLS_DIGIT) {
mm = c&0xf;
state = 18;
} else if(cls == CLS_TOKEN) {
mm = c|0x20;
state = 21;
} else
state = (cls == CLS_CRLF? 0:14);
break;
case 18:
/* getting numeric month */
if(cls == CLS_DIGIT)
mm = mm*10+(c&0xf);
else if(cls == CLS_SLASH)
state = 19;
else
state = (cls == CLS_CRLF? 0:14);
break;
case 19:
if(cls == CLS_DIGIT) {
yy = c&0xf;
state = 20;
} else
state = (cls == CLS_CRLF? 0:14);
break;
case 20:
/* getting year */
if(cls == CLS_DIGIT)
yy = yy*10+(c&0xf);
else if(cls == CLS_COLON)
state = 22;
else
state = (cls == CLS_CRLF? 0:14);
break;
case 21:
/* getting textual month */
if(cls == CLS_TOKEN)
mm = (mm<<8)|c|0x20;
else if(cls == CLS_SLASH) {
state = 19;
switch(mm) {
case ('j'<<16)|('a'<<8)|'n': mm=1; break;
case ('f'<<16)|('e'<<8)|'b': mm=2; break;
case ('m'<<16)|('a'<<8)|'r': mm=3; break;
case ('a'<<16)|('p'<<8)|'r': mm=4; break;
case ('m'<<16)|('a'<<8)|'y': mm=5; break;
case ('j'<<16)|('u'<<8)|'n': mm=6; break;
case ('j'<<16)|('u'<<8)|'l': mm=7; break;
case ('a'<<16)|('u'<<8)|'g': mm=8; break;
case ('s'<<16)|('e'<<8)|'p': mm=9; break;
case ('o'<<16)|('c'<<8)|'t': mm=10; break;
case ('n'<<16)|('o'<<8)|'v': mm=11; break;
case ('d'<<16)|('e'<<8)|'c': mm=12; break;
default:
state = 14;
}
}
break;
case 22:
if(cls == CLS_DIGIT) {
h = c&0xf;
state = 23;
} else
state = (cls == CLS_CRLF? 0:14);
break;
case 23:
/* getting hour */
if(cls == CLS_DIGIT)
h = h*10+(c&0xf);
else if(cls == CLS_COLON)
state = 24;
else
state = (cls == CLS_CRLF? 0:14);
break;
case 24:
if(cls == CLS_DIGIT) {
m = c&0xf;
state = 25;
} else
state = (cls == CLS_CRLF? 0:14);
break;
case 25:
/* getting minute */
if(cls == CLS_DIGIT)
m = m*10+(c&0xf);
else if(cls == CLS_COLON)
state = 26;
else
state = (cls == CLS_CRLF? 0:14);
break;
case 26:
if(cls == CLS_DIGIT) {
s = c&0xf;
state = 27;
} else
state = (cls == CLS_CRLF? 0:14);
break;
case 27:
/* getting second */
if(cls == CLS_DIGIT)
s = s*10+(c&0xf);
else if(cls == CLS_WSPACE)
state = 28;
else
state = (cls == CLS_CRLF? 0:14);
break;
case 28:
if(cls>=CLS_HYPHEN) {
state = 29;
tzs = cls!=CLS_PLUS;
tz = 0;
} else if(cls == CLS_DIGIT) {
state = 29;
tzs = 0;
tz = c&0xf;
} else if(cls==CLS_CRLF)
state = 0;
break;
case 29:
/* getting timezone */
if(cls == CLS_DIGIT)
tz = tz*10+(c&0xf);
else {
if(tzs)
tz = -tz;
push_int(yy);
push_int(mm);
push_int(dd);
push_int(h);
push_int(m);
push_int(s);
push_int(tz);
if(cls == CLS_RBRACK)
state = 7;
else
state = (cls == CLS_CRLF? 0 : 30);
}
break;
case 30:
if(cls == CLS_RBRACK)
state = 7;
else if(cls == CLS_CRLF)
state = 0;
break;
case 31:
if(cls == CLS_QUOTE) {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) );
#else
PUSHBUF();
#endif
push_int(0);
push_int(0);
state = 10;
} else if(cls >= CLS_TOKEN)
#ifdef DYNAMIC_BUF
low_my_putchar( c, &buf );
#else
BUFSET(c);
#endif
else {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) ); /* method */
#else
PUSHBUF(); /* method */
#endif
state = (cls == CLS_CRLF? 0 : 32);
}
break;
case 32:
if(cls == CLS_QUOTE) {
push_int(0);
push_int(0);
state = 10;
} else if(cls >= CLS_TOKEN) {
#ifdef DYNAMIC_BUF
buf.s.str = NULL;
initialize_buf( &buf );
low_my_putchar( c, &buf );
#else
bufpos = 0;
BUFSET(c);
#endif
state = 33;
} else
if(cls == CLS_CRLF)
state = 0;
break;
case 33:
if(cls == CLS_QUOTE)
state = 34;
else if(cls == CLS_CRLF) {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) );
#else
PUSHBUF();
#endif
state = 0;
} else if(cls == CLS_WSPACE) {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) ); /* path */
#else
PUSHBUF(); /* path */
#endif
state = 35;
} else
#ifdef DYNAMIC_BUF
low_my_putchar( c, &buf );
#else
BUFSET(c);
#endif
break;
case 34:
if(cls >= CLS_TOKEN) {
#ifdef DYNAMIC_BUF
low_my_putchar( '"', &buf );
low_my_putchar( c, &buf );
#else
BUFSET('"');
BUFSET(c);
#endif
state = 33;
} else if(cls == CLS_CRLF) {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) );
#else
PUSHBUF();
#endif
state = 0;
} else {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) );
#else
PUSHBUF();
#endif
push_text("HTTP/0.9");
state = 10;
}
break;
case 35:
if(cls == CLS_QUOTE) {
push_text("HTTP/0.9");
state = 10;
} else if(cls >= CLS_TOKEN) {
#ifdef DYNAMIC_BUF
buf.s.str = NULL;
initialize_buf( &buf );
low_my_putchar( c, &buf );
#else
bufpos = 0;
BUFSET(c);
#endif
state = 8;
} else
if(cls == CLS_CRLF)
state = 0;
break;
}
}
}
/*! @decl program load_module(string module_name)
*!
*! Load a binary module.
*!
*! This function loads a module written in C or some other language
*! into Pike. The module is initialized and any programs or constants
*! defined will immediately be available.
*!
*! When a module is loaded the C function @tt{pike_module_init()@} will
*! be called to initialize it. When Pike exits @tt{pike_module_exit()@}
*! will be called. These two functions @b{must@} be available in the module.
*!
*! @note
*! The current working directory is normally not searched for
*! dynamic modules. Please use @expr{"./name.so"@} instead of just
*! @expr{"name.so"@} to load modules from the current directory.
*/
void f_load_module(INT32 args)
{
extern int global_callable_flags;
void *module;
modfun init, exit;
struct module_list *new_module;
struct pike_string *module_name;
ONERROR err;
module_name = Pike_sp[-args].u.string;
if((Pike_sp[-args].type != T_STRING) ||
(module_name->size_shift) ||
string_has_null(module_name)) {
Pike_error("Bad argument 1 to load_module()\n");
}
{
struct module_list *mp;
for (mp = dynamic_module_list; mp; mp = mp->next)
if (mp->name == module_name && mp->module_prog) {
pop_n_elems(args);
ref_push_program(mp->module_prog);
return;
}
}
/* Removing RTLD_GLOBAL breaks some PiGTK themes - Hubbe */
/* Using RTLD_LAZY is faster, but makes it impossible to
* detect linking problems at runtime..
*/
module=dlopen(module_name->str,
RTLD_NOW /*|RTLD_GLOBAL*/ );
if(!module)
{
struct object *err_obj = low_clone (module_load_error_program);
#define LOADERR_STRUCT(OBJ) \
((struct module_load_error_struct *) (err_obj->storage + module_load_error_offset))
const char *err = dlerror();
if (err) {
if (err[strlen (err) - 1] == '\n')
push_string (make_shared_binary_string (err, strlen (err) - 1));
else
push_text (err);
}
else
push_constant_text ("Unknown reason");
add_ref (LOADERR_STRUCT (err_obj)->path = Pike_sp[-args - 1].u.string);
add_ref (LOADERR_STRUCT (err_obj)->reason = Pike_sp[-1].u.string);
if (Pike_sp[-args].u.string->len < 1024) {
throw_error_object (err_obj, "load_module", Pike_sp - args - 1, args,
"load_module(\"%s\") failed: %s\n",
module_name->str, Pike_sp[-1].u.string->str);
} else {
throw_error_object (err_obj, "load_module", Pike_sp - args - 1, args,
"load_module() failed: %s\n",
Pike_sp[-1].u.string->str);
}
}
#ifdef PIKE_DEBUG
{
struct module_list *mp;
for (mp = dynamic_module_list; mp; mp = mp->next)
if (mp->module == module && mp->module_prog) {
fprintf(stderr, "load_module(): Module loaded twice:\n"
"Old name: %s\n"
"New name: %s\n",
mp->name->str, module_name->str);
pop_n_elems(args);
ref_push_program(mp->module_prog);
return;
}
}
#endif /* PIKE_DEBUG */
init = CAST_TO_FUN(dlsym(module, "pike_module_init"));
if (!init) {
init = CAST_TO_FUN(dlsym(module, "_pike_module_init"));
if (!init) {
dlclose(module);
Pike_error("pike_module_init missing in dynamic module \"%S\".\n",
module_name);
}
}
exit = CAST_TO_FUN(dlsym(module, "pike_module_exit"));
if (!exit) {
exit = CAST_TO_FUN(dlsym(module, "_pike_module_exit"));
if (!exit) {
dlclose(module);
Pike_error("pike_module_exit missing in dynamic module \"%S\".\n",
module_name);
}
}
#if defined(__NT__) && defined(_M_IA64)
{
fprintf(stderr, "pike_module_init: 0x%p\n"
" func: 0x%p\n"
" gp: 0x%p\n",
init, ((void **)init)[0], ((void **)init)[1]);
fprintf(stderr, "pike_module_exit: 0x%p\n"
" func: 0x%p\n"
" gp: 0x%p\n",
exit, ((void **)exit)[0], ((void **)exit)[1]);
}
#endif /* __NT__ && _M_IA64 */
new_module=ALLOC_STRUCT(module_list);
new_module->next=dynamic_module_list;
dynamic_module_list=new_module;
new_module->module=module;
copy_shared_string(new_module->name, Pike_sp[-args].u.string);
new_module->module_prog = NULL;
new_module->init=init;
new_module->exit=exit;
enter_compiler(new_module->name, 1);
start_new_program();
global_callable_flags|=CALLABLE_DYNAMIC;
#ifdef PIKE_DEBUG
{ struct svalue *save_sp=Pike_sp;
#endif
SET_ONERROR(err, cleanup_compilation, NULL);
#if defined(__NT__) && defined(_M_IA64)
fprintf(stderr, "Calling pike_module_init()...\n");
#endif /* __NT__ && _M_IA64 */
(*(modfun)init)();
#if defined(__NT__) && defined(_M_IA64)
fprintf(stderr, "pike_module_init() done.\n");
#endif /* __NT__ && _M_IA64 */
UNSET_ONERROR(err);
#ifdef PIKE_DEBUG
if(Pike_sp != save_sp)
Pike_fatal("load_module(%s) left %ld droppings on stack!\n",
module_name->str,
PTRDIFF_T_TO_LONG(Pike_sp - save_sp));
}
#endif
pop_n_elems(args);
{
struct program *p = end_program();
exit_compiler();
if (p) {
if (
#if 0
p->num_identifier_references
#else /* !0 */
1
#endif /* 0 */
) {
push_program(p);
add_ref(new_module->module_prog = Pike_sp[-1].u.program);
} else {
/* No identifier references -- Disabled module. */
free_program(p);
push_undefined();
}
} else {
/* Initialization failed. */
new_module->exit();
dlclose(module);
dynamic_module_list = new_module->next;
free_string(new_module->name);
free(new_module);
Pike_error("Failed to initialize dynamic module \"%S\".\n",
module_name);
}
}
}
static void make_colors(void)
{
static struct color
{
int r,g,b;
char *name;
struct pike_string *pname;
} c[]={
#define COLOR(name,R,G,B) \
{R,G,B,name,NULL},
#include "colors.h"
#undef COLOR
};
int i;
const int n=sizeof(c)/sizeof(c[0]);
for (i=0; (size_t)i<sizeof(html_color)/sizeof(html_color[0]); i++)
html_color[i].pname=make_shared_string(html_color[i].name);
for (i=0;i<n;i++)
{
struct color_struct *cs;
push_text(c[i].name);
copy_shared_string(c[i].pname,sp[-1].u.string);
push_object(clone_object(image_color_program,0));
cs=get_storage(sp[-1].u.object,image_color_program);
cs->rgb.r=(COLORTYPE)c[i].r;
cs->rgb.g=(COLORTYPE)c[i].g;
cs->rgb.b=(COLORTYPE)c[i].b;
RGB_TO_RGBL(cs->rgbl,cs->rgb);
copy_shared_string(cs->name,c[i].pname);
}
f_aggregate_mapping(n*2);
colors=sp[-1].u.mapping;
sp--;
dmalloc_touch_svalue(sp);
for (i=0;i<n;i++)
{
push_int(c[i].r);
push_int(c[i].g);
push_int(c[i].b);
f_aggregate(3);
}
f_aggregate(n);
colortable=clone_object(image_colortable_program,1);
if (!colortable)
Pike_fatal("couldn't create colortable\n");
push_int(12);
push_int(12);
push_int(12);
push_int(1);
safe_apply(colortable,"cubicles",4);
pop_stack();
for (i=0;i<n;i++)
push_string(c[i].pname);
f_aggregate(n);
colornames=sp[-1].u.array;
sp--;
dmalloc_touch_svalue(sp);
}