79b4dc2015-09-14Henrik Grubbström (Grubba) /* -*- mode: c; encoding: utf-8; -*-
e576bb2002-10-11Martin Nilsson || This file is part of Pike. For copyright information see COPYRIGHT. || Pike is distributed under GPL, LGPL and MPL. See the file COPYING || for more information. */
c3da7f2000-07-04Martin Stjernholm 
3a5b1d2000-05-24Fredrik Hübinette (Hubbe) #include "global.h" #include "interpret.h" #include "svalue.h" #include "pike_macros.h" #include "object.h" #include "program.h" #include "array.h"
bb8a782000-12-01Fredrik Hübinette (Hubbe) #include "pike_error.h"
3a5b1d2000-05-24Fredrik Hübinette (Hubbe) #include "constants.h" #include "mapping.h" #include "stralloc.h" #include "multiset.h" #include "pike_types.h" #include "pike_memory.h" #include "threads.h" #include "module_support.h" #include "cyclic.h" #include "bignum.h"
098c802000-05-24Fredrik Hübinette (Hubbe) #include "main.h"
b8c5b22000-05-25Fredrik Hübinette (Hubbe) #include "operators.h"
9da7f42001-06-05Martin Stjernholm #include "builtin_functions.h"
fed7de2001-06-28Henrik Grubbström (Grubba) #include "fsort.h"
a52eee2015-08-02Henrik Grubbström (Grubba) #include "stuff.h"
51adb82003-01-12Martin Stjernholm #include "gc.h"
d476592013-06-12Arne Goedeke #include "block_allocator.h"
c0d3772006-03-30Henrik Grubbström (Grubba) #include "pikecode.h"
f1d1aa2012-07-13Henrik Grubbström (Grubba) #include "opcodes.h"
a215142014-02-16Martin Nilsson #include "whitespace.h"
6c15cb2008-06-10Martin Stjernholm  #include <ctype.h> #include <errno.h> #include <math.h>
1f12012016-01-13Martin Nilsson #include <fcntl.h>
87aa2e2015-04-02Henrik Grubbström (Grubba)  #ifdef HAVE_ARPA_INET_H
9623712014-08-27Per Hedbor #include <arpa/inet.h>
87aa2e2015-04-02Henrik Grubbström (Grubba) #endif /* HAVE_ARPA_INET_H */
3a5b1d2000-05-24Fredrik Hübinette (Hubbe) 
a980cf2014-09-10Henrik Grubbström (Grubba) #define DEFAULT_CMOD_STORAGE
56c0642008-07-31Martin Stjernholm DECLARATIONS
12327f2013-05-22Per Hedbor  /*! @module System */ /*! @class TM *! A wrapper for the system struct tm time keeping structure. *! This can be used as a (very) lightweight alternative to Calendar. */
3c7f172013-11-17Henrik Grubbström (Grubba) PIKECLASS TM
12327f2013-05-22Per Hedbor { CVAR struct tm t; CVAR time_t unix_time; CVAR int modified; CVAR struct pike_string *set_zone; #ifdef STRUCT_TM_HAS___TM_GMTOFF #define tm_zone __tm_zone #define tm_gmtoff __tm_gmtoff
09b6e22013-07-08Henrik Grubbström (Grubba) #define GET_GMTOFF(TM) ((TM)->tm_gmtoff) #define GET_ZONE(TM) ((TM)->tm_zone) #define SET_GMTOFF(TM, VAL) (((TM)->tm_gmtoff) = (VAL)) #define SET_ZONE(TM, VAL) (((TM)->tm_zone) = (VAL)) #elif defined(STRUCT_TM_HAS_GMTOFF) #define GET_GMTOFF(TM) ((TM)->tm_gmtoff) #define GET_ZONE(TM) ((TM)->tm_zone) #define SET_GMTOFF(TM, VAL) (((TM)->tm_gmtoff) = (VAL)) #define SET_ZONE(TM, VAL) (((TM)->tm_zone) = (VAL)) #else #define GET_GMTOFF(TM) 0 #define GET_ZONE(TM) ((char*)NULL) #define SET_GMTOFF(TM, VAL) (VAL) #define SET_ZONE(TM, VAL) (VAL)
12327f2013-05-22Per Hedbor #endif #define strftime_zone strftime #define mktime_zone mktime #define strptime_zone strptime #define asctime_zone asctime #define localtime_zone(X,Y) localtime(X) #ifndef HAVE_EXTERNAL_TIMEZONE #undef timezone #endif #define MODIFY(X) do{ THIS->modified = 1;THIS->t.X; }while(0) #define FIX_THIS() do { \ if(THIS->modified){ \ THIS->unix_time = mktime_zone( &THIS->t ); \ THIS->modified = 0; \ } \ } while(0)
379f922013-05-27Per Hedbor #ifdef HAVE_STRPTIME
670cfc2013-11-17Henrik Grubbström (Grubba)  /*! @decl int(0..1) strptime( string(1..255) format, string(1..255) data )
12327f2013-05-22Per Hedbor  *! *! Parse the given @[data] using the format in @[format] as a date. *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @dl *! @item %% *! The % character.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %a or %A *! The weekday name according to the C locale, in abbreviated *! form or the full name.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %b or %B or %h *! The month name according to the C locale, in abbreviated form *! or the full name.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %c *! The date and time representation for the C locale.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %C *! The century number (0-99).
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %d or %e *! The day of month (1-31).
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %D *! Equivalent to %m/%d/%y.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %H *! The hour (0-23).
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %I *! The hour on a 12-hour clock (1-12).
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %j *! The day number in the year (1-366).
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %m *! The month number (1-12).
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %M *! The minute (0-59).
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %n *! Arbitrary whitespace.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %p *! The C locale's equivalent of AM or PM.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %R *! Equivalent to %H:%M.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %S *! The second (0-60; 60 may occur for leap seconds; *! earlier also 61 was allowed).
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %t *! Arbitrary whitespace.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %T *! Equivalent to %H:%M:%S.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %U *! The week number with Sunday the first day of the week (0-53).
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %w *! The weekday number (0-6) with Sunday = 0.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %W *! The week number with Monday the first day of the week (0-53).
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %x *! The date, using the C locale's date format.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %X *! The time, using the C locale's time format.
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %y *! The year within century (0-99). When a century is not *! otherwise specified, values in the range 69-99 refer to years *! in the twentieth century (1969-1999); values in the range *! 00-68 refer to years in the twenty-first century (2000-2068).
12327f2013-05-22Per Hedbor  *!
6bd26d2013-11-17Henrik Grubbström (Grubba)  *! @item %Y *! The year, including century (for example, 1991). *! @enddl
12327f2013-05-22Per Hedbor  *! */ PIKEFUN int(0..1) strptime( string(1..255) format, string(1..255) data ) { if( format->size_shift || data->size_shift ) Pike_error("Only 8bit strings are supported\n"); THIS->modified = 1; if( strptime_zone( data->str, format->str, &THIS->t ) == NULL ) RETURN 0; RETURN 1; }
4907f62014-09-04Martin Nilsson #endif /* HAVE_STRPTIME */
6bd26d2013-11-17Henrik Grubbström (Grubba)  /*! @decl string(1..255) strftime( string(1..255) format ) *! See also @[Gettext.setlocale] *! *! Convert the structure to a string. *! *! @dl *! @item %a *! The abbreviated weekday name according to the current locale *! *! @item %A *! The full weekday name according to the current locale. *! *! @item %b *! The abbreviated month name according to the current locale. *! *! @item %B *! The full month name according to the current locale. *! *! @item %c *! The preferred date and time representation for the current locale. *! *! @item %C *! The century number (year/100) as a 2-digit integer. *! *! @item %d *! The day of the month as a decimal number (range 01 to 31). *! *! @item %D *! Equivalent to @expr{%m/%d/%y@}. (for Americans only. *! Americans should note that in other countries @expr{%d/%m/%y@} *! is rather common. This means that in international context *! this format is ambiguous and should not be used.) *! *! @item %e *! Like @expr{%d@}, the day of the month as a decimal number, *! but a leading zero is replaced by a space. *! *! @item %E *! Modifier: use alternative format, see below. *! *! @item %F *! Equivalent to %Y-%m-%d (the ISO 8601 date format). (C99) *! *! @item %G *! The ISO 8601 week-based year (see NOTES) with century as a *! decimal number. The 4-digit year corresponding to the ISO *! week number (see @expr{%V@}). This has the same format and *! value as @expr{%Y@}, except that if the ISO week number *! belongs to the previous or next year, that year is used instead. *! *! @item %g *! Like @expr{%G@}, but without century, that is, *! with a 2-digit year (00-99). (TZ) *! *! @item %h *! Equivalent to %b. *! *! @item %H *! The hour as a decimal number using a 24-hour clock (range 00 to 23). *! *! @item %I *! The hour as a decimal number using a 12-hour clock (range 01 to 12). *! *! @item %j *! The day of the year as a decimal number (range 001 to 366). *! *! @item %k *! The hour (24-hour clock) as a decimal number (range 0 to 23); *! single digits are preceded by a blank. (See also @expr{%H@}.) *! *! @item %l *! The hour (12-hour clock) as a decimal number (range 1 to 12); *! single digits are preceded by a blank. (See also @expr{%I@}.) *! *! @item %m *! The month as a decimal number (range 01 to 12). *! *! @item %M *! The minute as a decimal number (range 00 to 59). *! *! @item %n *! A newline character. (SU) *! *! @item %O *! Modifier: use alternative format, see below. (SU) *! *! @item %p *! Either @expr{"AM"@} or @expr{"PM"@} according to the given time *! value, or the corresponding strings for the current locale. *! Noon is treated as @expr{"PM"@} and midnight as @expr{"AM"@}. *! *! @item %P *! Like @expr{%p@} but in lowercase: @expr{"am"@} or @expr{"pm"@} *! or a corresponding string for the current locale. *! *! @item %r *! The time in a.m. or p.m. notation. In the POSIX locale this is *! equivalent to @expr{%I:%M:%S %p@}. *! *! @item %R *! The time in 24-hour notation (@expr{%H:%M@}). (SU) *! For a version including the seconds, see @expr{%T@} below. *! *! @item %s *! The number of seconds since the Epoch, *! 1970-01-01 00:00:00 +0000 (UTC). (TZ) *! *! @item %S *! The second as a decimal number (range 00 to 60). *! (The range is up to 60 to allow for occasional leap seconds.) *! *! @item %t *! A tab character. (SU) *! *! @item %T *! The time in 24-hour notation (@expr{%H:%M:%S@}). (SU) *! *! @item %u *! The day of the week as a decimal, range 1 to 7, Monday being 1. *! See also @expr{%w@}. (SU) *! *! @item %U *! The week number of the current year as a decimal number, *! range 00 to 53, starting with the first Sunday as the first *! day of week 01. See also @expr{%V@} and @expr{%W@}. *! *! @item %V *! The ISO 8601 week number of the current year as a decimal number, *! range 01 to 53, where week 1 is the first week that has at least *! 4 days in the new year. See also @expr{%U@} and @expr{%W@}. *! *! @item %w *! The day of the week as a decimal, range 0 to 6, Sunday being 0. *! See also @expr{%u@}. *! @enddl */
12327f2013-05-22Per Hedbor  PIKEFUN string strftime(string(1..255) format) { char *buffer = xalloc( 8192 ); buffer[0] = 0; strftime_zone( buffer, 8192, format->str, &THIS->t ); push_text( buffer ); }
670cfc2013-11-17Henrik Grubbström (Grubba)  /*! @decl int(0..60) sec;
12327f2013-05-22Per Hedbor  *! @decl int(0..59) min; *! @decl int(0..59) hour; *! @decl int(1..31) mday; *! @decl int(0..11) mon; *! @decl int year; *! *! The various fields in the structure. Note that setting these *! might cause other fields to be recalculated, as an example, *! adding 1000 to the hour field would advance the 'mday', 'mon' *! and possibly 'year' fields. *! *! When read the fields are always normalized. *! *! Unlike the system struct tm the 'year' field is not year-1900, *! instead it is the actual year. */ PIKEFUN int(0..60) `sec() { FIX_THIS();RETURN THIS->t.tm_sec; } PIKEFUN int(0..59) `min() { FIX_THIS();RETURN THIS->t.tm_min; } PIKEFUN int(0..23) `hour() { FIX_THIS();RETURN THIS->t.tm_hour; } PIKEFUN int(1..31) `mday() { FIX_THIS();RETURN THIS->t.tm_mday; } PIKEFUN int(0..11) `mon() { FIX_THIS();RETURN THIS->t.tm_mon; }
7a74cc2014-08-26Per Hedbor  PIKEFUN int `year() { FIX_THIS();RETURN THIS->t.tm_year+1900; }
12327f2013-05-22Per Hedbor  PIKEFUN int `sec=(int a) { MODIFY(tm_sec=a); } PIKEFUN int `min=(int a) { MODIFY(tm_min=a); } PIKEFUN int `hour=(int a){ MODIFY(tm_hour=a); } PIKEFUN int `mday=(int a){ MODIFY(tm_mday=a); } PIKEFUN int `year=(int a){ MODIFY(tm_year=a-1900); } PIKEFUN int `mon=(int a){ MODIFY(tm_mon=a); } /*! @decl int isdst *! *! True if daylight savings are in effect. If this field is -1 *! (the default) it (and the timezone info) will be updated *! automatically using the timezone rules. */ PIKEFUN int(-1..1) `isdst() { FIX_THIS(); RETURN THIS->t.tm_isdst; } /*! @decl int wday *! The day of the week, sunday is 0, saturday is 6. *! This is calculated from the other fields and can not be changed directly. */ PIKEFUN int(0..6) `wday() { FIX_THIS(); RETURN THIS->t.tm_wday; } /*! @decl int yday *! The day of the year, from 0 (the first day) to 365 *! This is calculated from the other fields and can not be changed directly. */ PIKEFUN int(0..365) `yday() { FIX_THIS(); RETURN THIS->t.tm_yday; } /*! @decl int unix_time() *! Return the unix time corresponding to this time_t. If no time *! can be parsed from the structure -1 is returned. */ PIKEFUN int unix_time() { FIX_THIS(); RETURN THIS->unix_time; } /*! @decl string asctime() *! Return a string representing the time. Mostly useful for debug *! purposes, the exact format is very locale (see *! @[Gettext.setlocale]) and OS dependent. */ PIKEFUN string asctime() { FIX_THIS(); { char *tval = asctime_zone( &THIS->t ); if( tval ) push_text( tval ); else
5dfbb42013-12-07Arne Goedeke  push_undefined();
12327f2013-05-22Per Hedbor  } }
91829a2015-11-08Martin Nilsson  PIKEFUN string _sprintf( int flag, mapping options )
12327f2013-05-22Per Hedbor  { int post_sum = 1; switch( flag ) { case 'O':
75367d2014-08-22Arne Goedeke  push_static_text("System.TM(");
12327f2013-05-22Per Hedbor  post_sum = 1; /* fallthrough */ case 's': f_TM_asctime(0);
75367d2014-08-22Arne Goedeke  push_static_text("\n");
09b6e22013-07-08Henrik Grubbström (Grubba)  if( GET_ZONE(&(THIS->t)) )
12327f2013-05-22Per Hedbor  {
75367d2014-08-22Arne Goedeke  push_static_text(" ");
09b6e22013-07-08Henrik Grubbström (Grubba)  push_text( GET_ZONE(&(THIS->t)) );
12327f2013-05-22Per Hedbor  f_add( 2 ); } else
75367d2014-08-22Arne Goedeke  push_static_text("");
12327f2013-05-22Per Hedbor  f_replace( 3 ); break; case 'd': f_TM_unix_time(0); break; default: Pike_error("Can not format as %c", flag ); } if( post_sum ) {
75367d2014-08-22Arne Goedeke  push_static_text(")");
12327f2013-05-22Per Hedbor  f_add(3); } }
7a74cc2014-08-26Per Hedbor  /*! @decl int|string cast(string to) *! *! Casted to an integer @[unix_time] will be returned. *! *! Casting to a string will call @[asctime]. */ PIKEFUN int|string cast( string to )
68ec3f2014-08-18Martin Nilsson  flags ID_PROTECTED;
12327f2013-05-22Per Hedbor  {
68ec3f2014-08-18Martin Nilsson  if( to == literal_int_string )
12327f2013-05-22Per Hedbor  { f_TM_unix_time(0); return; }
68ec3f2014-08-18Martin Nilsson  if( to == literal_string_string )
12327f2013-05-22Per Hedbor  { f_TM_asctime(0); return;
68ec3f2014-08-18Martin Nilsson  } pop_stack(); push_undefined();
12327f2013-05-22Per Hedbor  } /*! @decl string zone *! *! The timezone of this structure */ PIKEFUN string `zone() { FIX_THIS();
09b6e22013-07-08Henrik Grubbström (Grubba)  if( GET_ZONE(&(THIS->t)) ) push_text( GET_ZONE(&(THIS->t)) );
12327f2013-05-22Per Hedbor  else push_undefined(); } /*! @decl int gmtoff *! The offset from GMT for the time in this tm-struct */ PIKEFUN int `gmtoff() { FIX_THIS();
09b6e22013-07-08Henrik Grubbström (Grubba)  push_int( GET_GMTOFF(&(THIS->t)) );
12327f2013-05-22Per Hedbor  } /* Setting the zone does not work, so.. */ /* PIKEFUN string `zone=(string x) { */ /* if( THIS->set_zone ) */ /* free_string( THIS->set_zone ); */ /* THIS->set_zone = x; */ /* MODIFY( tm_zone = x->str ); */ /* x->refs++; */ /* } */ /*! @decl int(0..1) localtime( int time ) *! Initialize the struct tm to the local time for the specified *! unix time_t. */ PIKEFUN int(0..1) localtime( int _t ) { time_t t = _t; struct tm *res = localtime_zone( &t, &THIS->t );
fdc9042015-04-17Martin Nilsson  if( !res ) RETURN 0;
12327f2013-05-22Per Hedbor  /* These are supposedly correctly by localtime_zone. */
09b6e22013-07-08Henrik Grubbström (Grubba)  SET_GMTOFF(res, GET_GMTOFF(&(THIS->t))); SET_ZONE(res, GET_ZONE(&(THIS->t)));
12327f2013-05-22Per Hedbor  THIS->t = *res; THIS->modified = 1; RETURN 1; } /*! @decl int(0..1) gmtime( int time ) *! Initialize the struct tm to the UTC time for the specified *! unix time_t. */ PIKEFUN int(0..1) gmtime( int _t ) { time_t t = _t; struct tm *res = gmtime( &t ); if( !res ) RETURN 0; THIS->t = *res; THIS->modified = 1; RETURN 1; }
8e94242013-05-28Henrik Grubbström (Grubba)  /*! @decl void create(int t) *! Create a new @[TM] initialized from a unix time_t.
12327f2013-05-22Per Hedbor  *! The timezone will always be UTC when using this function. */ PIKEFUN void create( int _t ) { f_TM_gmtime( 1 ); if( Pike_sp[-1].u.integer == 0 ) Pike_error("time out of range\n"); }
8e94242013-05-28Henrik Grubbström (Grubba)  /*! @decl void create() *! Construct a new TM, all fields will be set to 0. */
12327f2013-05-22Per Hedbor  PIKEFUN void create( ) { memset( &THIS->t, 0, sizeof( struct tm ) ); THIS->t.tm_isdst = -1; THIS->unix_time = 0; THIS->modified = 1; }
8e94242013-05-28Henrik Grubbström (Grubba)  /*! @decl void create( int year, int(0..11) mon, int(1..31) mday, @ *! int(0..24) hour, int(0..59) min, int(0..59) sec, @ *! string|void timezone ) *! Construct a new time using the given values.
12327f2013-05-22Per Hedbor  *! Slightly faster than setting them individually. */ PIKEFUN void create( int year, int(0..11) mon, int(1..31) mday, int(0..24) hour, int(0..59) min, int(0..59) sec, string|void timezone ) { struct tm *t = &THIS->t; t->tm_isdst = -1;
8e94242013-05-28Henrik Grubbström (Grubba)  t->tm_year = year - 1900;
12327f2013-05-22Per Hedbor  t->tm_mon = mon; t->tm_mday = mday; t->tm_hour = hour; t->tm_min = min; t->tm_sec = sec;
8e94242013-05-28Henrik Grubbström (Grubba)  if (THIS->set_zone) { free_string(THIS->set_zone); THIS->set_zone = NULL; }
12327f2013-05-22Per Hedbor  if( !timezone ) /* gmtime. */
09b6e22013-07-08Henrik Grubbström (Grubba)  SET_ZONE(t, "UTC");
12327f2013-05-22Per Hedbor  else {
8e94242013-05-28Henrik Grubbström (Grubba)  add_ref(timezone);
12327f2013-05-22Per Hedbor  THIS->set_zone = timezone;
09b6e22013-07-08Henrik Grubbström (Grubba)  SET_ZONE(t, timezone->str);
12327f2013-05-22Per Hedbor  } THIS->unix_time = mktime_zone( t ); } INIT { THIS->set_zone = 0; THIS->modified = 0; } EXIT { if( THIS->set_zone ) free_string( THIS->set_zone ); } }
e7afd92013-11-17Henrik Grubbström (Grubba) /*! @endclass */
12327f2013-05-22Per Hedbor #undef FIX_THIS #ifdef STRUCT_TM_HAS___TM_GMTOFF #undef tm_zone
09b6e22013-07-08Henrik Grubbström (Grubba) #undef tm_gmtoff
12327f2013-05-22Per Hedbor #endif
4907f62014-09-04Martin Nilsson 
12327f2013-05-22Per Hedbor /*! @endmodule */
7faf1e2005-01-08Henrik Grubbström (Grubba) /*! @decl array(array(int|string|type)) describe_program(program p)
2d8e642002-11-25Martin Nilsson  *! @belongs Debug
7d1b3b2001-12-21Henrik Grubbström (Grubba)  *! *! Debug function for showing the symbol table of a program.
7faf1e2005-01-08Henrik Grubbström (Grubba)  *! *! @returns *! Returns an array of arrays with the following information *! for each symbol in @[p]: *! @array *! @elem int modifiers *! Bitfield with the modifiers for the symbol. *! @elem string symbol_name *! Name of the symbol. *! @elem type value_type *! Value type for the symbol. *! @elem int symbol_type *! Type of symbol. *! @elem int symbol_offset *! Offset into the code or data area for the symbol. *! @elem int inherit_offset *! Offset in the inherit table to the inherit containing *! the symbol. *! @elem int inherit_level *! Depth in the inherit tree for the inherit containing *! the symbol. *! @endarray *! *! @note *! The API for this function is not fixed, and has changed *! since Pike 7.6. In particular it would make sense to return *! an array of objects instead, and more information about the *! symbols might be added.
7d1b3b2001-12-21Henrik Grubbström (Grubba)  */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
7d1b3b2001-12-21Henrik Grubbström (Grubba) PIKEFUN array(array(int|string)) _describe_program(mixed x) efun; { struct program *p; struct array *res; int i;
d4ecd72003-01-05Martin Nilsson  if (!(p = program_from_svalue(Pike_sp - args)))
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("_describe_program", 1, "program");
7d1b3b2001-12-21Henrik Grubbström (Grubba)  for (i=0; i < (int)p->num_identifier_references;i++) { struct reference *ref = p->identifier_references + i; struct identifier *id = ID_FROM_PTR(p, ref);
cab69e2002-04-24Henrik Grubbström (Grubba)  struct inherit *inh = INHERIT_FROM_PTR(p, ref);
7d1b3b2001-12-21Henrik Grubbström (Grubba)  push_int(ref->id_flags); ref_push_string(id->name);
7faf1e2005-01-08Henrik Grubbström (Grubba)  ref_push_type_value(id->type);
cab69e2002-04-24Henrik Grubbström (Grubba)  push_int(id->identifier_flags);
c278f72003-08-03Martin Stjernholm  if (IDENTIFIER_IS_C_FUNCTION(id->identifier_flags)) {
cab69e2002-04-24Henrik Grubbström (Grubba)  push_int(-2); } else { push_int(id->func.offset); } push_int(ref->inherit_offset); push_int(inh->inherit_level);
7faf1e2005-01-08Henrik Grubbström (Grubba)  f_aggregate(7);
7d1b3b2001-12-21Henrik Grubbström (Grubba)  } f_aggregate(p->num_identifier_references);
cdf18a2003-03-14Henrik Grubbström (Grubba)  dmalloc_touch_svalue(Pike_sp-1);
cbaa3a2002-05-24Henrik Grubbström (Grubba)  res = Pike_sp[-1].u.array; Pike_sp--;
7d1b3b2001-12-21Henrik Grubbström (Grubba)  pop_n_elems(args); push_array(res); }
d9a93b2001-07-01Fredrik Hübinette (Hubbe) /*! @decl string basetype(mixed x) *! *! Same as sprintf("%t",x); *! *! @seealso *! @[sprintf()] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
d9a93b2001-07-01Fredrik Hübinette (Hubbe) PIKEFUN string basetype(mixed x) efun; optflags OPT_TRY_OPTIMIZE; {
017b572011-10-28Henrik Grubbström (Grubba)  int t = TYPEOF(*x);
2a8be12004-12-21Henrik Grubbström (Grubba)  struct program *p;
017b572011-10-28Henrik Grubbström (Grubba)  if(t == T_OBJECT && (p = x->u.object->prog))
d9a93b2001-07-01Fredrik Hübinette (Hubbe)  {
017b572011-10-28Henrik Grubbström (Grubba)  ptrdiff_t fun = FIND_LFUN(p->inherits[SUBTYPEOF(*x)].prog, LFUN__SPRINTF);
d9a93b2001-07-01Fredrik Hübinette (Hubbe)  if(fun != -1) { push_int('t'); f_aggregate_mapping(0);
2a8be12004-12-21Henrik Grubbström (Grubba)  apply_low(x->u.object,
017b572011-10-28Henrik Grubbström (Grubba)  fun + p->inherits[SUBTYPEOF(*x)].identifier_level, 2); if(TYPEOF(Pike_sp[-1]) == T_STRING)
d9a93b2001-07-01Fredrik Hübinette (Hubbe)  { stack_swap(); pop_stack(); return;
9f516a2001-12-16Martin Stjernholm  } else if (UNSAFE_IS_ZERO(Pike_sp-1)) {
63a7302001-07-02Henrik Grubbström (Grubba)  pop_n_elems(2);
6a932b2014-08-18Martin Nilsson  ref_push_string(literal_object_string);
9db2bf2001-07-02Henrik Grubbström (Grubba)  return; } else { Pike_error("Non-string returned from _sprintf()\n");
d9a93b2001-07-01Fredrik Hübinette (Hubbe)  } } } pop_stack(); switch(t) {
6a932b2014-08-18Martin Nilsson  case T_ARRAY: ref_push_string(literal_array_string); break; case T_FLOAT: ref_push_string(literal_float_string); break; case T_FUNCTION: ref_push_string(literal_function_string); break; case T_INT: ref_push_string(literal_int_string); break; case T_MAPPING: ref_push_string(literal_mapping_string); break; case T_MULTISET: ref_push_string(literal_multiset_string); break; case T_OBJECT: ref_push_string(literal_object_string); break; case T_PROGRAM: ref_push_string(literal_program_string); break; case T_STRING: ref_push_string(literal_string_string); break; case T_TYPE: ref_push_string(literal_type_string); break;
d9a93b2001-07-01Fredrik Hübinette (Hubbe)  case T_ZERO: push_constant_text("zero"); break; case T_VOID: push_constant_text("void"); break;
a903032003-02-16Martin Stjernholm  /* The following are internal and shouldn't be applicable in normal use. */
75367d2014-08-22Arne Goedeke  case T_SVALUE_PTR: push_static_text("svalue_ptr"); break; case T_OBJ_INDEX: push_static_text("obj_index"); break; case T_MAPPING_DATA: push_static_text("mapping_data"); break; case T_PIKE_FRAME: push_static_text("pike_frame"); break; case T_MULTISET_DATA: push_static_text("multiset_data"); break; default: push_static_text("unknown"); break;
d9a93b2001-07-01Fredrik Hübinette (Hubbe)  } } /*! @decl string int2char(int x)
ba24802002-04-07Martin Nilsson  *! @appears String.int2char
d9a93b2001-07-01Fredrik Hübinette (Hubbe)  *! *! Same as sprintf("%c",x); *! *! @seealso *! @[sprintf()] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
d9a93b2001-07-01Fredrik Hübinette (Hubbe) PIKEFUN string int2char(int|object x) efun; optflags OPT_TRY_OPTIMIZE;
6416012014-08-31Henrik Grubbström (Grubba)  rawtype tFunc(tSetvar(0, tOr(tInt,tObj)), tNStr(tVar(0)));
d9a93b2001-07-01Fredrik Hübinette (Hubbe) { int c;
2a8be12004-12-21Henrik Grubbström (Grubba)  struct program *p;
017b572011-10-28Henrik Grubbström (Grubba)  if(TYPEOF(*x) == T_OBJECT && (p = x->u.object->prog))
d9a93b2001-07-01Fredrik Hübinette (Hubbe)  {
017b572011-10-28Henrik Grubbström (Grubba)  ptrdiff_t fun = FIND_LFUN(p->inherits[SUBTYPEOF(*x)].prog, LFUN__SPRINTF);
d9a93b2001-07-01Fredrik Hübinette (Hubbe)  if(fun != -1) { push_int('c'); f_aggregate_mapping(0);
2a8be12004-12-21Henrik Grubbström (Grubba)  apply_low(x->u.object,
017b572011-10-28Henrik Grubbström (Grubba)  fun + p->inherits[SUBTYPEOF(*x)].identifier_level, 2); if(TYPEOF(Pike_sp[-1]) == T_STRING)
d9a93b2001-07-01Fredrik Hübinette (Hubbe)  { stack_swap(); pop_stack(); return; }
8f5b5b2001-07-02Henrik Grubbström (Grubba)  Pike_error("Non-string returned from _sprintf()\n");
d9a93b2001-07-01Fredrik Hübinette (Hubbe)  } }
017b572011-10-28Henrik Grubbström (Grubba)  if(TYPEOF(*x) != T_INT)
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("int2char", 1, "int");
d9a93b2001-07-01Fredrik Hübinette (Hubbe)  c=x->u.integer; if(c>=0 && c<256) { struct pike_string *s; s=begin_shared_string(1); s->str[0]=c; RETURN end_shared_string(s); }else{ struct string_builder tmp; init_string_builder(&tmp,0); string_builder_putchar(&tmp, c); RETURN finish_string_builder(&tmp); } }
7b45292001-08-15Fredrik Hübinette (Hubbe) /*! @decl string int2hex(int x)
ba24802002-04-07Martin Nilsson  *! @appears String.int2hex
7b45292001-08-15Fredrik Hübinette (Hubbe)  *!
e97b362004-04-25Martin Nilsson  *! Same as @expr{sprintf("%x",x);@}, i.e. returns the integer @[x] in *! hexadecimal base using lower cased symbols.
7b45292001-08-15Fredrik Hübinette (Hubbe)  *! *! @seealso *! @[sprintf()] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
7b45292001-08-15Fredrik Hübinette (Hubbe) PIKEFUN string int2hex(int|object x) efun; optflags OPT_TRY_OPTIMIZE; { INT_TYPE c;
a973872003-01-26Mirar (Pontus Hagland)  unsigned INT_TYPE n;
7b45292001-08-15Fredrik Hübinette (Hubbe)  int len; struct pike_string *s;
2a8be12004-12-21Henrik Grubbström (Grubba)  struct program *p;
7b45292001-08-15Fredrik Hübinette (Hubbe) 
017b572011-10-28Henrik Grubbström (Grubba)  if(TYPEOF(*x) == T_OBJECT && (p = x->u.object->prog))
7b45292001-08-15Fredrik Hübinette (Hubbe)  {
017b572011-10-28Henrik Grubbström (Grubba)  ptrdiff_t fun = FIND_LFUN(p->inherits[SUBTYPEOF(*x)].prog, LFUN__SPRINTF);
7b45292001-08-15Fredrik Hübinette (Hubbe)  if(fun != -1) { push_int('x'); f_aggregate_mapping(0);
2a8be12004-12-21Henrik Grubbström (Grubba)  apply_low(x->u.object,
017b572011-10-28Henrik Grubbström (Grubba)  fun + p->inherits[SUBTYPEOF(*x)].identifier_level, 2); if(TYPEOF(Pike_sp[-1]) == T_STRING)
7b45292001-08-15Fredrik Hübinette (Hubbe)  { stack_swap(); pop_stack(); return; } Pike_error("Non-string returned from _sprintf()\n"); } }
017b572011-10-28Henrik Grubbström (Grubba)  if(TYPEOF(*x) != T_INT)
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("int2hex", 1, "int");
7b45292001-08-15Fredrik Hübinette (Hubbe)  c=x->u.integer; len=1; if(c<0) { len++;
9c3a7c2003-01-26Mirar (Pontus Hagland)  n=(-c)&((unsigned INT_TYPE)(-1));
7b45292001-08-15Fredrik Hübinette (Hubbe)  }else{ n=c; }
301e982002-01-18Martin Nilsson  while(n>65535) { n>>=16; len+=4; } while(n>15) { n>>=4; len++; }
13670c2015-05-25Martin Nilsson 
7b45292001-08-15Fredrik Hübinette (Hubbe)  s=begin_shared_string(len); if(!c) { s->str[0]='0'; }else{ if(c<0) { s->str[0]='-';
9c3a7c2003-01-26Mirar (Pontus Hagland)  n=(-c)&((unsigned INT_TYPE)(-1));
7b45292001-08-15Fredrik Hübinette (Hubbe)  }else{ n=c; }
301e982002-01-18Martin Nilsson  while(len && n)
7b45292001-08-15Fredrik Hübinette (Hubbe)  { s->str[--len]="0123456789abcdef"[n&0xf]; n>>=4; } } RETURN end_shared_string(s); }
8d251e2003-09-05Martin Nilsson 
b2d3ca2003-08-26Martin Nilsson /*! @decl string string2hex(string data) *! @appears String.string2hex *! *! Convert a string of binary data to a hexadecimal string. *! *! @seealso *! @[hex2string()] */
b2f5ff2011-11-04Per Hedbor  static const char hexchar[] = { '0','1','2','3','4','5','6','7','8','9', 'a','b','c','d','e','f' }; static const unsigned char hexdecode[256] = {
c857302015-12-01Martin Nilsson  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16, 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
b2f5ff2011-11-04Per Hedbor  /* '0' - '9' */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
c857302015-12-01Martin Nilsson  16,16,16,16,16,16,16,
b2f5ff2011-11-04Per Hedbor  /* 'A' - 'F' */ 10, 11, 12, 13, 14, 15,
c857302015-12-01Martin Nilsson  16,16,16,16,16,16,16,16,16,16,16,16,16, 16,16,16,16,16,16,16,16,16,16,16,16,16,
b2f5ff2011-11-04Per Hedbor  /* 'a' - 'f' */ 10, 11, 12, 13, 14, 15,
c857302015-12-01Martin Nilsson  16,16,16,16,16,16,16,16,16, 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16, 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16, 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16, 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16, 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16, 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16, 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16, 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16, 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
b2f5ff2011-11-04Per Hedbor };
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
00a65b2013-12-11Per Hedbor  PIKEFUN string(0..255) string2hex(string s)
b2d3ca2003-08-26Martin Nilsson  optflags OPT_TRY_OPTIMIZE; { struct pike_string *hex;
b2f5ff2011-11-04Per Hedbor  unsigned char *p,*st = (unsigned char *)s->str; int i, l;
b2d3ca2003-08-26Martin Nilsson  if (s->size_shift) Pike_error("Bad argument 1 to string2hex(), expected 8-bit string.\n"); hex = begin_shared_string(2 * s->len);
b2f5ff2011-11-04Per Hedbor  p = (unsigned char *)hex->str; l = s->len;
8d251e2003-09-05Martin Nilsson 
b2f5ff2011-11-04Per Hedbor  for (i=0; i<l; i++) { *p++ = hexchar[*st>>4]; *p++ = hexchar[*st&15]; st++;
8d251e2003-09-05Martin Nilsson  }
b2d3ca2003-08-26Martin Nilsson  RETURN end_shared_string(hex); }
c857302015-12-01Martin Nilsson /*! @decl string(8bit) hex2string(string(8bit) hex)
b2d3ca2003-08-26Martin Nilsson  *! @appears String.hex2string *!
c857302015-12-01Martin Nilsson  *! Convert a string of hexadecimal digits to binary *! data. Non-hexadecimal characters will be ignored when between *! tuples. Eg. "00 00" is ok, but "0 000" isn't.
b2d3ca2003-08-26Martin Nilsson  *! *! @seealso *! @[string2hex()] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
00a65b2013-12-11Per Hedbor PIKEFUN string(0..255) hex2string(string hex)
b2d3ca2003-08-26Martin Nilsson  optflags OPT_TRY_OPTIMIZE; { struct pike_string *s;
b2f5ff2011-11-04Per Hedbor  int tmp, i; unsigned char *p, *q = (unsigned char *)hex->str;
c857302015-12-01Martin Nilsson  int l = i = hex->len; if(hex->size_shift) Pike_error("Wide strings are not allowed.\n");
b2d3ca2003-08-26Martin Nilsson 
c857302015-12-01Martin Nilsson  s = begin_shared_string(l>>1);
b2f5ff2011-11-04Per Hedbor  p = (unsigned char *)s->str;
c857302015-12-01Martin Nilsson  while( l > 1 )
b2d3ca2003-08-26Martin Nilsson  {
b2f5ff2011-11-04Per Hedbor  tmp = hexdecode[*q++];
c857302015-12-01Martin Nilsson  if( tmp==16 ) { l--; i--; continue; } *p = tmp<<4; tmp = hexdecode[*q++]; if( tmp==16 ) Pike_error("Illegal hex format.\n"); *p++ |= tmp; l -= 2;
b2d3ca2003-08-26Martin Nilsson  }
c857302015-12-01Martin Nilsson  if( l && hexdecode[*q]!=16 ) Pike_error("Illegal hex format.\n"); if( hex->len>>1 == i>>1 ) RETURN end_shared_string(s); else RETURN end_and_resize_shared_string(s, i>>1);
b2d3ca2003-08-26Martin Nilsson }
5a3fc02014-04-08Martin Nilsson /*! @decl array(int) range(string s) *! @appears String.range *! *! Returns the character range of a string in an array of two *! elements. The first element contains the lower bound and the *! second the upper. The precision is only 8 bits, so for wide *! strings only character blocks are known. */ PIKEFUN array(int) string_range(string s)
de22f72014-08-25Martin Nilsson  errname range;
5a3fc02014-04-08Martin Nilsson  optflags OPT_TRY_OPTIMIZE; { int min, max; check_string_range(s, 0, &min, &max); pop_n_elems(args); push_int(min); push_int(max); f_aggregate(2); }
0498332001-02-10Henrik Grubbström (Grubba) /*! @decl array column(array data, mixed index) *! *! Extract a column from a two-dimensional array. *! *! This function is exactly equivalent to:
f79bd82003-04-01Martin Nilsson  *! @code *! map(@[data], lambda(mixed x,mixed y) { return x[y]; }, @[index]) *! @endcode
0498332001-02-10Henrik Grubbström (Grubba)  *! *! Except of course it is a lot shorter and faster. *! That is, it indices every index in the array data on the value of *! the argument index and returns an array with the results. *! *! @seealso *! @[rows()] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
b0f8352001-01-07Henrik Grubbström (Grubba) PIKEFUN array column(array data, mixed index)
3a5b1d2000-05-24Fredrik Hübinette (Hubbe)  efun; optflags OPT_TRY_OPTIMIZE; {
bcd8012003-04-28Martin Stjernholm  RETURN array_column (data, index, 1);
3a5b1d2000-05-24Fredrik Hübinette (Hubbe) }
0498332001-02-10Henrik Grubbström (Grubba) /*! @decl multiset mkmultiset(array a) *! *! This function creates a multiset from an array. *! *! @seealso *! @[aggregate_multiset()] *! */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
3a5b1d2000-05-24Fredrik Hübinette (Hubbe) PIKEFUN multiset(1) mkmultiset(array(1=mixed) a) efun;
8f998d2000-08-31Henrik Grubbström (Grubba)  optflags OPT_TRY_OPTIMIZE|OPT_EXTERNAL_DEPEND;
3a5b1d2000-05-24Fredrik Hübinette (Hubbe) { RETURN mkmultiset(a); }
50d97a2003-02-01Martin Stjernholm /*! @decl int trace(int level, void|string facility, void|int all_threads)
0498332001-02-10Henrik Grubbström (Grubba)  *!
50d97a2003-02-01Martin Stjernholm  *! This function changes the trace level for the subsystem identified *! by @[facility] to @[level]. If @[facility] is zero or left out, it *! changes the global trace level which affects all subsystems.
0498332001-02-10Henrik Grubbström (Grubba)  *!
50d97a2003-02-01Martin Stjernholm  *! Enabling tracing causes messages to be printed to stderr. A higher *! trace level includes the output from all lower levels. The lowest *! level is zero which disables all trace messages.
0498332001-02-10Henrik Grubbström (Grubba)  *! *! See the @tt{-t@} command-line option for more information.
6198092003-01-08Martin Stjernholm  *!
50d97a2003-02-01Martin Stjernholm  *! @param level *! If @[facility] is specified then there is typically only one *! trace level for it, i.e. it's an on-or-off toggle. The global *! trace levels, when @[facility] isn't specified, are: *! *! @int
2fe0542003-02-01Martin Stjernholm  *! @value 1
50d97a2003-02-01Martin Stjernholm  *! Trace calls to Pike functions and garbage collector runs.
2fe0542003-02-01Martin Stjernholm  *! @value 2
50d97a2003-02-01Martin Stjernholm  *! Trace calls to builtin functions.
2fe0542003-02-01Martin Stjernholm  *! @value 3
50d97a2003-02-01Martin Stjernholm  *! Trace every interpreted opcode.
2fe0542003-02-01Martin Stjernholm  *! @value 4
50d97a2003-02-01Martin Stjernholm  *! Also trace the opcode arguments. *! @endint *! *! @param facility *! Valid facilities are: *! *! @string
2fe0542003-02-01Martin Stjernholm  *! @value "gc"
e7a6482009-11-20Martin Stjernholm  *! Trace the doings of the garbage collector. The setting is *! never thread local. @[level] has two different meanings: *! @dl *! @item 1..2 *! Trace the start and end of each gc run. *! @item 3.. *! Additionally show info about the collected garbage, to aid *! hunting down garbage problems. This currently shows gc'd *! trampolines. Note that the output can be very bulky and is *! somewhat low-level technical. Also note that pike currently *! has to be configured with @expr{--with-rtldebug@} to enable *! this. *! @enddl
50d97a2003-02-01Martin Stjernholm  *! @endstring
6198092003-01-08Martin Stjernholm  *! *! @param all_threads
50d97a2003-02-01Martin Stjernholm  *! Trace levels are normally thread local, so changes affect only *! the current thread. To change the level in all threads, pass a *! nonzero value in this argument.
6198092003-01-08Martin Stjernholm  *! *! @returns
50d97a2003-02-01Martin Stjernholm  *! The old trace level in the current thread is returned.
0498332001-02-10Henrik Grubbström (Grubba)  */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
c834442008-05-29Martin Stjernholm PIKEFUN int trace(int level, void|string facility, void|zero|int all_threads)
098c802000-05-24Fredrik Hübinette (Hubbe)  efun; optflags OPT_SIDE_EFFECT; {
50d97a2003-02-01Martin Stjernholm  INT32 old_level; if (facility) { struct pike_string *gc_str;
de56ec2003-02-08Martin Stjernholm  MAKE_CONST_STRING(gc_str, "gc");
fe21442004-09-02Henrik Grubbström (Grubba)  if (facility == gc_str) {
50d97a2003-02-01Martin Stjernholm  old_level = gc_trace; gc_trace = level; } else { bad_arg_error("trace", Pike_sp-args, args, 2, "trace facility identifier", Pike_sp-args+1, "Bad argument 2 to trace(). Unknown trace facility."); }
6198092003-01-08Martin Stjernholm  }
50d97a2003-02-01Martin Stjernholm  else { old_level = Pike_interpreter.trace_level; #ifdef PIKE_THREADS
c834442008-05-29Martin Stjernholm  if (!all_threads)
50d97a2003-02-01Martin Stjernholm  Pike_interpreter.trace_level = level; else { struct thread_state *s; FOR_EACH_THREAD(s, s->state.trace_level = level); }
6198092003-01-08Martin Stjernholm #else
50d97a2003-02-01Martin Stjernholm  Pike_interpreter.trace_level = level;
6198092003-01-08Martin Stjernholm #endif
50d97a2003-02-01Martin Stjernholm  } RETURN old_level;
098c802000-05-24Fredrik Hübinette (Hubbe) }
51adb82003-01-12Martin Stjernholm /*! @decl mapping(string:float) gc_parameters (void|mapping(string:mixed) params) *! @belongs Pike *! *! Set and get various parameters that control the operation of the *! garbage collector. The passed mapping contains the parameters to *! set. If a parameter is missing from the mapping, the current value *! will be filled in instead. The same mapping is returned. Thus an *! empty mapping, or no argument at all, causes a mapping with all *! current settings to be returned. *! *! The following parameters are recognized: *! *! @mapping *! @member int "enabled"
0d9f932003-01-14Martin Stjernholm  *! If this is 1 then the gc is enabled as usual. If it's 0 then all *! automatically scheduled gc runs are disabled and the parameters *! below have no effect, but explicit runs through the @[gc] *! function still works as usual. If it's -1 then the gc is *! completely disabled so that even explicit @[gc] calls won't do *! anything.
51adb82003-01-12Martin Stjernholm  *! @member float "garbage_ratio_low"
85f8c72010-06-22Martin Stjernholm  *! As long as the gc time is less than time_ratio below, aim to run
51adb82003-01-12Martin Stjernholm  *! the gc approximately every time the ratio between the garbage *! and the total amount of allocated things is this. *! @member float "time_ratio"
85f8c72010-06-22Martin Stjernholm  *! When more than this fraction of the time is spent in the gc, aim *! for garbage_ratio_high instead of garbage_ratio_low.
51adb82003-01-12Martin Stjernholm  *! @member float "garbage_ratio_high" *! Upper limit for the garbage ratio - run the gc as often as it *! takes to keep it below this.
85f8c72010-06-22Martin Stjernholm  *! @member float "min_gc_time_ratio" *! This puts an upper limit on the gc interval, in addition to the *! factors above. It is specified as the minimum amount of time *! spent doing gc, as a factor of the total time. The reason for *! this limit is that the current amount of garbage can only be *! measured in a gc run, and if the gc starts to run very seldom *! due to very little garbage, it might get too slow to react to an *! increase in garbage generation. Set to 0.0 to turn this limit *! off.
51adb82003-01-12Martin Stjernholm  *! @member float "average_slowness" *! When predicting the next gc interval, use a decaying average *! with this slowness factor. It should be a value between 0.0 and *! 1.0 that specifies the weight to give to the old average value. *! The remaining weight up to 1.0 is given to the last reading.
b6a9792013-06-26Henrik Grubbström (Grubba)  *! @member function(:void) "pre_cb" *! This function is called when the gc starts. *! @member function(:void) "post_cb" *! This function is called when the mark and sweep pass of the gc *! is done.
e0fa982014-01-17Henrik Grubbström (Grubba)  *! @member function(object,int,int:void) "destruct_cb"
b6a9792013-06-26Henrik Grubbström (Grubba)  *! This function is called once for each object that is part of *! a cycle just before the gc will destruct it.
e0fa982014-01-17Henrik Grubbström (Grubba)  *! The arguments are: *! @dl *! @item *! The object to be destructed. *! @item *! The reason for it being destructed. One of: *! @int *! @value Object.DESTRUCT_CLEANUP *! Destructed during exit. *! @value Object.DESTRUCT_GC *! Destructed during normal implicit or explicit @[gc()]. *! @endint *! @item *! The number of references it had. *! @enddl
b6a9792013-06-26Henrik Grubbström (Grubba)  *! @member function(int:void) "done_cb" *! This function is called when the gc is done and about to exit. *! The argument is the same value as will be returned by gc().
51adb82003-01-12Martin Stjernholm  *! @endmapping *! *! @seealso *! @[gc], @[Debug.gc_status] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
51adb82003-01-12Martin Stjernholm PIKEFUN mapping(string:mixed) gc_parameters (void|mapping(string:mixed) params) optflags OPT_SIDE_EFFECT; { struct pike_string *str; struct svalue *set; struct svalue get; if (!params) {
85f8c72010-06-22Martin Stjernholm  push_mapping (allocate_mapping (6));
fe21442004-09-02Henrik Grubbström (Grubba)  params = Pike_sp[-1].u.mapping;
51adb82003-01-12Martin Stjernholm  } #define HANDLE_PARAM(NAME, CHECK_AND_SET, GET) do { \
de56ec2003-02-08Martin Stjernholm  MAKE_CONST_STRING (str, NAME); \
fe21442004-09-02Henrik Grubbström (Grubba)  if ((set = low_mapping_string_lookup (params, str))) { \
51adb82003-01-12Martin Stjernholm  CHECK_AND_SET; \ } \ else { \ GET; \
fe21442004-09-02Henrik Grubbström (Grubba)  mapping_string_insert (params, str, &get); \
51adb82003-01-12Martin Stjernholm  } \ } while (0) #define HANDLE_FLOAT_FACTOR(NAME, VAR) \ HANDLE_PARAM (NAME, { \
017b572011-10-28Henrik Grubbström (Grubba)  if (TYPEOF(*set) != T_FLOAT || \
51adb82003-01-12Martin Stjernholm  set->u.float_number < 0.0 || set->u.float_number > 1.0) \
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR ("gc_parameters", 1, \ "float between 0.0 and 1.0 for " NAME); \
bd67392015-10-14Martin Nilsson  VAR = (double) set->u.float_number; \
51adb82003-01-12Martin Stjernholm  }, { \
bd67392015-10-14Martin Nilsson  SET_SVAL(get, T_FLOAT, 0, float_number, (FLOAT_TYPE) VAR); \
51adb82003-01-12Martin Stjernholm  }); HANDLE_PARAM ("enabled", {
017b572011-10-28Henrik Grubbström (Grubba)  if (TYPEOF(*set) != T_INT || set->u.integer < -1 || set->u.integer > 1)
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR ("gc_parameters", 1, "integer in the range -1..1 for 'enabled'");
0d9f932003-01-14Martin Stjernholm  if (gc_enabled != set->u.integer) {
b7a5c32012-07-06Martin Stjernholm  if (gc_enabled > 0) { /* Disabling automatic gc - save the old alloc_threshold and set it to * the maximum value to avoid getting gc_evaluator_callback added. */ saved_alloc_threshold = alloc_threshold; alloc_threshold = GC_MAX_ALLOC_THRESHOLD;
51adb82003-01-12Martin Stjernholm  }
b7a5c32012-07-06Martin Stjernholm  else if (set->u.integer > 0) { /* Enabling automatic gc - restore the old alloc_threshold. If the * gc interval has gotten longer than it should be then the * multiplier calculation in do_gc should compensate. */ alloc_threshold = saved_alloc_threshold; } gc_enabled = set->u.integer;
51adb82003-01-12Martin Stjernholm  } }, {
017b572011-10-28Henrik Grubbström (Grubba)  SET_SVAL(get, T_INT, NUMBER_NUMBER, integer, gc_enabled);
51adb82003-01-12Martin Stjernholm  }); HANDLE_FLOAT_FACTOR ("garbage_ratio_low", gc_garbage_ratio_low); HANDLE_FLOAT_FACTOR ("time_ratio", gc_time_ratio); HANDLE_FLOAT_FACTOR ("garbage_ratio_high", gc_garbage_ratio_high);
85f8c72010-06-22Martin Stjernholm  HANDLE_FLOAT_FACTOR ("min_gc_time_ratio", gc_min_time_ratio);
51adb82003-01-12Martin Stjernholm  HANDLE_FLOAT_FACTOR ("average_slowness", gc_average_slowness);
b6a9792013-06-26Henrik Grubbström (Grubba)  HANDLE_PARAM("pre_cb", { assign_svalue(&gc_pre_cb, set); }, { assign_svalue(&get, &gc_pre_cb); }); HANDLE_PARAM("post_cb", { assign_svalue(&gc_post_cb, set); }, { assign_svalue(&get, &gc_post_cb); }); HANDLE_PARAM("destruct_cb", { assign_svalue(&gc_destruct_cb, set); }, { assign_svalue(&get, &gc_destruct_cb); }); HANDLE_PARAM("done_cb", { assign_svalue(&gc_done_cb, set); }, { assign_svalue(&get, &gc_done_cb); });
51adb82003-01-12Martin Stjernholm #undef HANDLE_PARAM #undef HANDLE_FLOAT_FACTOR
fe21442004-09-02Henrik Grubbström (Grubba)  REF_RETURN params;
51adb82003-01-12Martin Stjernholm }
d6fd962001-02-10Henrik Grubbström (Grubba) /*! @decl string ctime(int timestamp) *!
0498332001-02-10Henrik Grubbström (Grubba)  *! Convert the output from a previous call to @[time()] into a readable *! string containing the current year, month, day and time. *!
f917a32002-10-03Martin Stjernholm  *! Like @[localtime], this function might throw an error if the *! ctime(2) call failed on the system. It's platform dependent what *! time ranges that function can handle, e.g. Windows doesn't handle *! a negative @[timestamp].
21f3f62002-10-03Martin Stjernholm  *!
0498332001-02-10Henrik Grubbström (Grubba)  *! @seealso *! @[time()], @[localtime()], @[mktime()], @[gmtime()] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
14f6892008-04-22Martin Stjernholm PIKEFUN string ctime(longest timestamp)
098c802000-05-24Fredrik Hübinette (Hubbe)  efun; optflags OPT_TRY_OPTIMIZE; {
14f6892008-04-22Martin Stjernholm  time_t i; char *s; #if SIZEOF_TIME_T < SIZEOF_LONGEST
ad8ee62008-04-23Martin Nilsson  if (timestamp > MAX_TIME_T || timestamp < MIN_TIME_T)
7712092008-04-23Martin Stjernholm  SIMPLE_ARG_ERROR ("ctime", 1, "Timestamp outside valid range.");
14f6892008-04-22Martin Stjernholm #endif i = (time_t) timestamp; s = ctime (&i);
f917a32002-10-03Martin Stjernholm  if (!s) Pike_error ("ctime() on this system cannot handle " "the timestamp %ld.\n", (long) i);
21f3f62002-10-03Martin Stjernholm  RETURN make_shared_string(s);
098c802000-05-24Fredrik Hübinette (Hubbe) }
0498332001-02-10Henrik Grubbström (Grubba) /*! @decl mapping mkmapping(array ind, array val) *! *! Make a mapping from two arrays. *! *! Makes a mapping @[ind[x]]:@[val[x]], @tt{0 <= x < sizeof(ind)@}. *! *! @[ind] and @[val] must have the same size. *! *! This is the inverse operation of @[indices()] and @[values()]. *! *! @seealso *! @[indices()], @[values()] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
b0f8352001-01-07Henrik Grubbström (Grubba) PIKEFUN mapping(1:2) mkmapping(array(1=mixed) ind, array(2=mixed) val)
098c802000-05-24Fredrik Hübinette (Hubbe)  efun;
8f998d2000-08-31Henrik Grubbström (Grubba)  optflags OPT_TRY_OPTIMIZE|OPT_EXTERNAL_DEPEND;
098c802000-05-24Fredrik Hübinette (Hubbe) {
b0f8352001-01-07Henrik Grubbström (Grubba)  if(ind->size != val->size)
cbaa3a2002-05-24Henrik Grubbström (Grubba)  bad_arg_error("mkmapping", Pike_sp-args, args, 2, "array", Pike_sp+1-args,
098c802000-05-24Fredrik Hübinette (Hubbe)  "mkmapping called on arrays of different sizes (%d != %d)\n",
b0f8352001-01-07Henrik Grubbström (Grubba)  ind->size, val->size);
098c802000-05-24Fredrik Hübinette (Hubbe) 
b0f8352001-01-07Henrik Grubbström (Grubba)  RETURN mkmapping(ind, val);
098c802000-05-24Fredrik Hübinette (Hubbe) }
3a5b1d2000-05-24Fredrik Hübinette (Hubbe) 
3ee7482014-07-27Henrik Grubbström (Grubba) /*! @decl string secure(string str)
aff1972008-06-29Martin Nilsson  *! @belongs String *! *! Marks the string as secure, which will clear the memory area *! before freeing the string.
4b99202014-07-29Henrik Grubbström (Grubba)  *! *! @seealso *! @[Object.secure()]
aff1972008-06-29Martin Nilsson  */
56e48a2008-06-30Henrik Grubbström (Grubba) PIKEFUN string string_secure(string str) optflags OPT_SIDE_EFFECT; rawtype tFunc(tSetvar(0, tStr), tVar(0));
aff1972008-06-29Martin Nilsson { str->flags |= STRING_CLEAR_ON_EXIT;
8d9a1b2008-06-30Henrik Grubbström (Grubba)  REF_RETURN str;
aff1972008-06-29Martin Nilsson }
3ee7482014-07-27Henrik Grubbström (Grubba) /*! @decl object secure(object str) *! @belongs Object *! *! Marks the object as secure, which will clear the memory area *! before freeing the object.
4b99202014-07-29Henrik Grubbström (Grubba)  *! *! @seealso *! @[String.secure()]
3ee7482014-07-27Henrik Grubbström (Grubba)  */ PIKEFUN object object_secure(object obj) optflags OPT_SIDE_EFFECT; rawtype tFunc(tSetvar(0, tObj), tVar(0)); { obj->flags |= OBJECT_CLEAR_ON_EXIT; REF_RETURN obj; }
31acb72001-07-26Martin Nilsson /*! @decl int count(string haystack, string needle) *! @belongs String
0498332001-02-10Henrik Grubbström (Grubba)  *!
c5e2a42004-04-30Martin Nilsson  *! Count the number of non-overlapping times the string @[needle] *! occurs in the string @[haystack]. The special cases for the needle *! @expr{""@} is that it occurs one time in the empty string, zero *! times in a one character string and between every character *! (length-1) in any other string.
0498332001-02-10Henrik Grubbström (Grubba)  *! *! @seealso *! @[search()], @[`/()] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
6613052000-08-10Henrik Grubbström (Grubba) PIKEFUN int string_count(string haystack, string needle)
de22f72014-08-25Martin Nilsson  errname count;
991fdf2000-05-25Fredrik Hübinette (Hubbe)  optflags OPT_TRY_OPTIMIZE; {
89fc4c2000-08-10Henrik Grubbström (Grubba)  ptrdiff_t c = 0; ptrdiff_t i, j;
991fdf2000-05-25Fredrik Hübinette (Hubbe)  switch (needle->len) { case 0: switch (haystack->len) { case 0: c=1; break; /* "" appears one time in "" */ case 1: c=0; break; /* "" doesn't appear in "x" */ default: c=haystack->len-1; /* one time between each character */ } break; case 1: /* maybe optimize? */
c5e2a42004-04-30Martin Nilsson  /* It is already fairly optimized in pike_search_engine. */
991fdf2000-05-25Fredrik Hübinette (Hubbe)  default: for (i=0; i<haystack->len; i++) { j=string_search(haystack,needle,i); if (j==-1) break; i=j+needle->len-1; c++; } break; }
bd67392015-10-14Martin Nilsson  RETURN (INT_TYPE)c;
991fdf2000-05-25Fredrik Hübinette (Hubbe) }
31acb72001-07-26Martin Nilsson /*! @decl string trim_whites (string s) *! @belongs String
5117f12001-04-16Martin Stjernholm  *! *! Trim leading and trailing spaces and tabs from the string @[s]. */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
5117f12001-04-16Martin Stjernholm PIKEFUN string string_trim_whites (string s)
de22f72014-08-25Martin Nilsson  errname trim_whites;
5117f12001-04-16Martin Stjernholm  optflags OPT_TRY_OPTIMIZE; { ptrdiff_t start = 0, end = s->len; int chr; switch (s->size_shift) { #define DO_IT(TYPE) \ { \ for (; start < s->len; start++) { \ chr = ((TYPE *) s->str)[start]; \ if (chr != ' ' && chr != '\t') break; \ } \ while (--end > start) { \ chr = ((TYPE *) s->str)[end]; \ if (chr != ' ' && chr != '\t') break; \ } \ } case 0: DO_IT (p_wchar0); break; case 1: DO_IT (p_wchar1); break; case 2: DO_IT (p_wchar2); break; #undef DO_IT } RETURN string_slice (s, start, end + 1 - start); }
dfae9d2010-01-02Stephen R. van den Berg /*! @decl string normalize_space (string s, string|void whitespace) *! @belongs String *!
8152502010-01-02Stephen R. van den Berg  *! @param s *! Is returned after white space in it has been normalised.
dfae9d2010-01-02Stephen R. van den Berg  *! White space is normalised by stripping leading and trailing white space *! and replacing sequences of white space characters with a single space. *!
8152502010-01-02Stephen R. van den Berg  *! @param whitespace *! Defines what is considered to be white space eligible for normalisation.
fa5fcc2010-01-08Stephen R. van den Berg  *! It has a default value that starts with @expr{" \t\r\n\v\f"@} and in *! addition to that contains all whitespace characters part of Unicode.
9a979e2010-01-09Stephen R. van den Berg  *! The first character denotes the character for replacing whitespace *! sequences.
8152502010-01-02Stephen R. van den Berg  *! *! @note *! Trailing and leading whitespace around \r and \n characters *! is stripped as well (only useful if they're not in the @[whitespace] set).
9a979e2010-01-09Stephen R. van den Berg  *! *! @note *! This function is a lot faster with just one argument (i.e. the builtin *! whitespace set has an optimised code path).
dfae9d2010-01-02Stephen R. van den Berg  */ PMOD_EXPORT PIKEFUN string string_normalize_space (string s, string|void whitespace)
de22f72014-08-25Martin Nilsson  errname normalize_space;
dfae9d2010-01-02Stephen R. van den Berg  optflags OPT_TRY_OPTIMIZE;
fa5fcc2010-01-08Stephen R. van den Berg { size_t len = s->len, wlen; const void *src = s->str; unsigned shift = s->size_shift, replspace; const void *ws; void *wstemp = 0;
dfae9d2010-01-02Stephen R. van den Berg  struct string_builder sb; unsigned foundspace = 0;
f39c292010-01-11Stephen R. van den Berg  wlen = replspace = 0; /* useless, but suppresses silly compiler warning */
fa5fcc2010-01-08Stephen R. van den Berg  { unsigned bshift = shift, wshift; if(whitespace) if(!(wlen = whitespace->len)) REF_RETURN s; else { ws = whitespace->str; wshift = whitespace->size_shift; replspace = index_shared_string(whitespace, 0); if(replspace > 0xffff) bshift = 2; else if(replspace > 0xff && !bshift) bshift = 1;
22c7d82010-01-08Stephen R. van den Berg  if(wshift!=shift) { /* convert whitespace to shift of input */
fa5fcc2010-01-08Stephen R. van den Berg  PCHARP pcnws;
22c7d82010-01-08Stephen R. van den Berg  wstemp = xalloc(wlen<<shift); pcnws = MKPCHARP(wstemp, shift); if(wshift>shift) {
4ce3db2010-01-11Jonas Wallden  PCHARP pcows = MKPCHARP_STR(whitespace);
fa5fcc2010-01-08Stephen R. van den Berg  size_t clen = wlen, i; i = wlen = 0; do { unsigned chr = INDEX_PCHARP(pcows, i++);
f39c292010-01-11Stephen R. van den Berg  if (chr<=0xff || (chr<=0xffff && shift)) /* shift is 0 or 1 */
fa5fcc2010-01-08Stephen R. van den Berg  SET_INDEX_PCHARP(pcnws, wlen++, chr); } while(--clen); } else pike_string_cpy(pcnws, whitespace); ws = wstemp; } }
dfae9d2010-01-02Stephen R. van den Berg  else
fa5fcc2010-01-08Stephen R. van den Berg  ws = 0; init_string_builder_alloc (&sb, len, bshift); if(bshift == shift) sb.known_shift = bshift; }
6528232010-01-09Stephen R. van den Berg 
dfae9d2010-01-02Stephen R. van den Berg  switch (shift) {
fa5fcc2010-01-08Stephen R. van den Berg #define NORMALISE_TIGHT_LOOP(TYPE,CASE) \ { \ const TYPE *start = src, *end = start+len; \
d6206f2010-01-02Stephen R. van den Berg  if (!ws) { \
fa5fcc2010-01-08Stephen R. van den Berg  TYPE *dst = (void*)sb.s->str; \
d6206f2010-01-02Stephen R. van den Berg  for (; start < end; start++) { \
7950ba2010-01-02Stephen R. van den Berg  switch(*start) { \
6528232010-01-09Stephen R. van den Berg  CASE \
7950ba2010-01-02Stephen R. van den Berg  continue; \ } \ break; \
dfae9d2010-01-02Stephen R. van den Berg  } \
d6206f2010-01-02Stephen R. van den Berg  for (; start < end; start++) { \
fa5fcc2010-01-08Stephen R. van den Berg  if(*start<=' ' || *start>=0x85) /* optimise common case */ \ switch(*start) { \
6528232010-01-09Stephen R. van den Berg  CASE \
5f84e02010-01-09Stephen R. van den Berg  if (!foundspace) \ *dst++ = ' ', foundspace=1; \
7950ba2010-01-02Stephen R. van den Berg  continue; \
fa5fcc2010-01-08Stephen R. van den Berg  default:goto found##TYPE; \ } \ else \ found##TYPE: \ foundspace=0; \ *dst++ = *start; \
d6206f2010-01-02Stephen R. van den Berg  } \
fa5fcc2010-01-08Stephen R. van den Berg  sb.s->len = dst - (TYPE*)sb.s->str; \
d6206f2010-01-02Stephen R. van den Berg  } else { \
fa5fcc2010-01-08Stephen R. van den Berg  const TYPE*ps = (const TYPE*)ws+wlen; \
d6206f2010-01-02Stephen R. van den Berg  for (; start < end; start++) { \
fa5fcc2010-01-08Stephen R. van den Berg  size_t clen = wlen; \
d6206f2010-01-02Stephen R. van den Berg  do { \
f39c292010-01-11Stephen R. van den Berg  if (ps[0-clen] == *start) \
d6206f2010-01-02Stephen R. van den Berg  goto lead##TYPE; \
fa5fcc2010-01-08Stephen R. van den Berg  } while(--clen); \
d6206f2010-01-02Stephen R. van den Berg  break; \ lead##TYPE:; \ } \ for (; start < end; start++) { \
5f84e02010-01-09Stephen R. van den Berg  TYPE chr = *start; \
fa5fcc2010-01-08Stephen R. van den Berg  size_t clen = wlen; \
7950ba2010-01-02Stephen R. van den Berg  do \
f39c292010-01-11Stephen R. van den Berg  if (ps[0-clen] == chr) { \
5f84e02010-01-09Stephen R. van den Berg  if (!foundspace) \ string_builder_putchar(&sb, replspace), foundspace=1; \ goto skip##TYPE; \
7950ba2010-01-02Stephen R. van den Berg  } \
fa5fcc2010-01-08Stephen R. van den Berg  while(--clen); \
dfae9d2010-01-02Stephen R. van den Berg  if (foundspace && (chr=='\n' || chr=='\r')) { \
fa5fcc2010-01-08Stephen R. van den Berg  sb.s->len--; string_builder_putchar(&sb, chr); \ foundspace=0; \
dfae9d2010-01-02Stephen R. van den Berg  goto lead##TYPE; \ } \
5f84e02010-01-09Stephen R. van den Berg  string_builder_putchar(&sb, chr); foundspace=0; \
dfae9d2010-01-02Stephen R. van den Berg skip##TYPE:; \
d6206f2010-01-02Stephen R. van den Berg  } \
dfae9d2010-01-02Stephen R. van den Berg  } \ }
fa5fcc2010-01-08Stephen R. van den Berg  case 0: NORMALISE_TIGHT_LOOP (p_wchar0,SPACECASE8); break; case 1: NORMALISE_TIGHT_LOOP (p_wchar1,SPACECASE16); break; case 2: NORMALISE_TIGHT_LOOP (p_wchar2,SPACECASE16); break; #undef NORMALISE_TIGHT_LOOP
dfae9d2010-01-02Stephen R. van den Berg  }
fa5fcc2010-01-08Stephen R. van den Berg  if (wstemp) free(wstemp);
dfae9d2010-01-02Stephen R. van den Berg  if (foundspace)
fa5fcc2010-01-08Stephen R. van den Berg  sb.s->len--;
dfae9d2010-01-02Stephen R. van den Berg  RETURN finish_string_builder (&sb); }
31acb72001-07-26Martin Nilsson /*! @decl string trim_all_whites (string s) *! @belongs String
5117f12001-04-16Martin Stjernholm  *! *! Trim leading and trailing white spaces characters (space, tab,
4d32882010-03-02Martin Nilsson  *! newline, carriage return, form feed, vertical tab and all the *! white spaces defined in Unicode) from the string @[s].
5117f12001-04-16Martin Stjernholm  */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
5117f12001-04-16Martin Stjernholm PIKEFUN string string_trim_all_whites (string s)
de22f72014-08-25Martin Nilsson  errname trim_all_whites;
5117f12001-04-16Martin Stjernholm  optflags OPT_TRY_OPTIMIZE; { ptrdiff_t start = 0, end = s->len; int chr; switch (s->size_shift) {
4d32882010-03-02Martin Nilsson  #define DO_IT(TYPE,CASE) \
5117f12001-04-16Martin Stjernholm  { \
4d32882010-03-02Martin Nilsson  for (; start < end; start++) { \
5117f12001-04-16Martin Stjernholm  chr = ((TYPE *) s->str)[start]; \
4d32882010-03-02Martin Nilsson  switch(chr) { \ CASE \ continue; \ } \ break; \
5117f12001-04-16Martin Stjernholm  } \ while (--end > start) { \ chr = ((TYPE *) s->str)[end]; \
4d32882010-03-02Martin Nilsson  switch(chr) { \ CASE \ continue; \ } \ break; \
5117f12001-04-16Martin Stjernholm  } \ }
4d32882010-03-02Martin Nilsson  case 0: DO_IT (p_wchar0,SPACECASE8); break; case 1: DO_IT (p_wchar1,SPACECASE16); break; case 2: DO_IT (p_wchar2,SPACECASE16); break;
5117f12001-04-16Martin Stjernholm #undef DO_IT } RETURN string_slice (s, start, end + 1 - start); }
126fa42013-04-03Henrik Grubbström (Grubba) /*! @decl string status(int verbose)
af80262013-02-07Henrik Grubbström (Grubba)  *! @belongs String *! *! Get string table statistics. *! *! @returns *! Returns a string with an ASCII table containing *! the current string table statistics. *! *! @note *! Currently returns the empty string (@expr{""@}) *! if @[verbose] is zero. *! *! @note *! The formatting and contents of the result *! may vary between different versions of Pike. */ PIKEFUN string string_status(int verbose)
de22f72014-08-25Martin Nilsson  errname status;
af80262013-02-07Henrik Grubbström (Grubba) { RETURN add_string_status(verbose); }
31acb72001-07-26Martin Nilsson /*! @decl int implements(program prog, program api) *! @belongs Program
0498332001-02-10Henrik Grubbström (Grubba)  *! *! Returns 1 if @[prog] implements @[api]. */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
b0f8352001-01-07Henrik Grubbström (Grubba) PIKEFUN int program_implements(program prog, program api)
de22f72014-08-25Martin Nilsson  errname implements;
991fdf2000-05-25Fredrik Hübinette (Hubbe)  optflags OPT_TRY_OPTIMIZE; {
b0f8352001-01-07Henrik Grubbström (Grubba)  RETURN implements(prog, api);
991fdf2000-05-25Fredrik Hübinette (Hubbe) }
a9d8c32012-10-28Tobias S. Josefowitz /*! @decl int inherits(program|object child, program parent)
31acb72001-07-26Martin Nilsson  *! @belongs Program
0498332001-02-10Henrik Grubbström (Grubba)  *! *! Returns 1 if @[child] has inherited @[parent]. */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
a9d8c32012-10-28Tobias S. Josefowitz PIKEFUN int program_inherits(program|object child, program parent)
de22f72014-08-25Martin Nilsson  errname inherits;
991fdf2000-05-25Fredrik Hübinette (Hubbe)  optflags OPT_TRY_OPTIMIZE; {
c1d4842012-10-28Tobias S. Josefowitz  struct program *p = program_from_svalue(child);
a9d8c32012-10-28Tobias S. Josefowitz 
c1d4842012-10-28Tobias S. Josefowitz  if (!p)
de22f72014-08-25Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("inherits", 1, "program|object");
c1d4842012-10-28Tobias S. Josefowitz  RETURN low_get_storage(p, parent) != -1;
991fdf2000-05-25Fredrik Hübinette (Hubbe) }
31acb72001-07-26Martin Nilsson /*! @decl string defined(program p) *! @belongs Program
0498332001-02-10Henrik Grubbström (Grubba)  *! *! Returns a string with filename and linenumber describing where *! the program @[p] was defined. *!
cbe8c92003-04-07Martin Nilsson  *! The returned string is of the format @expr{"filename:linenumber"@}.
0498332001-02-10Henrik Grubbström (Grubba)  *!
cbe8c92003-04-07Martin Nilsson  *! If it cannot be determined where the program was defined, @expr{0@} *! (zero) will be returned.
0498332001-02-10Henrik Grubbström (Grubba)  */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
b8c5b22000-05-25Fredrik Hübinette (Hubbe) PIKEFUN string program_defined(program p)
de22f72014-08-25Martin Nilsson  errname defined;
b8c5b22000-05-25Fredrik Hübinette (Hubbe)  optflags OPT_TRY_OPTIMIZE; {
ef24a82012-01-12Henrik Grubbström (Grubba)  INT_TYPE line;
9de5ff2002-12-01Martin Stjernholm  struct pike_string *tmp = low_get_program_line(p, &line);
b8c5b22000-05-25Fredrik Hübinette (Hubbe) 
9de5ff2002-12-01Martin Stjernholm  pop_n_elems(args);
50edc82001-07-13Henrik Grubbström (Grubba) 
9de5ff2002-12-01Martin Stjernholm  if (tmp) {
50edc82001-07-13Henrik Grubbström (Grubba)  push_string(tmp); if(line >= 1) {
75367d2014-08-22Arne Goedeke  push_static_text(":");
50edc82001-07-13Henrik Grubbström (Grubba)  push_int(line); f_add(3);
b8c5b22000-05-25Fredrik Hübinette (Hubbe)  } }
9de5ff2002-12-01Martin Stjernholm  else push_int(0);
b8c5b22000-05-25Fredrik Hübinette (Hubbe) }
31acb72001-07-26Martin Nilsson /*! @decl int(8..8)|int(16..16)|int(32..32) width(string s) *! @belongs String
0498332001-02-10Henrik Grubbström (Grubba)  *! *! Returns the width of a string. *!
4448f42013-04-04Henrik Grubbström (Grubba)  *! @returns *! Three return values are currently possible: *! @int *! @value 8 *! The string @[s] only contains characters <= 255. *! @value 16 *! The string @[s] only contains characters <= 65535. *! @value 32 *! The string @[s] contains characters >= 65536. *! @endint *! *! @note *! It is possible that a future version of Pike may return *! further values. In particular the width @expr{7@} seems *! like it could be useful.
0498332001-02-10Henrik Grubbström (Grubba)  */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
d6fd962001-02-10Henrik Grubbström (Grubba) PIKEFUN int(8 .. 8)|int(16 .. 16)|int(32 .. 32) string_width(string s)
de22f72014-08-25Martin Nilsson  errname width;
991fdf2000-05-25Fredrik Hübinette (Hubbe)  optflags OPT_TRY_OPTIMIZE; { RETURN 8 * (1 << s->size_shift); }
0498332001-02-10Henrik Grubbström (Grubba) /*! @decl mixed m_delete(object|mapping map, mixed index) *! *! If @[map] is an object that implements @[lfun::_m_delete()],
dd5cba2003-02-10Marek Habersack  *! that function will be called with @[index] as its single argument.
0498332001-02-10Henrik Grubbström (Grubba)  *!
dd5cba2003-02-10Marek Habersack  *! Otherwise if @[map] is a mapping the entry with index @[index]
0498332001-02-10Henrik Grubbström (Grubba)  *! will be removed from @[map] destructively. *! *! If the mapping does not have an entry with index @[index], nothing is done. *! *! @returns
52ced62003-02-11Henrik Grubbström (Grubba)  *! The value that was removed will be returned.
0498332001-02-10Henrik Grubbström (Grubba)  *! *! @note *! Note that @[m_delete()] changes @[map] destructively. *! *! @seealso *! @[mappingp()] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
a3453e2001-02-05Per Hedbor PIKEFUN mixed m_delete(object|mapping map, mixed index)
7f80d42000-06-19Fredrik Hübinette (Hubbe)  efun; optflags OPT_SIDE_EFFECT;
d8a04b2005-11-14Martin Nilsson  rawtype tOr(tFunc(tMap(tSetvar(0,tMix),tSetvar(1,tMix)) tVar(0),tVar(1)),tFunc(tObj tMix,tMix))
7f80d42000-06-19Fredrik Hübinette (Hubbe) {
2a8be12004-12-21Henrik Grubbström (Grubba)  struct program *p;
017b572011-10-28Henrik Grubbström (Grubba)  if( TYPEOF(*map) == T_MAPPING )
a3453e2001-02-05Per Hedbor  { struct svalue s; map_delete_no_free(map->u.mapping, index, &s); pop_n_elems(args);
cbaa3a2002-05-24Henrik Grubbström (Grubba)  *Pike_sp=s; Pike_sp++;
cdf18a2003-03-14Henrik Grubbström (Grubba)  dmalloc_touch_svalue(Pike_sp-1);
a3453e2001-02-05Per Hedbor  }
017b572011-10-28Henrik Grubbström (Grubba)  else if (TYPEOF(*map) == T_OBJECT && (p = map->u.object->prog))
a3453e2001-02-05Per Hedbor  {
017b572011-10-28Henrik Grubbström (Grubba)  int id = FIND_LFUN(p->inherits[SUBTYPEOF(*map)].prog, LFUN__M_DELETE);
ea56012001-02-09Per Hedbor  if( id == -1 )
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("m_delete", 1, "object containing the _m_delete method");
13670c2015-05-25Martin Nilsson 
2a8be12004-12-21Henrik Grubbström (Grubba)  apply_low(map->u.object,
017b572011-10-28Henrik Grubbström (Grubba)  id + p->inherits[SUBTYPEOF(*map)].identifier_level, 1);
a3453e2001-02-05Per Hedbor  stack_swap(); pop_stack();
79f6982001-02-05Henrik Grubbström (Grubba)  } else {
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("m_delete", 1, "object|mapping");
a3453e2001-02-05Per Hedbor  }
7f80d42000-06-19Fredrik Hübinette (Hubbe) }
9da7f42001-06-05Martin Stjernholm /*! @decl int get_weak_flag(array|mapping|multiset m)
0498332001-02-10Henrik Grubbström (Grubba)  *!
9da7f42001-06-05Martin Stjernholm  *! Returns the weak flag settings for @[m]. It's a combination of *! @[Pike.WEAK_INDICES] and @[Pike.WEAK_VALUES].
0498332001-02-10Henrik Grubbström (Grubba)  */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
e1b4192001-06-06Fredrik Hübinette (Hubbe) PIKEFUN int get_weak_flag(array m)
ee9fa92000-07-06Martin Stjernholm  efun;
8f998d2000-08-31Henrik Grubbström (Grubba)  optflags OPT_EXTERNAL_DEPEND;
ee9fa92000-07-06Martin Stjernholm {
e1b4192001-06-06Fredrik Hübinette (Hubbe)  RETURN (m->flags & ARRAY_WEAK_FLAG) ? PIKE_WEAK_VALUES : 0; }
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
e1b4192001-06-06Fredrik Hübinette (Hubbe) PIKEFUN int get_weak_flag(mapping m) { RETURN mapping_get_flags(m) & MAPPING_WEAK; }
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
e1b4192001-06-06Fredrik Hübinette (Hubbe) PIKEFUN int get_weak_flag(multiset m) {
5b15bb2001-12-10Martin Stjernholm  RETURN multiset_get_flags(m) & MULTISET_WEAK;
ee9fa92000-07-06Martin Stjernholm }
18c2252003-04-10Martin Nilsson /*! @decl program __empty_program(int|void line, string|void file) */
c834442008-05-29Martin Stjernholm PIKEFUN program __empty_program(int|zero|void line, string|void file)
aa68b12001-03-19Fredrik Hübinette (Hubbe)  efun; optflags OPT_EXTERNAL_DEPEND; {
c834442008-05-29Martin Stjernholm  struct program *prog = low_allocate_program(); if (file) ext_store_program_line (prog, line, file); RETURN prog;
aa68b12001-03-19Fredrik Hübinette (Hubbe) }
99f32f2009-02-21Henrik Grubbström (Grubba) /* Cut the string at the first NUL. */ static struct pike_string *delambda(struct pike_string *str) { PCHARP pcharp = MKPCHARP_STR(str); ptrdiff_t len = pcharp_strlen(pcharp); if (len == str->len) { /* Common case. */ add_ref(str); return str; } return make_shared_binary_pcharp(pcharp, len); }
b82bbf2013-07-13Chris Angelico /*! @decl string function_name(function|program f)
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  *!
b82bbf2013-07-13Chris Angelico  *! Return the name of the function or program @[f].
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  *!
cbe8c92003-04-07Martin Nilsson  *! If @[f] is a global function defined in the runtime @expr{0@} *! (zero) will be returned.
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  *! *! @seealso *! @[function_object()] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
1c1c5e2001-04-08Fredrik Hübinette (Hubbe) PIKEFUN string function_name(program|function func) efun; optflags OPT_TRY_OPTIMIZE; {
42d5b32012-01-09Henrik Grubbström (Grubba)  int f = -1; struct program *p = NULL;
017b572011-10-28Henrik Grubbström (Grubba)  switch(TYPEOF(*func))
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  { default:
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("function_name", 1, "function|program");
9282fd2015-09-27Martin Nilsson  UNREACHABLE(return);
13670c2015-05-25Martin Nilsson 
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  case PIKE_T_PROGRAM: {
42d5b32012-01-09Henrik Grubbström (Grubba)  p = func->u.program;
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  if(p->parent) { int e; p=p->parent; /* search constants in parent for this * program... */
13670c2015-05-25Martin Nilsson 
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  for(e = p->num_identifier_references; e--; ) { struct identifier *id; if (p->identifier_references[e].id_flags & ID_HIDDEN) continue; id = ID_FROM_INT(p, e); if (IDENTIFIER_IS_CONSTANT(id->identifier_flags) &&
89378b2010-11-23Henrik Grubbström (Grubba)  (id->func.const_info.offset >= 0) && is_eq( & PROG_FROM_INT(p, e)->constants[id->func.const_info.offset].sval,
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  func)) REF_RETURN id->name; }
52ced62003-02-11Henrik Grubbström (Grubba) #ifdef PIKE_DEBUG if (d_flag>5) { fprintf(stderr,
2523ce2003-04-28Martin Stjernholm  "Failed to find symbol for program %p\n"
52ced62003-02-11Henrik Grubbström (Grubba)  "Parent program info:\n", func->u.program); dump_program_tables(func->u.program->parent, 0); } #endif
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  } break; } case PIKE_T_FUNCTION:
42d5b32012-01-09Henrik Grubbström (Grubba)  if((f = SUBTYPEOF(*func)) == FUNCTION_BUILTIN) break; if(!(p = func->u.object->prog))
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  bad_arg_error("function_name", Pike_sp-args, args, 1, "function", Pike_sp-args, "Destructed object.\n");
42d5b32012-01-09Henrik Grubbström (Grubba)  if(p == pike_trampoline_program)
5a6d7d2001-04-10Fredrik Hübinette (Hubbe)  { struct pike_trampoline *t; t=((struct pike_trampoline *)func->u.object->storage);
c1f4762008-11-02Henrik Grubbström (Grubba) 
42d5b32012-01-09Henrik Grubbström (Grubba)  if(t->frame->current_object->prog) { p = t->frame->current_object->prog; f = t->func; }
5a6d7d2001-04-10Fredrik Hübinette (Hubbe)  }
c1f4762008-11-02Henrik Grubbström (Grubba) 
42d5b32012-01-09Henrik Grubbström (Grubba) #ifdef PIKE_DEBUG if(f >= p->num_identifier_references) Pike_fatal("Function without reference.\n"); #endif RETURN delambda(ID_FROM_INT(p, f)->name);
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  } pop_n_elems(args); push_int(0); }
6410612003-01-08Henrik Grubbström (Grubba) /*! @decl object function_object(function f)
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  *!
6410612003-01-08Henrik Grubbström (Grubba)  *! Return the object the function @[f] is in.
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  *!
cbe8c92003-04-07Martin Nilsson  *! If @[f] is a global function defined in the runtime @expr{0@} *! (zero) will be returned.
6410612003-01-08Henrik Grubbström (Grubba)  *! *! Zero will also be returned if @[f] is a constant in the *! parent class. In that case @[function_program()] can be *! used to get the parent program.
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  *! *! @seealso
6410612003-01-08Henrik Grubbström (Grubba)  *! @[function_name()], @[function_program()]
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
51adb82003-01-12Martin Stjernholm PIKEFUN object function_object(function|program func)
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  efun; optflags OPT_TRY_OPTIMIZE;
6410612003-01-08Henrik Grubbström (Grubba)  type function(function:object);
1c1c5e2001-04-08Fredrik Hübinette (Hubbe) {
017b572011-10-28Henrik Grubbström (Grubba)  switch(TYPEOF(*func))
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  { case PIKE_T_PROGRAM:
6410612003-01-08Henrik Grubbström (Grubba)  break;
13670c2015-05-25Martin Nilsson 
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  case PIKE_T_FUNCTION:
017b572011-10-28Henrik Grubbström (Grubba)  if(SUBTYPEOF(*func) == FUNCTION_BUILTIN) break;
5a6d7d2001-04-10Fredrik Hübinette (Hubbe)  if(func->u.object->prog == pike_trampoline_program) { struct object *o; o=((struct pike_trampoline *)func->u.object->storage)->frame->current_object; add_ref(o); pop_n_elems(args); push_object(o); return; }
017b572011-10-28Henrik Grubbström (Grubba)  SET_SVAL(*func, T_OBJECT, 0, object, func->u.object);
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  return;
5a6d7d2001-04-10Fredrik Hübinette (Hubbe)  default:
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("function_object",1,"function");
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  } pop_n_elems(args); push_int(0); }
6410612003-01-08Henrik Grubbström (Grubba) /*! @decl program function_program(function|program f) *! *! Return the program the function @[f] is in. *!
cbe8c92003-04-07Martin Nilsson  *! If @[f] is a global function defined in the runtime @expr{0@} *! (zero) will be returned.
6410612003-01-08Henrik Grubbström (Grubba)  *! *! @seealso *! @[function_name()], @[function_object()] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
6410612003-01-08Henrik Grubbström (Grubba) PIKEFUN program function_program(program|function func) efun; optflags OPT_TRY_OPTIMIZE; {
017b572011-10-28Henrik Grubbström (Grubba)  switch(TYPEOF(*func))
6410612003-01-08Henrik Grubbström (Grubba)  { case PIKE_T_PROGRAM: { struct program *p; if(!(p=func->u.program->parent)) break; add_ref(p); free_program(func->u.program); func->u.program=p; return; }
13670c2015-05-25Martin Nilsson 
6410612003-01-08Henrik Grubbström (Grubba)  case PIKE_T_FUNCTION: { struct program *p;
017b572011-10-28Henrik Grubbström (Grubba)  if(SUBTYPEOF(*func) == FUNCTION_BUILTIN)
48a6242003-05-31Martin Stjernholm  p = func->u.efun->prog; else p = func->u.object->prog;
6410612003-01-08Henrik Grubbström (Grubba)  if(p == pike_trampoline_program) { p = ((struct pike_trampoline *)func->u.object->storage)-> frame->current_object->prog; } if (p) { ref_push_program(p); stack_pop_n_elems_keep_top(args); return; } } break; default:
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("function_program", 1, "function");
6410612003-01-08Henrik Grubbström (Grubba)  } pop_n_elems(args); push_int(0); }
1f12012016-01-13Martin Nilsson PIKECLASS RandomInterface { CVAR INT64 int_buffer; CVAR int buffer_bits; INIT { THIS->int_buffer = 0; THIS->buffer_bits = 0; } PIKEFUN string(8bit) random_string(int(0..)) prototype; {} static void fill_int_buffer() { push_int(8); apply_current(f_RandomInterface_random_string_fun_num, 1); if( TYPEOF(Pike_sp[-1]) != T_STRING || Pike_sp[-1].u.string->len != 8 ) Pike_error("Illegal return value from random_string.\n");
78c5682016-03-24Henrik Grubbström (Grubba) #if PIKE_BYTEORDER == 1234 /* Little endian. */
1f12012016-01-13Martin Nilsson  THIS->int_buffer = ((INT64 *)Pike_sp[-1].u.string->str)[0];
78c5682016-03-24Henrik Grubbström (Grubba) #else /* Big endian. */ for (int i = 0; i < 8; i++) { ((p_wchar0 *)&THIS->int_buffer)[i] = STR0(Pike_sp[-1].u.string)[7-i]; } #endif
1f12012016-01-13Martin Nilsson  THIS->buffer_bits = 64; pop_stack(); }
4343ce2016-03-29Martin Nilsson  /* Generates a number 0<=c<limit from random bits taken from the int_buffer. Follows the NIST SP800-90A method for converting bit sequences into bound numbers, described in section B.5.1.1, and summarized as "throw away attempts that are too large". */
36925c2016-01-25Martin Nilsson  static INT_TYPE read_int(INT_TYPE limit)
1f12012016-01-13Martin Nilsson  {
36925c2016-01-25Martin Nilsson  if(limit <= 1) return 0;
1f12012016-01-13Martin Nilsson  int bits = my_log2(limit-1)+1;
7341a92016-03-17Martin Nilsson  INT64 mask = (1L<<bits)-1;
1f12012016-01-13Martin Nilsson  for(int i=0; i<1000; i++) { if(THIS->buffer_bits < bits) fill_int_buffer(); INT_TYPE ret = THIS->int_buffer&mask; THIS->int_buffer >>= bits; THIS->buffer_bits -= bits; if( ret < limit )
36925c2016-01-25Martin Nilsson  return ret;
1f12012016-01-13Martin Nilsson  } Pike_error("Failed to generate random data.\n"); }
36925c2016-01-25Martin Nilsson  /*! @decl int random(int max) *! *! This function returns a random number in the range *! @expr{0 .. @[max]-1@}. *! *! @seealso *! @[Random] */ PIKEFUN int(0..) random(int limit)
1f12012016-01-13Martin Nilsson  {
36925c2016-01-25Martin Nilsson  RETURN read_int(limit);
1f12012016-01-13Martin Nilsson  }
b7a4a02016-01-18Martin Nilsson  /*! @decl float random(float max) *! *! This function returns a random number in the range *! @expr{0 .. @[max]-ɛ@}. *! *! @seealso *! @[Random] */
1f12012016-01-13Martin Nilsson  PIKEFUN float random(float f) { if(f<=0.0) RETURN 0.0;
30f5b22016-04-09Martin Nilsson  UINT64 value;
24f0f72016-03-16Arne Goedeke  if (THIS->buffer_bits < 64) fill_int_buffer(); value = THIS->int_buffer; THIS->buffer_bits = 0;
1f12012016-01-13Martin Nilsson  RETURN (FLOAT_TYPE)ldexp((double)f * value, -64); }
b7a4a02016-01-18Martin Nilsson  /*! @decl mixed random(array|multiset x) *! Returns a random element from @[x]. */
1f12012016-01-13Martin Nilsson  PIKEFUN mixed random(array a) rawtype tFunc(tArr(tSetvar(0,tMix)),tVar(0)); { if(!a->size)
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("random", 1, "array with elements in it");
1f12012016-01-13Martin Nilsson  push_svalue(a->item + (read_int(a->size))); } PIKEFUN mixed random(multiset m) rawtype tFunc(tSet(tSetvar(1,tMix)),tVar(1)); { if(multiset_is_empty (m))
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("random", 1, "multiset with elements in it");
1f12012016-01-13Martin Nilsson  push_multiset_index (m, multiset_get_nth (m, read_int(multiset_sizeof (m)))); sub_msnode_ref (m); }
b7a4a02016-01-18Martin Nilsson  /*! @decl array random(mapping m) *! Returns a random index-value pair from the mapping. */
1f12012016-01-13Martin Nilsson  PIKEFUN array random(mapping m) { struct keypair *k; int e, count; if(!m_sizeof(m))
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("random", 1, "mapping with elements in it");
1f12012016-01-13Martin Nilsson  count = read_int( m_sizeof(m) ); NEW_MAPPING_LOOP(m->data) { if(count-- < 1) { push_svalue(&k->ind); push_svalue(&k->val); f_aggregate(2); return; } } UNREACHABLE(); }
b7a4a02016-01-18Martin Nilsson  /*! @decl mixed random(object o)
705e612016-03-13Henrik Grubbström (Grubba)  *! If random is called with an object, @[lfun::_random] will be
b7a4a02016-01-18Martin Nilsson  *! called in the object. *! *! @seealso *! @[lfun::_random()] */
1f12012016-01-13Martin Nilsson  PIKEFUN mixed random(object o) { int f = low_find_lfun(o->prog, LFUN__RANDOM); if (f < 0) Pike_error("Calling undefined lfun::%s.\n", lfun_names[LFUN__RANDOM]);
d7fdf72016-03-09Martin Nilsson  struct object *co = Pike_fp->current_object; ref_push_function(co, f_RandomInterface_random_string_fun_num); /* FIXME: precompiler doesn't generate usable fun_nums for variant symbols. */ ref_push_function(co, find_shared_string_identifier(MK_STRING("random"), co->prog)); apply_low(o, f, 2);
1f12012016-01-13Martin Nilsson  } }
c1dfb32016-03-18Martin Nilsson /** * Generates a random string of length len, using the current * random_string() function, and pushes it on the stack. */ PMOD_EXPORT void push_random_string(unsigned len) { struct svalue *random = simple_mapping_string_lookup(get_builtin_constants(), "random_string"); if(!random || (TYPEOF(*random) != T_FUNCTION)) Pike_error("Unable to resolve random function.\n"); push_int(len); apply_svalue(random, 1);
4ae9502016-03-19Martin Nilsson  if(TYPEOF(Pike_sp[-1])!=T_STRING || Pike_sp[-1].u.string->len != len || Pike_sp[-1].u.string->size_shift != 0)
c1dfb32016-03-18Martin Nilsson  Pike_error("Couldn't generate random string.\n"); }
2918542016-01-15Martin Nilsson #ifdef __NT__ #include <wincrypt.h>
ffaa5a2016-01-17Martin Nilsson static HCRYPTPROV crypto_handle;
403a452016-04-02Henrik Grubbström (Grubba) #else static int random_fd = -1; #endif
2918542016-01-15Martin Nilsson PIKECLASS RandomSystem { INHERIT RandomInterface;
b919a72016-04-02Henrik Grubbström (Grubba)  PIKEFUN string(8bit) random_string(int(0..) len)
2918542016-01-15Martin Nilsson  {
b919a72016-04-02Henrik Grubbström (Grubba)  if( !len )
530fe42016-01-17Martin Nilsson  RETURN empty_pike_string;
b919a72016-04-02Henrik Grubbström (Grubba)  if( len<0 ) Pike_error("Bad argument 1 to random_string(). Expected int(0..).\n");
403a452016-04-02Henrik Grubbström (Grubba)  #ifdef __NT__
2918542016-01-15Martin Nilsson  if(!crypto_handle) {
ffaa5a2016-01-17Martin Nilsson  if( !CryptAcquireContext(&crypto_handle, 0, 0, PROV_RSA_FULL,
2918542016-01-15Martin Nilsson  CRYPT_VERIFYCONTEXT|CRYPT_SILENT) ) Pike_error("Failed to set up Crypto Service.\n"); }
403a452016-04-02Henrik Grubbström (Grubba)  struct pike_string *ret = begin_shared_string(len); if( !CryptGenRandom(crypto_handle, len, (BYTE*)ret->str) )
2918542016-01-15Martin Nilsson  {
403a452016-04-02Henrik Grubbström (Grubba)  do_free_unlinked_pike_string (ret);
2918542016-01-15Martin Nilsson  Pike_error("Failed to create random data.\n"); }
403a452016-04-02Henrik Grubbström (Grubba) #else /* !__NT__ */
ffaa5a2016-01-17Martin Nilsson  if( random_fd==-1 )
1f12012016-01-13Martin Nilsson  {
ffaa5a2016-01-17Martin Nilsson  random_fd = open("/dev/urandom", O_RDONLY); if( random_fd==-1 )
1f12012016-01-13Martin Nilsson  Pike_error("Failed to open /dev/urandom.\n"); } struct pike_string *ret = begin_shared_string(len); char* str = ret->str; while( len ) {
ffaa5a2016-01-17Martin Nilsson  int sz = read(random_fd, str, len);
403a452016-04-02Henrik Grubbström (Grubba)  if (sz < 0) { free_string(ret); /* Attempt to recover on next call. */ close(random_fd); random_fd = -1; Pike_error("Failed to read %d bytes from /dev/urandom.\n", len); }
1f12012016-01-13Martin Nilsson  str += sz; len -= sz; }
403a452016-04-02Henrik Grubbström (Grubba) #endif /* !__NT__ */
1f12012016-01-13Martin Nilsson 
ffaa5a2016-01-17Martin Nilsson  RETURN end_shared_string(ret);
1f12012016-01-13Martin Nilsson  } }
1c1c5e2001-04-08Fredrik Hübinette (Hubbe) 
687af42008-07-08Henrik Grubbström (Grubba) #if defined(HAVE_SETENV) && defined(HAVE_UNSETENV) #define USE_SETENV #else
8d401b2008-06-05Martin Stjernholm /* Used to hold refs to the strings that we feed to putenv. Indexed on
687af42008-07-08Henrik Grubbström (Grubba)  * variable names, values are the "name=value" strings. * * This is not needed when using {,un}setenv(), since they maintain * their own corresponding table. */
8d401b2008-06-05Martin Stjernholm static struct mapping *env_allocs = NULL;
687af42008-07-08Henrik Grubbström (Grubba) #endif
8d401b2008-06-05Martin Stjernholm  /* Works exactly like the getenv efun defined in the master, but only * accesses the real environment. Everyone should use the caching * version in the master instead. */ PIKEFUN string|mapping _getenv (void|string var) rawtype tOr(tFunc(tStr, tString), tFunc(tVoid, tMap (tStr, tStr))); { /* FIXME: Perhaps add the amigaos4 stuff from pike_push_env here too. */ if (var) { if (var->size_shift) SIMPLE_ARG_TYPE_ERROR ("getenv", 1, "void|string(0..255)"); if (string_has_null (var)) { /* Won't find a variable name like this. */ pop_stack(); push_int (0); } else { char *entry = getenv (var->str); pop_stack(); if (!entry) push_int (0); else {
5aa54c2014-09-03Martin Nilsson  char *eq = strchr (entry, '=');
8d401b2008-06-05Martin Stjernholm  /* There should always be a '=' in the entry, but you never know.. */ push_string (make_shared_string (eq ? eq + 1 : entry)); } } } else { #ifdef DECLARE_ENVIRON extern char **environ; #endif struct mapping *m, *new_env_allocs; int n; /* Iterate the environment backwards below so that earlier * variables will override later ones in case the same variable * occur multiple times (which it shouldn't). That makes the * result similar to what getenv(3) commonly returns (at least the * one in gnu libc). */ for (n = 0; environ[n]; n++) {} m = allocate_mapping (n);
687af42008-07-08Henrik Grubbström (Grubba) #ifndef USE_SETENV
8d401b2008-06-05Martin Stjernholm  if (env_allocs) new_env_allocs = allocate_mapping (m_sizeof (env_allocs));
687af42008-07-08Henrik Grubbström (Grubba) #endif /* !USE_SETENV */
8d401b2008-06-05Martin Stjernholm  while (--n >= 0) {
5aa54c2014-09-03Martin Nilsson  char *entry = environ[n], *eq = strchr (entry, '=');
8d401b2008-06-05Martin Stjernholm  if (eq) { /* gnu libc getenv ignores variables without '='. */ struct pike_string *var = make_shared_binary_string (entry, eq - entry); struct pike_string *val = make_shared_string (eq + 1); mapping_string_insert_string (m, var, val);
687af42008-07-08Henrik Grubbström (Grubba) #ifndef USE_SETENV
8d401b2008-06-05Martin Stjernholm  /* Populate new_env_allocs with the env_allocs entries that * are still in use. */ if (env_allocs) { struct svalue *ea_val = low_mapping_string_lookup (env_allocs, var); if (ea_val && ea_val->u.string->str == entry) mapping_string_insert (new_env_allocs, var, ea_val); }
687af42008-07-08Henrik Grubbström (Grubba) #endif /* !USE_SETENV */
8d401b2008-06-05Martin Stjernholm  free_string (var); free_string (val); } }
687af42008-07-08Henrik Grubbström (Grubba) #ifndef USE_SETENV
8d401b2008-06-05Martin Stjernholm  if (env_allocs) { free_mapping (env_allocs); env_allocs = new_env_allocs; }
687af42008-07-08Henrik Grubbström (Grubba) #endif /* !USE_SETENV */
8d401b2008-06-05Martin Stjernholm  push_mapping (m); } } /* Works exactly like the putenv efun defined in the master, but only * updates the real environment. Everyone should use the version in * the master instead so that the cache doesn't get stale. */ PIKEFUN void _putenv (string var, void|string val) {
687af42008-07-08Henrik Grubbström (Grubba) #ifndef USE_SETENV
8d401b2008-06-05Martin Stjernholm  struct pike_string *putenv_str, *env_alloc_var;
687af42008-07-08Henrik Grubbström (Grubba) #endif
8d401b2008-06-05Martin Stjernholm  if (var->size_shift) SIMPLE_ARG_TYPE_ERROR ("putenv", 1, "string(0..255)");
5aa54c2014-09-03Martin Nilsson  if (string_has_null (var) || strchr (var->str, '='))
8d401b2008-06-05Martin Stjernholm  SIMPLE_ARG_ERROR ("putenv", 1, "Variable name cannot contain '=' or NUL."); if (val) {
687af42008-07-08Henrik Grubbström (Grubba) #ifndef USE_SETENV
8d401b2008-06-05Martin Stjernholm  struct string_builder sb;
687af42008-07-08Henrik Grubbström (Grubba) #endif
8d401b2008-06-05Martin Stjernholm  if (val->size_shift) SIMPLE_ARG_TYPE_ERROR ("putenv", 2, "void|string(0..255)"); if (string_has_null (val)) SIMPLE_ARG_ERROR ("putenv", 2, "Variable value cannot contain NUL.");
687af42008-07-08Henrik Grubbström (Grubba) #ifdef USE_SETENV if (setenv(var->str, val->str, 1)) { if (errno == ENOMEM) SIMPLE_OUT_OF_MEMORY_ERROR ("putenv", 0); else Pike_error ("Error from setenv(3): %s\n", strerror (errno)); } #else /* !USE_SETENV */
8d401b2008-06-05Martin Stjernholm  init_string_builder (&sb, 0); string_builder_shared_strcat (&sb, var); string_builder_putchar (&sb, '='); string_builder_shared_strcat (&sb, val); putenv_str = finish_string_builder (&sb); push_string (putenv_str); /* Let mega_apply pop. */
687af42008-07-08Henrik Grubbström (Grubba) #endif /* USE_SETENV */
8d401b2008-06-05Martin Stjernholm  }
0654322008-06-10Martin Stjernholm  else {
687af42008-07-08Henrik Grubbström (Grubba) #ifdef USE_SETENV /* Note: Some versions of glibc have a unsetenv(3) that returns void, * thus no checking of the return value here. */ unsetenv(var->str); #else /* !USE_SETENV */
0654322008-06-10Martin Stjernholm #ifdef PUTENV_ALWAYS_REQUIRES_EQUAL /* Windows can never get things quite right.. :P */ struct string_builder sb; init_string_builder (&sb, 0); string_builder_shared_strcat (&sb, var); string_builder_putchar (&sb, '='); putenv_str = finish_string_builder (&sb); push_string (putenv_str); /* Let mega_apply pop. */ #else
8d401b2008-06-05Martin Stjernholm  putenv_str = var;
0654322008-06-10Martin Stjernholm #endif
687af42008-07-08Henrik Grubbström (Grubba) #endif /* USE_SETENV */
0654322008-06-10Martin Stjernholm  }
8d401b2008-06-05Martin Stjernholm 
687af42008-07-08Henrik Grubbström (Grubba) #ifndef USE_SETENV
6c15cb2008-06-10Martin Stjernholm  if (putenv (putenv_str->str)) { if (errno == ENOMEM) SIMPLE_OUT_OF_MEMORY_ERROR ("putenv", 0); else Pike_error ("Error from putenv(3): %s\n", strerror (errno)); }
8d401b2008-06-05Martin Stjernholm  #ifdef __NT__ ref_push_string (var); f_lower_case (1);
017b572011-10-28Henrik Grubbström (Grubba)  assert (TYPEOF(Pike_sp[-1]) == T_STRING);
8d401b2008-06-05Martin Stjernholm  env_alloc_var = Pike_sp[-1].u.string; /* Let mega_apply pop. */ #else env_alloc_var = var; #endif if (!env_allocs) env_allocs = allocate_mapping (4); if (val) /* Must keep the string passed to putenv allocated (and we * assume no other entities are naughty enough to modify it). */ mapping_string_insert_string (env_allocs, env_alloc_var, putenv_str); else { struct svalue key;
017b572011-10-28Henrik Grubbström (Grubba)  SET_SVAL(key, T_STRING, 0, string, env_alloc_var);
8d401b2008-06-05Martin Stjernholm  map_delete (env_allocs, &key); }
687af42008-07-08Henrik Grubbström (Grubba) #endif /* !USE_SETENV */
8d401b2008-06-05Martin Stjernholm }
d27df52001-06-18Henrik Grubbström (Grubba) /* * Backtrace handling. */
bcbce02001-08-15Martin Nilsson /*! @module Pike */
d27df52001-06-18Henrik Grubbström (Grubba) /*! @class BacktraceFrame */ PIKECLASS backtrace_frame {
e044e22009-06-24Henrik Grubbström (Grubba)  PIKEVAR mixed _fun flags ID_PROTECTED|ID_PRIVATE; #ifdef PIKE_DEBUG PIKEVAR program oprog flags ID_PROTECTED|ID_PRIVATE; #endif
2aca9f2001-06-19Henrik Grubbström (Grubba)  PIKEVAR array args;
73b08f2003-01-31Martin Stjernholm 
e044e22009-06-24Henrik Grubbström (Grubba)  /* These are cleared when filename and lineno have been initialized
73b08f2003-01-31Martin Stjernholm  * from them. */
95489a2008-06-29Martin Nilsson  PIKEVAR program prog flags ID_PROTECTED|ID_PRIVATE;
90f8762002-04-08Martin Stjernholm  CVAR PIKE_OPCODE_T *pc;
73b08f2003-01-31Martin Stjernholm  /* These two are considered to be uninitialized from prog, pc and * fun as long as lineno == -1. */
d27df52001-06-18Henrik Grubbström (Grubba)  CVAR struct pike_string *filename;
ef24a82012-01-12Henrik Grubbström (Grubba)  CVAR INT_TYPE lineno;
d27df52001-06-18Henrik Grubbström (Grubba)  INIT {
90f8762002-04-08Martin Stjernholm  THIS->pc = NULL;
73b08f2003-01-31Martin Stjernholm  THIS->lineno = -1;
0f47db2001-06-19Henrik Grubbström (Grubba)  THIS->filename = NULL;
d27df52001-06-18Henrik Grubbström (Grubba)  } EXIT
8dcb7d2008-05-29Martin Stjernholm  gc_trivial;
d27df52001-06-18Henrik Grubbström (Grubba)  { if (THIS->filename) { free_string(THIS->filename);
0f47db2001-06-19Henrik Grubbström (Grubba)  THIS->filename = NULL;
d27df52001-06-18Henrik Grubbström (Grubba)  }
1073bf2001-06-26Henrik Grubbström (Grubba)  THIS->pc = NULL;
73b08f2003-01-31Martin Stjernholm  THIS->lineno = -1;
d27df52001-06-18Henrik Grubbström (Grubba)  }
4452172009-06-25Henrik Grubbström (Grubba)  /* NOTE: Use old-style getter/setter syntax for compatibility with * old Parser.Pike.split() used by precompile.pike. */ PIKEFUN mixed `->fun()
e044e22009-06-24Henrik Grubbström (Grubba)  { push_svalue(&THIS->_fun); }
513e2c2009-06-25Henrik Grubbström (Grubba)  PIKEFUN void `->fun=(mixed val)
e044e22009-06-24Henrik Grubbström (Grubba)  { /* FIXME: Should we allow this at all? * Linenumber info etc won't match. */ #ifdef PIKE_DEBUG
017b572011-10-28Henrik Grubbström (Grubba)  if ((TYPEOF(*val) == T_FUNCTION) && (SUBTYPEOF(*val) != FUNCTION_BUILTIN)) {
e044e22009-06-24Henrik Grubbström (Grubba)  assign_short_svalue((union anything *)&THIS->oprog, (union anything *)&val->u.object->prog, T_PROGRAM); } #endif assign_svalue(&THIS->_fun, val); }
18c2252003-04-10Martin Nilsson  /*! @decl int(0..1) _is_type(string t) *! This object claims to be an array for backward compatibility. */
d2cd4e2001-06-18Henrik Grubbström (Grubba)  PIKEFUN int(0..1) _is_type(string t) {
db795b2015-12-28Per Hedbor  RETURN (t == literal_array_string);
d2cd4e2001-06-18Henrik Grubbström (Grubba)  }
73b08f2003-01-31Martin Stjernholm  static void fill_in_file_and_line() {
0469ba2004-02-10Martin Stjernholm  struct pike_string *file = NULL;
73b08f2003-01-31Martin Stjernholm  assert (THIS->lineno == -1); if (THIS->pc && THIS->prog) { file = low_get_line(THIS->pc, THIS->prog, &THIS->lineno); THIS->pc = NULL; }
017b572011-10-28Henrik Grubbström (Grubba)  else if (TYPEOF(THIS->_fun) == PIKE_T_FUNCTION) {
e044e22009-06-24Henrik Grubbström (Grubba) #ifdef PIKE_DEBUG if (THIS->_fun.u.object->prog && THIS->_fun.u.object->prog != THIS->oprog) {
017b572011-10-28Henrik Grubbström (Grubba)  struct identifier *id = ID_FROM_INT(THIS->oprog, SUBTYPEOF(THIS->_fun));
e044e22009-06-24Henrik Grubbström (Grubba)  /* FIXME: Dump dmalloc info for the object? */ Pike_fatal("Lost track of function pointer! Function name was %s.\n", id->name?id->name->str:"<no name>"); } #endif
017b572011-10-28Henrik Grubbström (Grubba)  file = low_get_function_line (THIS->_fun.u.object, SUBTYPEOF(THIS->_fun),
73b08f2003-01-31Martin Stjernholm  &THIS->lineno);
d191622006-03-22Henrik Grubbström (Grubba)  } else if (THIS->prog) {
73b08f2003-01-31Martin Stjernholm  file = low_get_program_line (THIS->prog, &THIS->lineno);
d191622006-03-22Henrik Grubbström (Grubba)  }
73b08f2003-01-31Martin Stjernholm 
0469ba2004-02-10Martin Stjernholm  if (file) { if (!THIS->filename) THIS->filename = file; else free_string (file); }
73b08f2003-01-31Martin Stjernholm  if (THIS->prog) { free_program(THIS->prog); THIS->prog = NULL; } }
18c2252003-04-10Martin Nilsson  /*! @decl string _sprintf(int c, mapping|void opts) */
d27df52001-06-18Henrik Grubbström (Grubba)  PIKEFUN string _sprintf(int c, mapping|void opts) { pop_n_elems(args);
e6dbc22002-11-29Marcus Comstedt  if (c != 'O') { push_undefined (); return; }
75367d2014-08-22Arne Goedeke  push_static_text("backtrace_frame(");
73b08f2003-01-31Martin Stjernholm  if (THIS->lineno == -1) fill_in_file_and_line();
1073bf2001-06-26Henrik Grubbström (Grubba)  if (THIS->filename) {
d27df52001-06-18Henrik Grubbström (Grubba)  ref_push_string(THIS->filename);
75367d2014-08-22Arne Goedeke  push_static_text(":");
d27df52001-06-18Henrik Grubbström (Grubba)  push_int(THIS->lineno);
75367d2014-08-22Arne Goedeke  push_static_text(", ");
d27df52001-06-18Henrik Grubbström (Grubba)  f_add(4); } else {
75367d2014-08-22Arne Goedeke  push_static_text("Unknown file, ");
d27df52001-06-18Henrik Grubbström (Grubba)  }
017b572011-10-28Henrik Grubbström (Grubba)  if (TYPEOF(THIS->_fun) == PIKE_T_FUNCTION) {
e044e22009-06-24Henrik Grubbström (Grubba)  if (THIS->_fun.u.object->prog) { #ifdef PIKE_DEBUG if (THIS->_fun.u.object->prog != THIS->oprog) {
017b572011-10-28Henrik Grubbström (Grubba)  struct identifier *id = ID_FROM_INT(THIS->oprog, SUBTYPEOF(THIS->_fun));
e044e22009-06-24Henrik Grubbström (Grubba)  /* FIXME: Dump dmalloc info for the object? */ Pike_fatal("Lost track of function pointer! Function name was %s.\n", id->name?id->name->str:"<no name>"); } #endif push_svalue(&THIS->_fun);
0f47db2001-06-19Henrik Grubbström (Grubba)  f_function_name(1);
75367d2014-08-22Arne Goedeke  push_static_text("(), ");
0f47db2001-06-19Henrik Grubbström (Grubba)  f_add(2); } else {
e044e22009-06-24Henrik Grubbström (Grubba)  free_svalue(&THIS->_fun);
017b572011-10-28Henrik Grubbström (Grubba)  SET_SVAL(THIS->_fun, PIKE_T_INT, NUMBER_DESTRUCTED, integer, 0);
75367d2014-08-22Arne Goedeke  push_static_text("destructed_function(), ");
0f47db2001-06-19Henrik Grubbström (Grubba)  }
fac36c2012-01-16Henrik Grubbström (Grubba)  } else if (TYPEOF(THIS->_fun) == PIKE_T_PROGRAM) { /* FIXME: Use the master? */
75367d2014-08-22Arne Goedeke  push_static_text("program(), ");
42d5b32012-01-09Henrik Grubbström (Grubba)  } else if (TYPEOF(THIS->_fun) == PIKE_T_STRING) { push_svalue(&THIS->_fun);
75367d2014-08-22Arne Goedeke  push_static_text("(), ");
42d5b32012-01-09Henrik Grubbström (Grubba)  f_add(2);
d27df52001-06-18Henrik Grubbström (Grubba)  } else {
75367d2014-08-22Arne Goedeke  push_static_text("destructed_function(), ");
d27df52001-06-18Henrik Grubbström (Grubba)  }
0f47db2001-06-19Henrik Grubbström (Grubba)  if (THIS->args) {
75367d2014-08-22Arne Goedeke  push_static_text("Args: ");
0f47db2001-06-19Henrik Grubbström (Grubba)  push_int(THIS->args->size);
d27df52001-06-18Henrik Grubbström (Grubba)  f_add(2); } else {
75367d2014-08-22Arne Goedeke  push_static_text("No args");
d27df52001-06-18Henrik Grubbström (Grubba)  }
75367d2014-08-22Arne Goedeke  push_static_text(")");
d27df52001-06-18Henrik Grubbström (Grubba)  f_add(5); }
18c2252003-04-10Martin Nilsson  /*! @decl int(3..) _sizeof() */ PIKEFUN int(3..) _sizeof()
d27df52001-06-18Henrik Grubbström (Grubba)  {
0f47db2001-06-19Henrik Grubbström (Grubba)  if (THIS->args) { push_int(THIS->args->size + 3); } else { push_int(3);
d27df52001-06-18Henrik Grubbström (Grubba)  } }
18c2252003-04-10Martin Nilsson  /*! @decl mixed `[](int index, int|void end_or_none) *! The BacktraceFrame object can be indexed as an array. */
d2cd4e2001-06-18Henrik Grubbström (Grubba)  PIKEFUN mixed `[](int index, int|void end_or_none)
d27df52001-06-18Henrik Grubbström (Grubba)  {
d2cd4e2001-06-18Henrik Grubbström (Grubba)  INT_TYPE end = index;
d398fc2014-08-25Stephen R. van den Berg  INT32 numargs = 3;
d2cd4e2001-06-18Henrik Grubbström (Grubba)  INT32 i;
d398fc2014-08-25Stephen R. van den Berg  if (THIS->args) numargs += THIS->args->size;
d2cd4e2001-06-18Henrik Grubbström (Grubba)  if (!end_or_none) {
d398fc2014-08-25Stephen R. van den Berg  if (index < 0)
d2cd4e2001-06-18Henrik Grubbström (Grubba)  index_error("pike_frame->`[]", Pike_sp-args, args, NULL, Pike_sp-args, "Indexing with negative index (%"PRINTPIKEINT"d)\n", index);
d398fc2014-08-25Stephen R. van den Berg  else if (index >= numargs)
d2cd4e2001-06-18Henrik Grubbström (Grubba)  index_error("pike_frame->`[]", Pike_sp-args, args, NULL, Pike_sp-args, "Indexing with too large index (%"PRINTPIKEINT"d)\n", index);
d398fc2014-08-25Stephen R. van den Berg  } else
d2cd4e2001-06-18Henrik Grubbström (Grubba)  end = end_or_none->u.integer;
d27df52001-06-18Henrik Grubbström (Grubba)  pop_n_elems(args);
d2cd4e2001-06-18Henrik Grubbström (Grubba)  if (end_or_none) {
0f47db2001-06-19Henrik Grubbström (Grubba)  if ((end < 0) || (end < index) || (index >= numargs)) {
d2cd4e2001-06-18Henrik Grubbström (Grubba)  f_aggregate(0); return;
d27df52001-06-18Henrik Grubbström (Grubba)  }
d2cd4e2001-06-18Henrik Grubbström (Grubba) 
5929f32014-08-25Stephen R. van den Berg  if (end >= numargs)
d2cd4e2001-06-18Henrik Grubbström (Grubba)  end = numargs-1; } for (i = index; i <= end; i++) { switch(i) { case 0: /* Filename */
73b08f2003-01-31Martin Stjernholm  if (THIS->lineno == -1) fill_in_file_and_line();
5929f32014-08-25Stephen R. van den Berg  if (THIS->filename)
73b08f2003-01-31Martin Stjernholm  ref_push_string(THIS->filename);
5929f32014-08-25Stephen R. van den Berg  else
73b08f2003-01-31Martin Stjernholm  push_int(0);
1073bf2001-06-26Henrik Grubbström (Grubba)  break;
73b08f2003-01-31Martin Stjernholm  case 1: /* Linenumber */ if (THIS->lineno == -1) fill_in_file_and_line(); push_int(THIS->lineno); break;
d2cd4e2001-06-18Henrik Grubbström (Grubba)  case 2: /* Function */
e044e22009-06-24Henrik Grubbström (Grubba)  push_svalue(&THIS->_fun);
d2cd4e2001-06-18Henrik Grubbström (Grubba)  break; default: /* Arguments */ {
0f47db2001-06-19Henrik Grubbström (Grubba)  if ((i > 2) && (THIS->args) && (i-3 < THIS->args->size)) { push_svalue(THIS->args->item + (i - 3));
d2cd4e2001-06-18Henrik Grubbström (Grubba)  break; }
de22f72014-08-25Martin Nilsson  bad_arg_error("`[]", Pike_sp-args, args, 1,
d2cd4e2001-06-18Henrik Grubbström (Grubba)  "int(0..)", Pike_sp-args, "Bad argument 1 to backtrace_frame->`[](): " "Expected int(0..%d)\n", numargs + 2);
9282fd2015-09-27Martin Nilsson  } UNREACHABLE(break);
d27df52001-06-18Henrik Grubbström (Grubba)  }
d2cd4e2001-06-18Henrik Grubbström (Grubba)  }
5929f32014-08-25Stephen R. van den Berg  if (end_or_none)
d2cd4e2001-06-18Henrik Grubbström (Grubba)  f_aggregate(1 + end - index);
d27df52001-06-18Henrik Grubbström (Grubba)  }
d2cd4e2001-06-18Henrik Grubbström (Grubba) 
18c2252003-04-10Martin Nilsson  /*! @decl mixed `[]=(int index, mixed value) */
1073bf2001-06-26Henrik Grubbström (Grubba)  PIKEFUN mixed `[]=(int index, mixed value) {
5929f32014-08-25Stephen R. van den Berg  INT32 numargs = 3;
1073bf2001-06-26Henrik Grubbström (Grubba) 
5929f32014-08-25Stephen R. van den Berg  if (THIS->args) numargs += THIS->args->size;
1073bf2001-06-26Henrik Grubbström (Grubba) 
5929f32014-08-25Stephen R. van den Berg  if ((index < -numargs) || (index >= numargs))
1073bf2001-06-26Henrik Grubbström (Grubba)  index_error("pike_frame->`[]=", Pike_sp-args, args, NULL, Pike_sp-args,
b99d882003-05-15Martin Stjernholm  "Index %"PRINTPIKEINT"d is out of array range 0..%d,\n",
1073bf2001-06-26Henrik Grubbström (Grubba)  index, numargs-1);
5929f32014-08-25Stephen R. van den Berg  else if (index < 0)
1073bf2001-06-26Henrik Grubbström (Grubba)  index += numargs; if (args > 2) { pop_n_elems(args - 2); args = 2; } switch(index) { case 0: /* Filename */
73b08f2003-01-31Martin Stjernholm  if (THIS->lineno == -1) fill_in_file_and_line();
017b572011-10-28Henrik Grubbström (Grubba)  if (TYPEOF(*value) != PIKE_T_STRING) { if ((TYPEOF(*value) != PIKE_T_INT) ||
73b08f2003-01-31Martin Stjernholm  (value->u.integer)) {
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("`[]=", 2, "string|int(0..0)");
1073bf2001-06-26Henrik Grubbström (Grubba)  }
73b08f2003-01-31Martin Stjernholm  if (THIS->filename) { free_string(THIS->filename); THIS->filename = NULL;
1073bf2001-06-26Henrik Grubbström (Grubba)  } } else {
73b08f2003-01-31Martin Stjernholm  if (THIS->filename) { free_string(THIS->filename); THIS->filename = NULL;
1073bf2001-06-26Henrik Grubbström (Grubba)  }
73b08f2003-01-31Martin Stjernholm  copy_shared_string(THIS->filename, value->u.string);
1073bf2001-06-26Henrik Grubbström (Grubba)  } break;
73b08f2003-01-31Martin Stjernholm  case 1: /* Linenumber */ if (THIS->lineno == -1) fill_in_file_and_line();
5929f32014-08-25Stephen R. van den Berg  if (TYPEOF(*value) != PIKE_T_INT)
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("`[]=", 2, "int(1..)");
73b08f2003-01-31Martin Stjernholm  THIS->lineno = value->u.integer; break;
1073bf2001-06-26Henrik Grubbström (Grubba)  case 2: /* Function */
73b08f2003-01-31Martin Stjernholm  if (THIS->lineno == -1) fill_in_file_and_line();
e044e22009-06-24Henrik Grubbström (Grubba)  assign_svalue(&THIS->_fun, value);
1073bf2001-06-26Henrik Grubbström (Grubba)  break; default: /* Arguments */ assign_svalue(THIS->args->item + index - 3, value); break; } stack_swap(); pop_stack(); }
d27df52001-06-18Henrik Grubbström (Grubba) }; /*! @endclass */
5809812006-03-25Henrik Grubbström (Grubba) /*! @decl mapping(string:int|string) get_runtime_info() *! *! Get information about the Pike runtime. *! *! @returns *! Returns a mapping with the following content: *! @mapping *! @member string "bytecode_method" *! A string describing the bytecode method used by *! the Pike interpreter. *! @member int "abi" *! The number of bits in the ABI. Usually @expr{32@} or @expr{64@}. *! @member int "native_byteorder" *! The byte order used by the native cpu.
6c9f492006-04-22Henrik Grubbström (Grubba)  *! Usually @expr{1234@} (aka little endian) or *! @expr{4321@} (aka bigendian).
5809812006-03-25Henrik Grubbström (Grubba)  *! @member int "int_size" *! The number of bits in the native integer type. *! Usually @expr{32@} or @expr{64@}. *! @member int "float_size" *! The number of bits in the native floating point type. *! Usually @expr{32@} or @expr{64@}. *! @member int(0..1) "auto_bignum" *! Present if integers larger than the native size are automatically *! converted into bignums. *! @endmapping */ PIKEFUN mapping(string:int|string) get_runtime_info() optflags OPT_TRY_OPTIMIZE; { pop_n_elems(args);
75367d2014-08-22Arne Goedeke  push_static_text("bytecode_method");
7cf0162014-05-22Per Hedbor  push_text(PIKE_BYTECODE_METHOD_NAME);
75367d2014-08-22Arne Goedeke  push_static_text("abi");
5809812006-03-25Henrik Grubbström (Grubba)  push_int(sizeof(void *) * 8);
75367d2014-08-22Arne Goedeke  push_static_text("native_byteorder");
5809812006-03-25Henrik Grubbström (Grubba)  push_int(PIKE_BYTEORDER);
75367d2014-08-22Arne Goedeke  push_static_text("int_size");
5809812006-03-25Henrik Grubbström (Grubba)  push_int(sizeof(INT_TYPE) * 8);
75367d2014-08-22Arne Goedeke  push_static_text("float_size");
5809812006-03-25Henrik Grubbström (Grubba)  push_int(sizeof(FLOAT_TYPE) * 8);
75367d2014-08-22Arne Goedeke  push_static_text("auto_bignum");
5809812006-03-25Henrik Grubbström (Grubba)  push_int(1); f_aggregate_mapping(6*2); }
bcbce02001-08-15Martin Nilsson /*! @endmodule */
d97eb72011-07-10Henrik Grubbström (Grubba) void low_backtrace(struct Pike_interpreter_struct *i)
d27df52001-06-18Henrik Grubbström (Grubba) {
b85fa02003-02-24Martin Stjernholm  struct svalue *stack_top = i->stack_pointer;
c98dd22001-06-26Martin Stjernholm  struct pike_frame *f, *of = 0;
d27df52001-06-18Henrik Grubbström (Grubba)  int size = 0;
9906e32001-06-20Henrik Grubbström (Grubba)  struct array *res = NULL;
d27df52001-06-18Henrik Grubbström (Grubba) 
a8e9892001-09-05Fredrik Hübinette (Hubbe)  for (f = i->frame_pointer; f; f = f->next) {
9906e32001-06-20Henrik Grubbström (Grubba)  size++; } res = allocate_array_no_init(size, 0); push_array(res);
a8e9892001-09-05Fredrik Hübinette (Hubbe)  for (f = i->frame_pointer; f && size; f = (of = f)->next) {
d27df52001-06-18Henrik Grubbström (Grubba)  struct object *o = low_clone(backtrace_frame_program);
0f47db2001-06-19Henrik Grubbström (Grubba)  struct backtrace_frame_struct *bf;
e89d722002-01-04Henrik Grubbström (Grubba)  struct identifier *function = NULL;
0f47db2001-06-19Henrik Grubbström (Grubba) 
d27df52001-06-18Henrik Grubbström (Grubba)  call_c_initializers(o);
0f47db2001-06-19Henrik Grubbström (Grubba) 
9906e32001-06-20Henrik Grubbström (Grubba)  size--;
017b572011-10-28Henrik Grubbström (Grubba)  SET_SVAL(res->item[size], PIKE_T_OBJECT, 0, object, o);
9906e32001-06-20Henrik Grubbström (Grubba) 
0f47db2001-06-19Henrik Grubbström (Grubba)  bf = OBJ2_BACKTRACE_FRAME(o);
028e712015-05-01Arne Goedeke  if (f->type == FRAME_PIKE_FUNCTION && f->context && (bf->prog = f->context->prog)) {
0f47db2001-06-19Henrik Grubbström (Grubba)  add_ref(bf->prog);
df4fe22006-03-22Henrik Grubbström (Grubba)  bf->pc = f->pc;
0f47db2001-06-19Henrik Grubbström (Grubba)  }
42d5b32012-01-09Henrik Grubbström (Grubba)  SET_SVAL(bf->_fun, PIKE_T_INT, NUMBER_DESTRUCTED, integer, 0);
017b572011-10-28Henrik Grubbström (Grubba)  if (f->current_object && f->current_object->prog) {
028e712015-05-01Arne Goedeke  if (f->type == FRAME_BUILTIN) {
42d5b32012-01-09Henrik Grubbström (Grubba)  /* Unusual case. The frame is from call_c_initializers(), gc() * or similar. cf [bug 6156]. /grubba
fac36c2012-01-16Henrik Grubbström (Grubba)  * * Masquerade as the program. * * FIXME: Ought to keep parent-pointers.
42d5b32012-01-09Henrik Grubbström (Grubba)  */
fac36c2012-01-16Henrik Grubbström (Grubba)  SET_SVAL(bf->_fun, PIKE_T_PROGRAM, 0, program, f->current_object->prog); add_ref(f->current_object->prog);
42d5b32012-01-09Henrik Grubbström (Grubba)  } else { SET_SVAL(bf->_fun, PIKE_T_FUNCTION, CHECK_IDREF_RANGE(f->fun, f->current_object->prog), object, f->current_object); add_ref(f->current_object); function = ID_FROM_INT(f->current_object->prog, f->fun);
e044e22009-06-24Henrik Grubbström (Grubba) #ifdef PIKE_DEBUG
42d5b32012-01-09Henrik Grubbström (Grubba)  add_ref(bf->oprog = bf->_fun.u.object->prog);
e044e22009-06-24Henrik Grubbström (Grubba) #endif
42d5b32012-01-09Henrik Grubbström (Grubba)  }
0f47db2001-06-19Henrik Grubbström (Grubba)  } if (f->locals) {
bd67392015-10-14Martin Nilsson  INT32 numargs = (INT32) MINIMUM(f->num_args, stack_top - f->locals);
e89d722002-01-04Henrik Grubbström (Grubba)  INT32 varargs = 0;
a70d642008-05-28Martin Stjernholm  if(of && of->locals) {
c98dd22001-06-26Martin Stjernholm  /* f->num_args can be too large, so this is necessary for some
01f9142013-08-01Arne Goedeke  * reason. I don't know why. /mast * * possibly because f->num_args was uninitialized for c_initializers * /arne * */
bd67392015-10-14Martin Nilsson  numargs = (INT32)MINIMUM(f->num_args,of->locals - f->locals);
da90692002-11-26Henrik Grubbström (Grubba)  }
0f47db2001-06-19Henrik Grubbström (Grubba)  numargs = MAXIMUM(numargs, 0);
e89d722002-01-04Henrik Grubbström (Grubba)  /* Handle varargs... */ if (function && (function->identifier_flags & IDENTIFIER_VARARGS) &&
b85fa02003-02-24Martin Stjernholm  (f->locals + numargs < stack_top) &&
017b572011-10-28Henrik Grubbström (Grubba)  (TYPEOF(f->locals[numargs]) == T_ARRAY)) {
e89d722002-01-04Henrik Grubbström (Grubba)  varargs = f->locals[numargs].u.array->size; } if (numargs + varargs) { bf->args = allocate_array_no_init(numargs + varargs, 0);
2523ce2003-04-28Martin Stjernholm  bf->args->type_field = assign_svalues_no_free(bf->args->item, f->locals, numargs, BIT_MIXED);
e89d722002-01-04Henrik Grubbström (Grubba)  if (varargs) {
2523ce2003-04-28Martin Stjernholm  bf->args->type_field |= assign_svalues_no_free(bf->args->item + numargs, f->locals[numargs].u.array->item, varargs, BIT_MIXED);
e89d722002-01-04Henrik Grubbström (Grubba)  }
0f47db2001-06-19Henrik Grubbström (Grubba)  } }
d27df52001-06-18Henrik Grubbström (Grubba)  }
2523ce2003-04-28Martin Stjernholm  res->type_field = BIT_OBJECT;
9906e32001-06-20Henrik Grubbström (Grubba)  /* NOTE: res has already been pushed on the stack. */
d27df52001-06-18Henrik Grubbström (Grubba) }
e1b4192001-06-06Fredrik Hübinette (Hubbe) 
a8e9892001-09-05Fredrik Hübinette (Hubbe) /*! @decl array(Pike.BacktraceFrame) backtrace() *! *! FIXME: This documentation is not up to date! *! *! Get a description of the current call stack. *! *! The description is returned as an array with one entry for each call *! frame on the stack. *! *! Each entry has this format: *! @array *! @elem string file *! A string with the filename if known, else zero. *! @elem int line *! An integer containing the linenumber if known, else zero. *! @elem function fun *! The function that was called at this level. *! @elem mixed|void ... args *! The arguments that the function was called with. *! @endarray *! *! The current call frame will be last in the array. *! *! @note *! Please note that the frame order may be reversed in a later version
e1aec82014-11-15Stephen R. van den Berg  *! of Pike to accommodate for deferred backtraces.
a8e9892001-09-05Fredrik Hübinette (Hubbe)  *! *! Note that the arguments reported in the backtrace are the current *! values of the variables, and not the ones that were at call-time. *! This can be used to hide sensitive information from backtraces *! (eg passwords). *! *! @seealso *! @[catch()], @[throw()] */ PMOD_EXPORT PIKEFUN array(mixed) backtrace() efun; optflags OPT_EXTERNAL_DEPEND; { low_backtrace(& Pike_interpreter); }
a3c4332001-06-20Per Hedbor /*! @module String */ /*! @class Buffer *! A buffer, used for building strings. It's
008f902014-09-10Stephen R. van den Berg  *! conceptually similar to a string, but you can only @[add] *! strings to it, and you can only @[get] the value from it once. *! *! There is a reason for those seemingly rather odd limitations, *! it makes it possible to do some optimizations that really speed *! things up.
a3c4332001-06-20Per Hedbor  *! *! You do not need to use this class unless you add very many *! strings together, or very large strings. *! *! @example *! For the fastest possible operation, write your code like this: *!
f79bd82003-04-01Martin Nilsson  *! @code *! String.Buffer b = String.Buffer( );
a3c4332001-06-20Per Hedbor  *!
f79bd82003-04-01Martin Nilsson  *! function add = b->add;
a3c4332001-06-20Per Hedbor  *!
f79bd82003-04-01Martin Nilsson  *! .. call add several times in code ...
a3c4332001-06-20Per Hedbor  *!
f79bd82003-04-01Martin Nilsson  *! string result = b->get(); // also clears the buffer *! @endcode
a3c4332001-06-20Per Hedbor  */
41730d2001-07-26Martin Nilsson PIKECLASS Buffer
a3c4332001-06-20Per Hedbor {
008f902014-09-10Stephen R. van den Berg  CVAR struct string_builder str; CVAR int initial;
e950862014-08-29Stephen R. van den Berg 
008f902014-09-10Stephen R. van den Berg  PIKEFUN int _size_object()
e950862014-08-29Stephen R. van den Berg  {
008f902014-09-10Stephen R. van den Berg  if( THIS->str.s ) RETURN THIS->str.malloced; RETURN 0;
e950862014-08-29Stephen R. van den Berg  }
008f902014-09-10Stephen R. van den Berg  void f_Buffer_get_copy( INT32 args ); void f_Buffer_get( INT32 args ); void f_Buffer_add( INT32 args ); /*! @decl void create(int initial_size) *! *! Initializes a new buffer. *! *! If no @[initial_size] is specified, 256 is used. If you *! know approximately how big the buffer will be, you can optimize *! the operation of @[add()] (slightly) by passing the size to this *! function. */ PIKEFUN void create( int|void size )
e950862014-08-29Stephen R. van den Berg  { struct Buffer_struct *str = THIS;
008f902014-09-10Stephen R. van den Berg  if( size ) str->initial = MAXIMUM( size->u.integer, 512 ); else str->initial = 256;
e950862014-08-29Stephen R. van den Berg  }
008f902014-09-10Stephen R. van den Berg  /*! @decl string _sprintf( int flag, mapping flags ) *! It is possible to @[sprintf] a String.Buffer object *! as @tt{%s@} just as if it was a string. */ PIKEFUN string _sprintf( int flag, mapping flags )
e950862014-08-29Stephen R. van den Berg  {
008f902014-09-10Stephen R. van den Berg  switch( flag ) { case 'O': { struct pike_string *res; struct Buffer_struct *str = THIS;
5e9fc02015-08-18Per Hedbor  push_static_text( "Buffer(%d /* %d */)" );
008f902014-09-10Stephen R. van den Berg  if( str->str.s ) { push_int(str->str.s->len); push_int(str->str.malloced); } else { push_int( 0 ); push_int( 0 ); } f_sprintf( 3 ); dmalloc_touch_svalue(Pike_sp-1); res = Pike_sp[-1].u.string; Pike_sp--; RETURN res; }
e950862014-08-29Stephen R. van den Berg 
008f902014-09-10Stephen R. van den Berg  case 's': { pop_n_elems( args ); if( Pike_fp->current_object->refs != 1 ) f_Buffer_get_copy( 0 ); else f_Buffer_get( 0 ); } return;
13670c2015-05-25Martin Nilsson 
008f902014-09-10Stephen R. van den Berg  case 't': RETURN make_shared_binary_string("Buffer",6); } pop_n_elems( args ); push_undefined();
e950862014-08-29Stephen R. van den Berg  }
2687f92013-09-20Per Hedbor 
008f902014-09-10Stephen R. van den Berg  /*! @decl mixed cast( string type ) *! It is possible to cast a String.Buffer object to *! a @expr{string@} and an @expr{int@}. */ PIKEFUN mixed cast( string type ) flags ID_PROTECTED;
2687f92013-09-20Per Hedbor  {
008f902014-09-10Stephen R. van den Berg  if( type == literal_string_string ) { pop_stack(); if( Pike_fp->current_object->refs != 1 ) f_Buffer_get_copy( 0 ); else f_Buffer_get( 0 ); return; }
e950862014-08-29Stephen R. van den Berg 
008f902014-09-10Stephen R. van den Berg  if( type == literal_int_string ) { struct Buffer_struct *str = THIS; pop_stack(); if( Pike_fp->current_object->refs != 1 ) f_Buffer_get_copy( 0 ); else f_Buffer_get( 0 ); o_cast_to_int( ); return;
e950862014-08-29Stephen R. van den Berg  } pop_stack();
008f902014-09-10Stephen R. van den Berg  push_undefined();
e950862014-08-29Stephen R. van den Berg  }
13670c2015-05-25Martin Nilsson 
008f902014-09-10Stephen R. van den Berg  /*! @decl String.Buffer `+( string|String.Buffer what )
e950862014-08-29Stephen R. van den Berg  */
008f902014-09-10Stephen R. van den Berg  PIKEFUN object `+( string|Buffer what ) rawtype tFunc(tOr(tString, tObjIs_BUFFER), tObjIs_BUFFER);
e950862014-08-29Stephen R. van den Berg  {
008f902014-09-10Stephen R. van den Berg  struct Buffer_struct *str = THIS, *str2; struct object *res = fast_clone_object( Buffer_program ); str2 = OBJ2_BUFFER( res ); str2->initial = str->initial; if( str->str.s ) init_string_builder_copy (&str2->str, &str->str); if( (Pike_fp->current_object->flags & OBJECT_CLEAR_ON_EXIT) ) res->flags |= OBJECT_CLEAR_ON_EXIT; apply( res, "add", 1 ); RETURN res;
e950862014-08-29Stephen R. van den Berg  }
008f902014-09-10Stephen R. van den Berg  /*! @decl String.Buffer `+=( string|String.Buffer what ) */ PIKEFUN object `+=( string|Buffer what ) rawtype tFunc(tOr(tString, tObjIs_BUFFER), tObjIs_BUFFER);
e950862014-08-29Stephen R. van den Berg  {
008f902014-09-10Stephen R. van den Berg  f_Buffer_add( 1 ); REF_RETURN Pike_fp->current_object;
e950862014-08-29Stephen R. van den Berg  }
a8cfab2014-09-10Stephen R. van den Berg  /*! @decl int add(string|String.Buffer ... data)
e950862014-08-29Stephen R. van den Berg  *!
a8cfab2014-09-10Stephen R. van den Berg  *! Adds @[data] to the buffer.
e950862014-08-29Stephen R. van den Berg  *! *! @returns
008f902014-09-10Stephen R. van den Berg  *! Returns the size of the buffer. *! *! @note *! Pike 7.8 and earlier did not support adding @[String.Buffer]s *! directly.
e950862014-08-29Stephen R. van den Berg  */
a8cfab2014-09-10Stephen R. van den Berg  PIKEFUN int add( string|Buffer ... arg1 ) rawtype tFuncV(tNone, tOr(tString, tObjIs_BUFFER), tIntPos);
e950862014-08-29Stephen R. van den Berg  { struct Buffer_struct *str = THIS;
008f902014-09-10Stephen R. van den Berg  if (args) { int init_from_arg0 = 0, j; ptrdiff_t sum = 0; int shift = 0;
a8cfab2014-09-10Stephen R. van den Berg  for (j=0; j < args; j++) {
008f902014-09-10Stephen R. van den Berg  struct pike_string *a; if (TYPEOF(Pike_sp[j-args]) == PIKE_T_STRING) a = Pike_sp[j-args].u.string; else if ((TYPEOF(Pike_sp[j-args]) != PIKE_T_OBJECT) || (Pike_sp[j-args].u.object->prog != Buffer_program))
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("add", j+1, "string|String.Buffer");
008f902014-09-10Stephen R. van den Berg  else { a = OBJ2_BUFFER(Pike_sp[j-args].u.object)->str.s; if (!a) continue; } sum += a->len; shift |= a->size_shift; }
a8cfab2014-09-10Stephen R. van den Berg  shift |= str->str.known_shift; shift = shift & ~(shift >> 1); /* We know it will be a string that really is this wide. */ str->str.known_shift = shift;
e950862014-08-29Stephen R. van den Berg 
008f902014-09-10Stephen R. van den Berg  if (!str->str.s) {
a8cfab2014-09-10Stephen R. van den Berg  if (sum <= str->initial)
008f902014-09-10Stephen R. van den Berg  sum = str->initial; else
a8cfab2014-09-10Stephen R. van den Berg  sum <<= 1;
e950862014-08-29Stephen R. van den Berg 
008f902014-09-10Stephen R. van den Berg  init_string_builder_alloc(&str->str, sum, shift);
a8cfab2014-09-10Stephen R. van den Berg  } else string_build_mkspace(&str->str, sum, shift);
e950862014-08-29Stephen R. van den Berg 
a8cfab2014-09-10Stephen R. van den Berg  for(sum = str->str.s->len, j = 0; j<args; j++) {
008f902014-09-10Stephen R. van den Berg  struct pike_string *a; if (TYPEOF(Pike_sp[j-args]) == PIKE_T_STRING) a = Pike_sp[j-args].u.string; else { a = OBJ2_BUFFER(Pike_sp[j-args].u.object)->str.s; if (!a) continue; }
a8cfab2014-09-10Stephen R. van den Berg  pike_string_cpy(MKPCHARP_STR_OFF(str->str.s, sum), a); sum += a->len;
008f902014-09-10Stephen R. van den Berg  }
e950862014-08-29Stephen R. van den Berg 
a8cfab2014-09-10Stephen R. van den Berg  str->str.s->len = sum;
e950862014-08-29Stephen R. van den Berg  }
008f902014-09-10Stephen R. van den Berg  RETURN str->str.s ? str->str.s->len : 0;
e950862014-08-29Stephen R. van den Berg  }
008f902014-09-10Stephen R. van den Berg  /*! @decl void putchar(int c) *! Appends the character @[c] at the end of the string. */ PIKEFUN void putchar(int c) { struct Buffer_struct *str = THIS; if(!str->str.s) init_string_builder_alloc(&str->str, str->initial, 0); string_builder_putchar(&str->str, c); } /*! @decl int sprintf(strict_sprintf_format format, sprintf_args ... args) *! Appends the output from @[sprintf] at the end of the string. *! Returns the resulting size of the String.Buffer.
e950862014-08-29Stephen R. van den Berg  */
008f902014-09-10Stephen R. van den Berg  PIKEFUN int sprintf(mixed ... arguments) rawtype tFuncV(tAttr("strict_sprintf_format", tOr(tStr, tObj)), tAttr("sprintf_args", tMix), tStr);
e950862014-08-29Stephen R. van den Berg  {
008f902014-09-10Stephen R. van den Berg  // FIXME: Reset length on exception? struct Buffer_struct *str = THIS; if(!str->str.s) init_string_builder_alloc(&str->str, str->initial, 0);
558e912014-10-05Martin Nilsson  low_f_sprintf(args, &str->str);
008f902014-09-10Stephen R. van den Berg  RETURN str->str.s->len;
e950862014-08-29Stephen R. van den Berg  } /*! @decl string get_copy() *! *! Get the data from the buffer. Significantly slower than @[get], *! but does not clear the buffer. *! *! @seealso *! @[get()] */ PIKEFUN string get_copy() {
008f902014-09-10Stephen R. van den Berg  struct pike_string *str = THIS->str.s; ptrdiff_t len; if( str && (len = str->len) > 0 ) { char *d = (char *)str->str; switch( str->size_shift ) { case 0: str=make_shared_binary_string0((p_wchar0 *)d,len); break; case 1: str=make_shared_binary_string1((p_wchar1 *)d,len); break;
759c422015-10-17Martin Nilsson  case 2:
008f902014-09-10Stephen R. van den Berg  str=make_shared_binary_string2((p_wchar2 *)d,len); break;
e950862014-08-29Stephen R. van den Berg  }
008f902014-09-10Stephen R. van den Berg  if( Pike_fp->current_object->flags & OBJECT_CLEAR_ON_EXIT ) str->flags |= STRING_CLEAR_ON_EXIT; RETURN str;
e950862014-08-29Stephen R. van den Berg  }
008f902014-09-10Stephen R. van den Berg  push_empty_string(); return;
2687f92013-09-20Per Hedbor  }
e950862014-08-29Stephen R. van den Berg  /*! @decl string get() *! *! Get the data from the buffer. *! *! @note *! This will clear the data in the buffer *! *! @seealso *! @[get_copy()], @[clear()] */ PIKEFUN string get( ) {
008f902014-09-10Stephen R. van den Berg  struct Buffer_struct *str = THIS; pop_n_elems(args); if( str->str.s ) { struct pike_string *s = finish_string_builder( &str->str ); str->str.malloced = 0; str->str.s = NULL; if( Pike_fp->current_object->flags & OBJECT_CLEAR_ON_EXIT ) s->flags |= STRING_CLEAR_ON_EXIT; push_string(s); } else push_empty_string();
e950862014-08-29Stephen R. van den Berg  }
a3c4332001-06-20Per Hedbor 
008f902014-09-10Stephen R. van den Berg  /*! @decl void clear()
41730d2001-07-26Martin Nilsson  *!
008f902014-09-10Stephen R. van den Berg  *! Empty the buffer, and don't care about the old content.
41730d2001-07-26Martin Nilsson  *!
008f902014-09-10Stephen R. van den Berg  *! @note *! This function was not available in Pike 7.8 and earlier. *! *! @seealso *! @[get()]
41730d2001-07-26Martin Nilsson  */
008f902014-09-10Stephen R. van den Berg  PIKEFUN void clear()
a3c4332001-06-20Per Hedbor  {
008f902014-09-10Stephen R. van den Berg  /* FIXME: Support resetting the initial size? */
a3c4332001-06-20Per Hedbor  struct Buffer_struct *str = THIS;
008f902014-09-10Stephen R. van den Berg  if (str->str.s) { /* FIXME: There's also the alternative of using * reset_string_builder() here. */ free_string_builder(&str->str); str->str.s = NULL;
e950862014-08-29Stephen R. van den Berg  }
a3c4332001-06-20Per Hedbor  }
008f902014-09-10Stephen R. van den Berg  /*! @decl int _sizeof() *! *! Returns the size of the buffer.
18c2252003-04-10Martin Nilsson  */
008f902014-09-10Stephen R. van den Berg  PIKEFUN int _sizeof()
e950862014-08-29Stephen R. van den Berg  { struct Buffer_struct *str = THIS;
008f902014-09-10Stephen R. van den Berg  RETURN str->str.s ? str->str.s->len : 0;
edb0842001-07-11Martin Stjernholm  }
a3c4332001-06-20Per Hedbor  INIT { struct Buffer_struct *str = THIS;
f4ef462016-01-12Martin Nilsson  memset( str, 0, sizeof( *str ) );
a3c4332001-06-20Per Hedbor  } EXIT
8dcb7d2008-05-29Martin Stjernholm  gc_trivial;
a3c4332001-06-20Per Hedbor  { struct Buffer_struct *str = THIS;
008f902014-09-10Stephen R. van den Berg  if( str->str.s ) { if( Pike_fp->flags & OBJECT_CLEAR_ON_EXIT ) guaranteed_memset( str->str.s->str, 0, str->str.s->len ); free_string_builder( &str->str );
e950862014-08-29Stephen R. van den Berg  }
a3c4332001-06-20Per Hedbor  }
45e13d2008-06-23Martin Stjernholm  GC_RECURSE {
008f902014-09-10Stephen R. van den Berg  if (mc_count_bytes (Pike_fp->current_object) && THIS->str.s)
45e13d2008-06-23Martin Stjernholm  mc_counted_bytes += THIS->str.malloced; }
a3c4332001-06-20Per Hedbor }
41730d2001-07-26Martin Nilsson /*! @endclass
fed7de2001-06-28Henrik Grubbström (Grubba)  */ /*! @class Replace
c5e2a42004-04-30Martin Nilsson  *! *! This is a "compiled" version of the @[replace] function applied on *! a string, with more than one replace string. The replace strings *! are given to the create method as a @i{from@} and @i{to@} array *! and are then analyzed. The @expr{`()@} is then called with a *! string and the replace rules in the Replace object will be *! applied. The Replace object is used internally by the Pike *! optimizer and need not be used manually.
fed7de2001-06-28Henrik Grubbström (Grubba)  */ PIKECLASS multi_string_replace {
6f6d2b2006-03-11Henrik Grubbström (Grubba)  CVAR struct replace_many_context ctx;
4530562006-03-11Henrik Grubbström (Grubba)  /* NOTE: from and to are only kept for _encode()'s use. */
95489a2008-06-29Martin Nilsson  PIKEVAR array from flags ID_PROTECTED; PIKEVAR array to flags ID_PROTECTED;
fed7de2001-06-28Henrik Grubbström (Grubba) 
2687f92013-09-20Per Hedbor  PIKEFUN int _size_object() { int res = 0, i; if( THIS->ctx.v ) {
b9fd7f2013-09-23Per Hedbor  struct svalue tmp;
86d4ae2014-06-24Henrik Grubbström (Grubba)  SET_SVAL_TYPE(tmp, PIKE_T_STRING);
2687f92013-09-20Per Hedbor  for( i=0; i<THIS->ctx.num; i++ )
b9fd7f2013-09-23Per Hedbor  { res += sizeof(struct replace_many_tupel); tmp.u.string = THIS->ctx.v[i].ind; res += rec_size_svalue( &tmp, NULL ); tmp.u.string = THIS->ctx.v[i].val; res += rec_size_svalue( &tmp, NULL ); }
2687f92013-09-20Per Hedbor  } RETURN res; }
91829a2015-11-08Martin Nilsson  /*! @decl void create() *! @decl void create(mapping(string:string)) *! @decl void create(array(string) from, array(string)|string to)
18c2252003-04-10Martin Nilsson  */
6f6d2b2006-03-11Henrik Grubbström (Grubba)  PIKEFUN void create(array(string)|mapping(string:string)|void from_arg, array(string)|string|void to_arg)
fed7de2001-06-28Henrik Grubbström (Grubba)  {
a830442008-06-17Martin Stjernholm  if (THIS->from) { free_array(THIS->from); THIS->from = NULL; } if (THIS->to) { free_array(THIS->to); THIS->to = NULL; }
5ca4cf2008-06-19Martin Stjernholm  if (THIS->ctx.v)
a830442008-06-17Martin Stjernholm  free_replace_many_context(&THIS->ctx);
6f6d2b2006-03-11Henrik Grubbström (Grubba) 
e8c54a2016-02-24Henrik Grubbström (Grubba)  if (to_arg) { if (!from_arg || (TYPEOF(*from_arg) != T_ARRAY)) {
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("replace", 1, "array(string)|mapping(string:string)");
6f6d2b2006-03-11Henrik Grubbström (Grubba)  }
017b572011-10-28Henrik Grubbström (Grubba)  if (TYPEOF(*to_arg) == T_STRING) {
6f6d2b2006-03-11Henrik Grubbström (Grubba)  push_int(from_arg->u.array->size); stack_swap(); f_allocate(2);
e8c54a2016-02-24Henrik Grubbström (Grubba)  to_arg = Pike_sp - 1;
6f6d2b2006-03-11Henrik Grubbström (Grubba)  }
017b572011-10-28Henrik Grubbström (Grubba)  if (TYPEOF(*to_arg) != T_ARRAY) {
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("replace", 2, "array(string)|string");
6f6d2b2006-03-11Henrik Grubbström (Grubba)  } if (from_arg->u.array->size != to_arg->u.array->size) { Pike_error("Replace must have equal-sized from and to arrays.\n"); } add_ref(THIS->from = from_arg->u.array); add_ref(THIS->to = to_arg->u.array);
e8c54a2016-02-24Henrik Grubbström (Grubba)  } else if (from_arg) { if (TYPEOF(*from_arg) != T_MAPPING) Pike_error("Illegal arguments to create().\n"); THIS->from = mapping_indices(from_arg->u.mapping); THIS->to = mapping_values(from_arg->u.mapping); } else { return;
fed7de2001-06-28Henrik Grubbström (Grubba)  }
c5e2a42004-04-30Martin Nilsson 
6f6d2b2006-03-11Henrik Grubbström (Grubba)  if (!THIS->from->size) {
d5c9e22005-01-07Henrik Grubbström (Grubba)  /* Enter no-op mode. */ return; }
6f6d2b2006-03-11Henrik Grubbström (Grubba)  if( (THIS->from->type_field & ~BIT_STRING) && (array_fix_type_field(THIS->from) & ~BIT_STRING) )
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("replace", 1, "array(string)|mapping(string:string)");
fed7de2001-06-28Henrik Grubbström (Grubba) 
6f6d2b2006-03-11Henrik Grubbström (Grubba)  if( (THIS->to->type_field & ~BIT_STRING) && (array_fix_type_field(THIS->to) & ~BIT_STRING) )
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("replace", 2, "array(string)|string");
fed7de2001-06-28Henrik Grubbström (Grubba) 
6f6d2b2006-03-11Henrik Grubbström (Grubba)  compile_replace_many(&THIS->ctx, THIS->from, THIS->to, 1);
fed7de2001-06-28Henrik Grubbström (Grubba)  }
18c2252003-04-10Martin Nilsson  /*! @decl string `()(string str) */
fed7de2001-06-28Henrik Grubbström (Grubba)  PIKEFUN string `()(string str) {
6f6d2b2006-03-11Henrik Grubbström (Grubba)  if (!THIS->ctx.v) {
4530562006-03-11Henrik Grubbström (Grubba)  /* The result is already on the stack in the correct place... */ return;
fed7de2001-06-28Henrik Grubbström (Grubba)  }
6f6d2b2006-03-11Henrik Grubbström (Grubba)  RETURN execute_replace_many(&THIS->ctx, str);
fed7de2001-06-28Henrik Grubbström (Grubba)  }
6f6d2b2006-03-11Henrik Grubbström (Grubba)  /*! @decl array(array(string)) _encode()
18c2252003-04-10Martin Nilsson  */
6f6d2b2006-03-11Henrik Grubbström (Grubba)  PIKEFUN array(array(string)) _encode()
9f91572001-07-01Henrik Grubbström (Grubba)  {
6f6d2b2006-03-11Henrik Grubbström (Grubba)  if (THIS->from) { ref_push_array(THIS->from); } else { push_undefined();
9f91572001-07-01Henrik Grubbström (Grubba)  }
6f6d2b2006-03-11Henrik Grubbström (Grubba)  if (THIS->to) { ref_push_array(THIS->to); } else { push_undefined();
9f91572001-07-01Henrik Grubbström (Grubba)  } f_aggregate(2); }
18c2252003-04-10Martin Nilsson  /*! @decl void _decode(array(array(string)) encoded) */
9f91572001-07-01Henrik Grubbström (Grubba)  PIKEFUN void _decode(array(array(string)) encoded) { INT32 i;
91829a2015-11-08Martin Nilsson  for (i=0; i < encoded->size; i++)
9f91572001-07-01Henrik Grubbström (Grubba)  push_svalue(encoded->item + i); f_multi_string_replace_create(i); }
fed7de2001-06-28Henrik Grubbström (Grubba)  INIT {
f4ef462016-01-12Martin Nilsson  memset(&THIS->ctx, 0, sizeof(struct replace_many_context));
fed7de2001-06-28Henrik Grubbström (Grubba)  } EXIT
8dcb7d2008-05-29Martin Stjernholm  gc_trivial;
fed7de2001-06-28Henrik Grubbström (Grubba)  {
6f6d2b2006-03-11Henrik Grubbström (Grubba)  free_replace_many_context(&THIS->ctx);
fed7de2001-06-28Henrik Grubbström (Grubba)  } } /*! @endclass */
0c4ad02001-07-05Henrik Grubbström (Grubba) /*! @class SingleReplace
c5e2a42004-04-30Martin Nilsson  *! *! This is a "compiled" version of the @[replace] function applied on *! a string, with just one replace string. The replace strings are *! given to the create method as a @i{from@} and @i{tom@} string and *! are then analyzed. The @expr{`()@} is then called with a string *! and the replace rule in the Replace object will be applied. The *! Replace object is used internally by the Pike optimizer and need *! not be used manually.
0c4ad02001-07-05Henrik Grubbström (Grubba)  */ PIKECLASS single_string_replace { CVAR SearchMojt mojt;
95489a2008-06-29Martin Nilsson  PIKEVAR string del flags ID_PROTECTED|ID_PRIVATE; PIKEVAR string to flags ID_PROTECTED|ID_PRIVATE;
0c4ad02001-07-05Henrik Grubbström (Grubba) 
8910312008-06-23Martin Stjernholm  EXTRA {
4903e82016-01-30Martin Nilsson  PIKE_MAP_VARIABLE ("o", single_string_replace_storage_offset + OFFSETOF (single_string_replace_struct, mojt.container), tObj, T_OBJECT, ID_PROTECTED|ID_PRIVATE);
8910312008-06-23Martin Stjernholm  }
45e13d2008-06-23Martin Stjernholm  /*! @decl void create(string|void from, string|void to) *! *! @note *! May be called with either zero or two arguments. */ PIKEFUN void create(string|void del, string|void to)
0c4ad02001-07-05Henrik Grubbström (Grubba)  { if (THIS->del) { free_string(THIS->del); THIS->del = NULL; } if (THIS->to) { free_string(THIS->to); THIS->to = NULL; }
fe21442004-09-02Henrik Grubbström (Grubba)  if (!del) return;
0c4ad02001-07-05Henrik Grubbström (Grubba) 
fe21442004-09-02Henrik Grubbström (Grubba)  if (!to) {
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("replace", 2, "string");
0c4ad02001-07-05Henrik Grubbström (Grubba)  }
fe21442004-09-02Henrik Grubbström (Grubba)  if (del == to) {
0c4ad02001-07-05Henrik Grubbström (Grubba)  /* No-op... */ return; }
fe21442004-09-02Henrik Grubbström (Grubba)  copy_shared_string(THIS->del, del); copy_shared_string(THIS->to, to);
0c4ad02001-07-05Henrik Grubbström (Grubba)  if (del->len) {
50edc82001-07-13Henrik Grubbström (Grubba)  THIS->mojt = simple_compile_memsearcher(del);
0c4ad02001-07-05Henrik Grubbström (Grubba)  } } /*** replace function ***/ typedef char *(* replace_searchfunc)(void *,void *,size_t);
18c2252003-04-10Martin Nilsson  /*! @decl string `()(string str) */
0c4ad02001-07-05Henrik Grubbström (Grubba)  PIKEFUN string `()(string str) { int shift; struct pike_string *del = THIS->del; struct pike_string *to = THIS->to; struct pike_string *ret = NULL; if (!str->len || !del || !to) { /* The result is already on the stack in the correct place... */ return; } shift = MAXIMUM(str->size_shift, to->size_shift); if (!del->len) { int e, pos; ret = begin_wide_shared_string(str->len + to->len * (str->len-1), shift); low_set_index(ret, 0, index_shared_string(str, 0)); for(pos=e=1;e<str->len;e++) { pike_string_cpy(MKPCHARP_STR_OFF(ret,pos), to); pos+=to->len; low_set_index(ret,pos++,index_shared_string(str,e)); } } else { char *s, *end, *tmp; replace_searchfunc f = (replace_searchfunc)0; void *mojt_data = THIS->mojt.data; PCHARP r; end = str->str+(str->len<<str->size_shift); switch(str->size_shift) { case 0: f = (replace_searchfunc)THIS->mojt.vtab->func0; break; case 1: f = (replace_searchfunc)THIS->mojt.vtab->func1; break; case 2: f = (replace_searchfunc)THIS->mojt.vtab->func2; break; } if(del->len == to->len) { ret = begin_wide_shared_string(str->len, shift); } else { INT32 delimiters = 0; s = str->str; while((s = f(mojt_data, s, (end-s)>>str->size_shift))) { delimiters++; s += del->len << str->size_shift; } if (!delimiters) { /* The result is already on the stack in the correct place... */ return; } ret = begin_wide_shared_string(str->len + (to->len-del->len)*delimiters, shift); } s = str->str; r = MKPCHARP_STR(ret); while((tmp = f(mojt_data, s, (end-s)>>str->size_shift))) { #ifdef PIKE_DEBUG if(tmp + (del->len << str->size_shift) > end)
362d302004-03-08Martin Nilsson  Pike_fatal("SearchMojt found a match beyond end of string!\n");
0c4ad02001-07-05Henrik Grubbström (Grubba) #endif generic_memcpy(r,MKPCHARP(s,str->size_shift),(tmp-s)>>str->size_shift); INC_PCHARP(r,(tmp-s)>>str->size_shift); pike_string_cpy(r,to); INC_PCHARP(r,to->len); s=tmp+(del->len << str->size_shift); } generic_memcpy(r,MKPCHARP(s,str->size_shift),(end-s)>>str->size_shift); } RETURN end_shared_string(ret); }
18c2252003-04-10Martin Nilsson  /*! @decl array(string) _encode() */
0c4ad02001-07-05Henrik Grubbström (Grubba)  PIKEFUN array(string) _encode() { if (THIS->del) { ref_push_string(THIS->del); ref_push_string(THIS->to); f_aggregate(2); } else { push_int(0); } }
18c2252003-04-10Martin Nilsson  /*! @decl void _decode(array(string)|int(0..0) encoded) */
0c4ad02001-07-05Henrik Grubbström (Grubba)  PIKEFUN void _decode(array(string)|int(0..0) encoded_)
13670c2015-05-25Martin Nilsson  {
0c4ad02001-07-05Henrik Grubbström (Grubba)  INT32 i = 0;
017b572011-10-28Henrik Grubbström (Grubba)  if (TYPEOF(*encoded_) == PIKE_T_ARRAY) {
0c4ad02001-07-05Henrik Grubbström (Grubba)  struct array *encoded = encoded_->u.array;
91829a2015-11-08Martin Nilsson  for (i=0; i < encoded->size; i++)
0c4ad02001-07-05Henrik Grubbström (Grubba)  push_svalue(encoded->item + i); }
13670c2015-05-25Martin Nilsson 
0c4ad02001-07-05Henrik Grubbström (Grubba)  f_single_string_replace_create(i); } } /*! @endclass */
19f7672003-02-18Marcus Comstedt /*! @class Bootstring
3715ee2003-02-19Marcus Comstedt  *! *! This class implements the "Bootstring" string transcoder described in
abf31d2003-09-11Marcus Comstedt  *! @url{ftp://ftp.rfc-editor.org/in-notes/rfc3492.txt@}.
19f7672003-02-18Marcus Comstedt  */ PIKECLASS bootstring { CVAR INT_TYPE base, tmin, tmax, skew, damp; CVAR INT_TYPE initial_bias, initial_n; CVAR p_wchar2 delim;
95489a2008-06-29Martin Nilsson  PIKEVAR string digits flags ID_PROTECTED|ID_PRIVATE;
19f7672003-02-18Marcus Comstedt  static INT_TYPE bootstring_cp_to_digit(p_wchar2 ch) { ptrdiff_t digit = THIS->digits->len; PCHARP digits = MKPCHARP_STR( THIS->digits ); while (digit>=0) if (INDEX_PCHARP( digits, digit ) == ch) return digit; else --digit; return -1; } static INT_TYPE bootstring_adapt(INT_TYPE delta, INT_TYPE numpoints, int firsttime) { struct bootstring_struct *bs = THIS; INT_TYPE k = 0, b = bs->base; INT_TYPE a = b - bs->tmin; INT_TYPE limit = (a * bs->tmax) >> 1; if (firsttime) delta /= bs->damp; else delta >>= 1; delta += delta / numpoints; while (delta > limit) { delta /= a; k += b; } return k + (a + 1)*delta / (delta + bs->skew); }
3715ee2003-02-19Marcus Comstedt  /*! @decl string decode(string s) *! *! Decodes a Bootstring encoded string of "basic" code points back *! to the original string space. */
19f7672003-02-18Marcus Comstedt  PIKEFUN string decode(string s) { struct bootstring_struct *bs = THIS; INT_TYPE n = bs->initial_n; INT_TYPE i = 0; INT_TYPE bias = bs->initial_bias; ptrdiff_t pos, input_left; PCHARP input; struct string_builder output; init_string_builder( &output,0 ); input = MKPCHARP_STR( s ); input_left = s->len; for (pos = input_left-1; pos > 0; --pos) if (INDEX_PCHARP( input, pos ) == bs->delim) { string_builder_append( &output, input, pos ); INC_PCHARP( input, pos+1 ); input_left -= pos+1; break; } while (input_left > 0) { INT_TYPE oldi = i; INT_TYPE w = 1; INT_TYPE k; for (k=bs->base; ; k+=bs->base) { INT_TYPE digit, t; if (input_left < 1 || (digit = bootstring_cp_to_digit( EXTRACT_PCHARP( input ) )) < 0) { free_string_builder( &output ); Pike_error( "Invalid variable-length integer.\n" ); } INC_PCHARP( input, 1 ); --input_left; i += digit * w; /* fail on overflow... */ if (k <= bias + bs->tmin) t = bs->tmin; else if (k >= bias + bs->tmax) t = bs->tmax; else t = k - bias; if (digit < t) break; w *= (bs->base - t); } bias = bootstring_adapt( i - oldi, output.s->len+1, !oldi ); n += i / (output.s->len+1); i %= output.s->len+1; string_builder_putchar( &output, n ); if (i != output.s->len-1) switch (output.s->size_shift) { case 0: { p_wchar0 *s = STR0(output.s); INT_TYPE p = output.s->len; while (--p>i) s[p] = s[p-1];
bd67392015-10-14Martin Nilsson  s[p] = (p_wchar0) n;
19f7672003-02-18Marcus Comstedt  } break; case 1: { p_wchar1 *s = STR1(output.s); INT_TYPE p = output.s->len; while (--p>i) s[p] = s[p-1];
bd67392015-10-14Martin Nilsson  s[p] = (p_wchar1) n;
19f7672003-02-18Marcus Comstedt  } break; case 2: { p_wchar2 *s = STR2(output.s); INT_TYPE p = output.s->len; while (--p>i) s[p] = s[p-1];
bd67392015-10-14Martin Nilsson  s[p] = (p_wchar2) n;
19f7672003-02-18Marcus Comstedt  } break;
759c422015-10-17Martin Nilsson  }
19f7672003-02-18Marcus Comstedt  i++; } RETURN finish_string_builder( &output ); }
3715ee2003-02-19Marcus Comstedt  /*! @decl string encode(string s) *! *! Encodes a string using Bootstring encoding into a string constisting *! only of "basic" code points (< initial_n). */
19f7672003-02-18Marcus Comstedt  PIKEFUN string encode(string s) { struct bootstring_struct *bs = THIS; INT_TYPE n = bs->initial_n; INT_TYPE delta = 0; INT_TYPE bias = bs->initial_bias; INT_TYPE c, h, b = 0; ptrdiff_t pos, input_left; PCHARP input; struct string_builder output; init_string_builder( &output,0 ); input = MKPCHARP_STR( s ); input_left = s->len; for (pos=0; pos<input_left; pos++) if ((c = INDEX_PCHARP( input, pos )) < n) { string_builder_putchar( &output, c ); b++; } if ((h = b)) string_builder_putchar( &output, bs->delim ); while (h < input_left) { INT_TYPE m = -1; for (pos=0; pos<input_left; pos++) if ((c = INDEX_PCHARP( input, pos )) >= n && (m < 0 || c < m)) m = c; delta = delta + (m - n) * (h + 1); /* fail on overflow... */ n = m; for (pos=0; pos<input_left; pos++) if ((c = INDEX_PCHARP( input, pos )) < n) delta++; else if (c == n) { INT_TYPE k, q = delta; for (k=bs->base; ; k+=bs->base) { INT_TYPE t, bt; if (k <= bias + bs->tmin) t = bs->tmin; else if(k >= bias + bs->tmax) t = bs->tmax; else t = k-bias; if (q < t) break; bt = bs->base - t; string_builder_putchar( &output, index_shared_string( bs->digits, t + (q-t)%bt ) ); q = (q-t) / bt; } string_builder_putchar( &output, index_shared_string( bs->digits, q ) ); bias = bootstring_adapt( delta, h+1, h==b ); delta = 0; h++; } delta++; n++; } RETURN finish_string_builder( &output ); }
3715ee2003-02-19Marcus Comstedt  /*! @decl void create(int base, int tmin, int tmax, int skew, @ *! int damp, int initial_bias, int initial_n, @ *! int delim, string digits) *! *! Creates a Bootstring transcoder instance using the specified parameters. *! *! @param base *! The base used by the variable-length integers. *! @param tmin *! The minimum threshold digit value for the variable-length integers. *! Must be >=0 and <= tmax. *! @param tmax *! The maximum threshold digit value for the variable-length integers. *! Must be <= base-1. *! @param skew *! The skew term for the bias adapation. Must be >= 1. *! @param damp
1ae3d62003-02-19Henrik Grubbström (Grubba)  *! The damping factor for the bias adaption. Must be >= 2.
3715ee2003-02-19Marcus Comstedt  *! @param initial_bias *! The initial bias for the variable-length integer thresholding. *! initial_bias % base must be <= base - tmin. *! @param initial_n *! The first code point outside the "basic" set of code points. *! @param delim *! The "basic" code point used as the delimiter. *! @param digits *! The "basic" code points used as digits. The length of the string *! should be the same as the base parameter. */
19f7672003-02-18Marcus Comstedt  PIKEFUN void create( int base, int tmin, int tmax,
13670c2015-05-25Martin Nilsson  int skew, int damp,
19f7672003-02-18Marcus Comstedt  int initial_bias, int initial_n, int delim, string digits )
95489a2008-06-29Martin Nilsson  flags ID_PROTECTED;
19f7672003-02-18Marcus Comstedt  { struct bootstring_struct *bs = THIS;
3715ee2003-02-19Marcus Comstedt  if (base<2) Pike_error("Bogus base\n"); if (tmin<0 || tmax<tmin || base-1<tmax) Pike_error("Parameters violate 0 <= tmin <= tmax <= base-1\n"); if (skew < 1) Pike_error("Parameters violate skew >= 1\n"); if (damp < 2) Pike_error("Parameters violate damp >= 2\n"); if (initial_bias%base > base-tmin) Pike_error("Parameters violate initial_bias%%base <= base-tmin\n"); if (digits->len != base) Pike_error("Length of digits string does not match base.\n");
19f7672003-02-18Marcus Comstedt  bs->base = base; bs->tmin = tmin; bs->tmax = tmax; bs->skew = skew; bs->damp = damp; bs->initial_bias = initial_bias; bs->initial_n = initial_n; bs->delim = delim; if (bs->digits) { free_string( bs->digits ); bs->digits = NULL; } copy_shared_string( bs->digits, digits ); } } /*! @endclass */
fed7de2001-06-28Henrik Grubbström (Grubba) /*! @endmodule */
a3c4332001-06-20Per Hedbor 
da90692002-11-26Henrik Grubbström (Grubba) /*! @module System */ /*! @class Time *! *! The current time as a structure containing a sec and a usec *! member. */ PIKECLASS Time { CVAR int hard_update;
c329cb2011-02-15Martin Nilsson 
1fde1f2011-02-16Henrik Grubbström (Grubba)  /*! @decl int sec *! @decl int usec
da90692002-11-26Henrik Grubbström (Grubba)  *! *! The number of seconds and microseconds since the epoch and the *! last whole second, respectively. (See also @[predef::time()]) *!
1fde1f2011-02-16Henrik Grubbström (Grubba)  *! @note
da90692002-11-26Henrik Grubbström (Grubba)  *! Please note that these variables will continually update when *! they are requested, there is no need to create new Time() *! objects. */
1fde1f2011-02-16Henrik Grubbström (Grubba)  PIKEFUN int `sec() {
f010202011-11-16Tobias S. Josefowitz  struct timeval now;
1fde1f2011-02-16Henrik Grubbström (Grubba)  if( THIS->hard_update )
f010202011-11-16Tobias S. Josefowitz  ACCURATE_GETTIMEOFDAY( &now ); else INACCURATE_GETTIMEOFDAY( &now );
1fde1f2011-02-16Henrik Grubbström (Grubba) 
f010202011-11-16Tobias S. Josefowitz  RETURN now.tv_sec;
1fde1f2011-02-16Henrik Grubbström (Grubba)  } PIKEFUN int `usec() {
f010202011-11-16Tobias S. Josefowitz  struct timeval now;
1fde1f2011-02-16Henrik Grubbström (Grubba)  if( THIS->hard_update )
f010202011-11-16Tobias S. Josefowitz  ACCURATE_GETTIMEOFDAY( &now ); else INACCURATE_GETTIMEOFDAY( &now );
1fde1f2011-02-16Henrik Grubbström (Grubba) 
f010202011-11-16Tobias S. Josefowitz  RETURN now.tv_usec;
1fde1f2011-02-16Henrik Grubbström (Grubba)  } /*! @decl int usec_full
da90692002-11-26Henrik Grubbström (Grubba)  *! *! The number of microseconds since the epoch. Please note that
1fde1f2011-02-16Henrik Grubbström (Grubba)  *! pike needs to have been compiled with bignum support for this
da90692002-11-26Henrik Grubbström (Grubba)  *! variable to contain sensible values. */
1fde1f2011-02-16Henrik Grubbström (Grubba)  PIKEFUN int `usec_full()
da90692002-11-26Henrik Grubbström (Grubba)  {
f010202011-11-16Tobias S. Josefowitz  struct timeval now;
da90692002-11-26Henrik Grubbström (Grubba)  if( THIS->hard_update )
f010202011-11-16Tobias S. Josefowitz  ACCURATE_GETTIMEOFDAY( &now ); else INACCURATE_GETTIMEOFDAY( &now );
da90692002-11-26Henrik Grubbström (Grubba) 
f010202011-11-16Tobias S. Josefowitz  push_int( now.tv_sec );
da90692002-11-26Henrik Grubbström (Grubba)  push_int( 1000000 ); f_multiply( 2 );
f010202011-11-16Tobias S. Josefowitz  push_int( now.tv_usec );
da90692002-11-26Henrik Grubbström (Grubba)  f_add( 2 ); return; }
c329cb2011-02-15Martin Nilsson 
30c0612008-06-29Martin Stjernholm  /*! @decl protected void create( int fast );
da90692002-11-26Henrik Grubbström (Grubba)  *!
c834442008-05-29Martin Stjernholm  *! If @[fast] is true, do not request a new time from the system,
da90692002-11-26Henrik Grubbström (Grubba)  *! instead use the global current time variable. *! *! This will only work in callbacks, but can save significant amounts *! of CPU. */
c834442008-05-29Martin Stjernholm  PIKEFUN void create( int|zero|void fast )
1fde1f2011-02-16Henrik Grubbström (Grubba)  flags ID_PROTECTED;
da90692002-11-26Henrik Grubbström (Grubba)  { THIS->hard_update = !fast; } } /*! @endclass */ /*! @class Timer */ PIKECLASS Timer { CVAR struct timeval last_time; CVAR int hard_update;
13670c2015-05-25Martin Nilsson 
da90692002-11-26Henrik Grubbström (Grubba)  /*! @decl float peek() *! Return the time in seconds since the last time @[get] was called. */ PIKEFUN float peek( ) {
f010202011-11-16Tobias S. Josefowitz  struct timeval now;
da90692002-11-26Henrik Grubbström (Grubba)  FLOAT_TYPE res; if( THIS->hard_update )
f010202011-11-16Tobias S. Josefowitz  ACCURATE_GETTIMEOFDAY( &now ); else INACCURATE_GETTIMEOFDAY( &now ); res = now.tv_sec-THIS->last_time.tv_sec + (now.tv_usec-THIS->last_time.tv_usec)/(FLOAT_TYPE) 1000000.0;
da90692002-11-26Henrik Grubbström (Grubba)  RETURN res; } /*! @decl float get() *! Return the time in seconds since the last time get was called. *! The first time this method is called the time since the object *! was created is returned instead. */ PIKEFUN float get( ) { f_Timer_peek( 0 );
f010202011-11-16Tobias S. Josefowitz  INACCURATE_GETTIMEOFDAY(&THIS->last_time);
da90692002-11-26Henrik Grubbström (Grubba)  return; }
30c0612008-06-29Martin Stjernholm  /*! @decl protected void create( int|void fast )
da90692002-11-26Henrik Grubbström (Grubba)  *! Create a new timer object. The timer keeps track of relative time *! with sub-second precision.
13670c2015-05-25Martin Nilsson  *!
c834442008-05-29Martin Stjernholm  *! If @[fast] is specified, the timer will not do system calls to get
da90692002-11-26Henrik Grubbström (Grubba)  *! the current time but instead use the one maintained by pike. This
c834442008-05-29Martin Stjernholm  *! will result in faster but more or less inexact timekeeping. *! The pike maintained time is only updated when a @[Pike.Backend] *! object stops waiting and starts executing code.
da90692002-11-26Henrik Grubbström (Grubba)  */
c834442008-05-29Martin Stjernholm  PIKEFUN void create( int|zero|void fast )
13a9fc2011-02-16Henrik Grubbström (Grubba)  flags ID_PROTECTED;
da90692002-11-26Henrik Grubbström (Grubba)  { THIS->hard_update = !fast; if( THIS->hard_update )
f010202011-11-16Tobias S. Josefowitz  ACCURATE_GETTIMEOFDAY( &THIS->last_time ); else INACCURATE_GETTIMEOFDAY( &THIS->last_time );
da90692002-11-26Henrik Grubbström (Grubba)  } } /*! @endclass */ /*! @endmodule */
8bef1b2001-09-27Fredrik Hübinette (Hubbe) 
897e622013-11-19Henrik Grubbström (Grubba) /*! @module Builtin */ /*! @class automap_marker *! *! This is an internal class used by @[__automap__()]. *! *! It may show up during module dumping or in backtraces *! and the like. *! *! It should in normal circumstances never be used directly. *! *! @seealso *! @[__automap__()], @[map()] */
8bef1b2001-09-27Fredrik Hübinette (Hubbe) PIKECLASS automap_marker { PIKEVAR array arg; PIKEVAR int depth;
897e622013-11-19Henrik Grubbström (Grubba)  /*! @decl void create(array arr, int depth) *! *! @param arr *! Array that @[__automap__()] is to loop over. *! *! @param depth *! Recursion depth of @[arr] where the loop will be. */
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  PIKEFUN void create(array a, int d) { if(THIS->arg) free_array(THIS->arg); add_ref(THIS->arg=a); THIS->depth=d; } PIKEFUN string _sprintf(int mode, mapping flags) { pop_n_elems(args);
e6dbc22002-11-29Marcus Comstedt  if (mode != 'O') { push_undefined (); return; }
75367d2014-08-22Arne Goedeke  push_static_text("%O%*'[*]'n");
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  if(THIS->arg) ref_push_array(THIS->arg); else push_int(0); push_int(THIS->depth*3); f_sprintf(3); } }
897e622013-11-19Henrik Grubbström (Grubba) /*! @endclass */ /*! @endmodule */
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  static void low_automap(int d, int depth, struct svalue *fun, struct svalue *real_args, INT32 args) { INT32 x,e,tmp,size=0x7fffffff; struct svalue *tmpargs=Pike_sp - args; struct array *ret;
2523ce2003-04-28Martin Stjernholm  TYPE_FIELD types;
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  for(e=0;e<args;e++) {
017b572011-10-28Henrik Grubbström (Grubba)  if(TYPEOF(real_args[e]) == T_OBJECT &&
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  real_args[e].u.object->prog == automap_marker_program && OBJ2_AUTOMAP_MARKER(real_args[e].u.object)->depth >= d) {
017b572011-10-28Henrik Grubbström (Grubba)  if(TYPEOF(tmpargs[e]) != T_ARRAY)
a241e02001-09-27Fredrik Hübinette (Hubbe)  index_error("__automap__", Pike_sp-args, args, tmpargs, NULL, "Automap on non-array.\n");
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  tmp=tmpargs[e].u.array->size; if(tmp < size) size=tmp; } }
897e622013-11-19Henrik Grubbström (Grubba)  if(size == 0x7fffffff) Pike_error("No automap markers found in __automap__\n");
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  push_array(ret=allocate_array(size));
2523ce2003-04-28Martin Stjernholm  types = 0;
8bef1b2001-09-27Fredrik Hübinette (Hubbe) 
cacbac2016-04-14Martin Karlgren  struct pike_frame *frame; if (d == depth) { frame = frame_init(); frame_setup_from_svalue(frame, fun); } else { frame = NULL; }
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  for(x=0;x<size;x++) { for(e=0;e<args;e++) {
017b572011-10-28Henrik Grubbström (Grubba)  if(TYPEOF(real_args[e]) == T_OBJECT &&
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  real_args[e].u.object->prog == automap_marker_program && OBJ2_AUTOMAP_MARKER(real_args[e].u.object)->depth >= d) { #ifdef PIKE_DEBUG if(x >= tmpargs[e].u.array->size)
5aad932002-08-15Marcus Comstedt  Pike_fatal("low_automap failed to determine size!\n");
8bef1b2001-09-27Fredrik Hübinette (Hubbe) #endif push_svalue(ITEM(tmpargs[e].u.array)+x); }else{ push_svalue(tmpargs+e); } }
13670c2015-05-25Martin Nilsson 
cacbac2016-04-14Martin Karlgren  if(frame != NULL) { frame_prepare (frame, args); frame_execute (frame); } else {
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  low_automap(d+1,depth,fun,real_args,args);
cacbac2016-04-14Martin Karlgren  }
2523ce2003-04-28Martin Stjernholm  stack_pop_to_no_free (ITEM(ret) + x);
017b572011-10-28Henrik Grubbström (Grubba)  types |= 1 << TYPEOF(ITEM(ret)[x]);
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  }
cacbac2016-04-14Martin Karlgren  if (frame != NULL) { frame_pop (frame); }
2523ce2003-04-28Martin Stjernholm  ret->type_field = types;
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  stack_unlink(args); }
897e622013-11-19Henrik Grubbström (Grubba) /*! @decl array __automap__(function fun, mixed ... args) *! *! Automap execution function. *! *! @param fun *! Function to call for each of the mapped arguments. *! *! @param args *! Arguments for @[fun]. Either *! @mixed *! @type Builtin.automap_marker *! Wrapper for an array to loop over. All of the *! arrays will be looped over in parallel. *! @type mixed *! All other arguments will be held constant during *! the automap, and sent as is to @[fun]. *! @endmixed *! *! @note *! This function is used by the compiler to implement the *! automap syntax, and should in normal circumstances never *! be used directly. *! *! It may however show up during module dumping and in *! backtraces. *! *! @note *! It is an error not to have any @[Builtin.automap_marker]s *! in @[args]. *! *! @seealso *! @[Builtin.automap_marker], @[map()] */
8bef1b2001-09-27Fredrik Hübinette (Hubbe) PIKEFUN array __automap__(mixed fun, mixed ... tmpargs) efun; { int e,depth=-1; check_stack(args); for(e=0;e<args-1;e++) {
017b572011-10-28Henrik Grubbström (Grubba)  if(TYPEOF(tmpargs[e]) == T_OBJECT &&
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  tmpargs[e].u.object->prog == automap_marker_program) { int tmp=OBJ2_AUTOMAP_MARKER(tmpargs[e].u.object)->depth; if(tmp > depth) depth=tmp; ref_push_array(OBJ2_AUTOMAP_MARKER(tmpargs[e].u.object)->arg); }else{ push_svalue(tmpargs+e); } } check_stack(depth * (args+1)); low_automap(1,depth,fun,tmpargs,args-1); stack_unlink(args); }
e796b22011-01-07Henrik Grubbström (Grubba) /*! @module Builtin
dbe50e2009-11-09Henrik Grubbström (Grubba)  */
6f321c2011-01-20Henrik Grubbström (Grubba) /*! @class Setter *! *! Internal class for implementing setters.
35ce662013-11-16Henrik Grubbström (Grubba)  *! *! This class is used by @[_get_setter()]. *! *! @seealso *! @[_get_setter()]
6f321c2011-01-20Henrik Grubbström (Grubba)  */ PIKECLASS Setter { PIKEVAR object o flags ID_PROTECTED|ID_PRIVATE|ID_LOCAL; CVAR int f;
35ce662013-11-16Henrik Grubbström (Grubba)  /*! @decl void `()(mixed val) *! *! Set the variable for the setter to @[val]. *! *! This is the function returned by @[_get_setter()]. */
6f321c2011-01-20Henrik Grubbström (Grubba)  PIKEFUN void `()(mixed val) flags ID_PROTECTED; { if (!THIS->o) { Pike_error("Uninitialized Setter!\n"); } object_low_set_index(THIS->o, THIS->f, Pike_sp-1); }
91829a2015-11-08Martin Nilsson 
6f321c2011-01-20Henrik Grubbström (Grubba)  PIKEFUN string _sprintf(int c, mapping|void opts) flags ID_PROTECTED; { struct program *prog; if (!THIS->o) {
75367d2014-08-22Arne Goedeke  push_static_text("Setter()");
6f321c2011-01-20Henrik Grubbström (Grubba)  } else if ((prog = THIS->o->prog)) {
75367d2014-08-22Arne Goedeke  push_static_text("%O->`%s=");
6f321c2011-01-20Henrik Grubbström (Grubba)  ref_push_object(THIS->o); ref_push_string(ID_FROM_INT(prog, THIS->f)->name); f_sprintf(3); } else {
75367d2014-08-22Arne Goedeke  push_static_text("Setter(destructed object)");
6f321c2011-01-20Henrik Grubbström (Grubba)  } stack_pop_n_elems_keep_top(args); } }
35ce662013-11-16Henrik Grubbström (Grubba) /*! @endclass */
6f321c2011-01-20Henrik Grubbström (Grubba) PMOD_EXPORT struct object *get_setter(struct object *o, int f) { struct object *res = clone_object(Setter_program, 0); struct Setter_struct *setter = OBJ2_SETTER(res); add_ref(setter->o = o); setter->f = f; return res; }
35ce662013-11-16Henrik Grubbström (Grubba) /*! @decl function(mixed_void) _get_setter(object o, string varname)
6f321c2011-01-20Henrik Grubbström (Grubba)  *!
35ce662013-11-16Henrik Grubbström (Grubba)  *! Get a setter for the variable named @[varname] in object @[o]. *! *! @returns *! Returns a @[Setter()->`()()] for the variable if it exists, *! and @expr{UNDEFINED@} otherwise.
6f321c2011-01-20Henrik Grubbström (Grubba)  *! *! @seealso *! @[object_variablep()] */ PIKEFUN function(mixed:void) _get_setter(object o, string s) { struct program *p;
4dbbd22011-01-21Henrik Grubbström (Grubba)  struct inherit *inh;
6f321c2011-01-20Henrik Grubbström (Grubba)  int f; if (!(p = o->prog)) { Pike_error("Indexing a destructed object.\n"); }
017b572011-10-28Henrik Grubbström (Grubba)  inh = p->inherits + SUBTYPEOF(Pike_sp[-args]);
4dbbd22011-01-21Henrik Grubbström (Grubba)  p = inh->prog;
6f321c2011-01-20Henrik Grubbström (Grubba)  f = find_shared_string_identifier(s, p); if ((f >= 0) && IDENTIFIER_IS_VARIABLE(ID_FROM_INT(p, f)->identifier_flags)) {
4dbbd22011-01-21Henrik Grubbström (Grubba)  f += inh->identifier_level;
6f321c2011-01-20Henrik Grubbström (Grubba)  push_function(get_setter(o, f), f_Setter_cq__backtick_28_29_fun_num); } else { push_undefined(); } stack_pop_n_elems_keep_top(args); }
83045c2011-03-05Martin Stjernholm /*! @class Null
dbe50e2009-11-09Henrik Grubbström (Grubba)  *!
e796b22011-01-07Henrik Grubbström (Grubba)  *! This class is used to implement the low-level aspects of @[Val.Null].
dbe50e2009-11-09Henrik Grubbström (Grubba)  *! *! @note
e796b22011-01-07Henrik Grubbström (Grubba)  *! This class should typically not be used directly. Use *! @[Val.Null] instead. *!
d038542011-01-17Henrik Grubbström (Grubba)  *! @note *! This class was previously available as @[Sql.Null]. Any such use *! should be replaced with @[Val.Null]. *!
e796b22011-01-07Henrik Grubbström (Grubba)  *! @deprecated Val.Null
dbe50e2009-11-09Henrik Grubbström (Grubba)  *! *! @seealso
e796b22011-01-07Henrik Grubbström (Grubba)  *! @[Val.Null], @[Val.null]
dbe50e2009-11-09Henrik Grubbström (Grubba)  */
83045c2011-03-05Martin Stjernholm PIKECLASS Null
dbe50e2009-11-09Henrik Grubbström (Grubba) { EXTRA {
83045c2011-03-05Martin Stjernholm  /*! @decl constant is_val_null = 1 *! *! Nonzero recognition constant. */ add_integer_constant("is_val_null", 1, 0);
dbe50e2009-11-09Henrik Grubbström (Grubba)  /*! @decl constant is_sql_null = 1 *! *! SQL Null marker.
83045c2011-03-05Martin Stjernholm  *! *! @deprecated is_val_null
dbe50e2009-11-09Henrik Grubbström (Grubba)  */ add_integer_constant("is_sql_null", 1, 0); } PIKEFUN int `!() flags ID_PROTECTED; { RETURN 1; } PIKEFUN string _sprintf(int fmt, mixed ... extras) flags ID_PROTECTED; { pop_n_elems(args); if (fmt == 'O') {
75367d2014-08-22Arne Goedeke  push_static_text("Val.null");
dbe50e2009-11-09Henrik Grubbström (Grubba)  } else { push_undefined(); } }
77865b2009-11-11Henrik Grubbström (Grubba)  PIKEFUN int __hash()
dbe50e2009-11-09Henrik Grubbström (Grubba)  flags ID_PROTECTED; {
91829a2015-11-08Martin Nilsson  RETURN 17;
dbe50e2009-11-09Henrik Grubbström (Grubba)  }
13670c2015-05-25Martin Nilsson 
dbe50e2009-11-09Henrik Grubbström (Grubba)  PIKEFUN int `==(mixed other) flags ID_PROTECTED; {
91829a2015-11-08Martin Nilsson  if (TYPEOF(*other) != T_OBJECT) RETURN 0;
ace6c92011-03-15Martin Stjernholm  /* Look for the is_val_null constant directly in the program of * other, without going through its `[]. When this is called in a * codec, other can be a completely arbitrary object which may not * have a `[] that works in that context. */ push_int (0); ref_push_program (other->u.object->prog);
83045c2011-03-05Martin Stjernholm  push_constant_text("is_val_null");
ace6c92011-03-15Martin Stjernholm  if (program_index_no_free (Pike_sp - 3, Pike_sp - 2, Pike_sp - 1) &&
017b572011-10-28Henrik Grubbström (Grubba)  TYPEOF(Pike_sp[-3]) == T_INT && Pike_sp[-3].u.integer) {
ace6c92011-03-15Martin Stjernholm  pop_n_elems (4); push_int (1); } else { pop_n_elems (4); push_int (0); }
dbe50e2009-11-09Henrik Grubbström (Grubba)  }
dce09c2010-05-28Martin Stjernholm  /*! @decl string encode_json() *! *! Defined for use with @[Standards.JSON.encode], so that it *! formats NULL as @expr{null@}. */
b670b42010-05-28Martin Stjernholm  PIKEFUN string encode_json(...)
dce09c2010-05-28Martin Stjernholm  {
dffabf2014-02-24Per Hedbor  pop_n_elems(args);
dce09c2010-05-28Martin Stjernholm  push_constant_text ("null"); }
dbe50e2009-11-09Henrik Grubbström (Grubba) } /*! @endclass */
3dce7d2013-04-30Markus Ottensmann PMOD_EXPORT PIKEFUN int levenshtein_distance(string a, string b) { int i, j, n, *lev_i, *lev_p; /* Simple cases: strings are equal or one of them is empty: */ if (a == b) RETURN 0; if (a->len == 0) RETURN b->len; if (b->len == 0) RETURN a->len; /* Return -1 if any of the strings is wider than 8 bits: */ if (a->size_shift || b->size_shift) RETURN -1; /* Allocate two rows on the stack: */ n = b->len+1; lev_i = alloca(n*sizeof(int)); lev_p = alloca(n*sizeof(int)); if (!lev_i || !lev_p) RETURN -1; /* Initialise the first row */ for (j = 0; j < n; j++) lev_i[j] = j; for (i = 0; i < a->len; i++) { /* lev_p = row for i, lev_i = row for i+1: */ memcpy(lev_p, lev_i, n*sizeof(int)); lev_i[0] = i + 1; for (j = 0; j < b->len; j++) { int cost = (a->str[i] == b->str[j]) ? 0 : 1; int test, min_val = lev_i[j]+1; if ((test = lev_p[j+1]+1) < min_val) min_val = test; if ((test = lev_p[j]+cost) < min_val) min_val = test; lev_i[j+1] = min_val; } } RETURN lev_i[b->len]; }
dbe50e2009-11-09Henrik Grubbström (Grubba) /*! @endmodule */
1031362011-01-21Henrik Grubbström (Grubba) /*! @module Serializer */ /*! @class Serializable *! *! The base class for serializable objects. *! *! Inherit this class in classes that need to be serializable. *! *! @seealso *! @[Serializer.serialize()], @[Serializer.deserialize()] */ PIKECLASS Serializable {
fe7f0e2014-02-17Henrik Grubbström (Grubba)  /* Loop over all true variables, and call fun_num in the current object. */
6220962011-01-28Henrik Grubbström (Grubba)  static void low_serialize(int i, struct svalue *fun, int use_setter, int fun_num)
1031362011-01-21Henrik Grubbström (Grubba)  { struct inherit *inh; struct program *p = Pike_fp->current_object->prog; struct svalue *save_sp = Pike_sp; inh = p->inherits + i; p = inh->prog; for (i = 0; i < p->num_identifier_references; i++) { struct reference *ref = PTR_FROM_INT(p, i); struct identifier *id; if ((ref->id_flags & ID_HIDDEN) || ((ref->id_flags & (ID_PRIVATE|ID_INHERITED)) == (ID_PRIVATE|ID_INHERITED))) { continue; } id = ID_FROM_PTR(p, ref);
fe7f0e2014-02-17Henrik Grubbström (Grubba)  if (!IDENTIFIER_IS_VARIABLE(id->identifier_flags) || (id->run_time_type == PIKE_T_GET_SET)) {
1031362011-01-21Henrik Grubbström (Grubba)  continue; }
6220962011-01-28Henrik Grubbström (Grubba)  push_svalue(fun);
1031362011-01-21Henrik Grubbström (Grubba)  if (use_setter) { push_function(get_setter(Pike_fp->current_object, i + inh->identifier_level), f_Setter_cq__backtick_28_29_fun_num); } else { low_object_index_no_free(Pike_sp, Pike_fp->current_object, i + inh->identifier_level); Pike_sp++; }
9cded82011-02-04Henrik Grubbström (Grubba)  ref_push_string(id->name); ref_push_type_value(id->type);
6220962011-01-28Henrik Grubbström (Grubba)  apply_current(fun_num, 4);
1031362011-01-21Henrik Grubbström (Grubba)  pop_stack(); } if (Pike_sp != save_sp) { /* Not likely, but... */ pop_n_elems(Pike_sp - save_sp); } }
d6ec7c2011-01-29Henrik Grubbström (Grubba)  /*! @decl protected void _serialize_variable( @
9cded82011-02-04Henrik Grubbström (Grubba)  *! function(mixed, string, type:void) serializer, @ *! mixed value, @
d6ec7c2011-01-29Henrik Grubbström (Grubba)  *! string symbol, @
9cded82011-02-04Henrik Grubbström (Grubba)  *! type symbol_type)
6220962011-01-28Henrik Grubbström (Grubba)  *! *! Default serialization function for variables. *! *! @param serializer *! Function to be called in turn. *!
9cded82011-02-04Henrik Grubbström (Grubba)  *! @param value *! Value of the variable. *!
6220962011-01-28Henrik Grubbström (Grubba)  *! @param symbol *! Variable name. *! *! @param symbol_type *! Type of the variable. *! *! This function is typically called from @[_serialize()], and just does *! @code
9cded82011-02-04Henrik Grubbström (Grubba)  *! serializer(value, symbol, symbol_type);
6220962011-01-28Henrik Grubbström (Grubba)  *! @endcode *! *! It is provided for overloading for eg filtering or validation purposes. *! *! @seealso *! @[_serialize()], @[_deserialize_variable()] */
9cded82011-02-04Henrik Grubbström (Grubba)  PIKEFUN void _serialize_variable(function(mixed, string, type:void) serializer, mixed value, string symbol, type symbol_type)
6220962011-01-28Henrik Grubbström (Grubba)  flags ID_PROTECTED;
9cded82011-02-04Henrik Grubbström (Grubba)  rawtype tFunc(tFunc(tMix tStr tType(tMix), tVoid) tMix tStr tType(tMix), tVoid);
6220962011-01-28Henrik Grubbström (Grubba)  { f_call_function(args); }
d6ec7c2011-01-29Henrik Grubbström (Grubba)  /*! @decl protected void _serialize(object o, @
9cded82011-02-04Henrik Grubbström (Grubba)  *! function(mixed, string, type:void) serializer)
1031362011-01-21Henrik Grubbström (Grubba)  *! *! Dispatch function for serialization. *! *! @param o *! Object to serialize. Always a context of the current object. *! *! @param serializer
6220962011-01-28Henrik Grubbström (Grubba)  *! Function to typically be called once for every variable
1031362011-01-21Henrik Grubbström (Grubba)  *! in the inheriting class. *!
6220962011-01-28Henrik Grubbström (Grubba)  *! This function calls @[_serialize_variable()] once
aad25e2013-11-16Henrik Grubbström (Grubba)  *! for every variable in the inheriting class, which *! in turn will call @[serializer] with the arguments: *! @dl *! @item Argument 1 *! The value of the variable. *! @item Argument 2 *! The name of the variable. *! @item Argument 3 *! The declared type of the variable. *! @enddl
1031362011-01-21Henrik Grubbström (Grubba)  *! *! @note *! The symbols will be listed in the order they were defined *! in the class. *! *! @note *! This function is typically called via @[Serializer.serialize()].
aad25e2013-11-16Henrik Grubbström (Grubba)  *! *! @seealso *! @[Serializer.serialize()], @[_serialize_variable()], *! @[_deserialize()]
1031362011-01-21Henrik Grubbström (Grubba)  */ PIKEFUN void _serialize(object o,
9cded82011-02-04Henrik Grubbström (Grubba)  function(mixed, string, type:void) serializer)
1031362011-01-21Henrik Grubbström (Grubba)  flags ID_PROTECTED;
9cded82011-02-04Henrik Grubbström (Grubba)  rawtype tFunc(tObj tFunc(tMix tStr tType(tMix), tVoid), tVoid);
1031362011-01-21Henrik Grubbström (Grubba)  { if (o != Pike_fp->current_object) {
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("_serialize", 1, "this");
1031362011-01-21Henrik Grubbström (Grubba)  }
017b572011-10-28Henrik Grubbström (Grubba)  low_serialize(SUBTYPEOF(Pike_sp[-args]), serializer, 0,
6220962011-01-28Henrik Grubbström (Grubba)  f_Serializable_cq__serialize_variable_fun_num);
1031362011-01-21Henrik Grubbström (Grubba)  }
80095c2011-01-28Henrik Grubbström (Grubba)  static void *find_program_from_object_type_cb(struct pike_type *t) { struct program *p; if ((t->type != PIKE_T_OBJECT) || !t->cdr) return NULL; p = id_to_program(CDR_TO_INT(t)); if (!p || (p->flags & PROGRAM_NEEDS_PARENT) || (low_find_lfun(p, LFUN__DESERIALIZE) == -1)) return NULL; return p; } DEFAULT_CMOD_STORAGE void f_deserialize(INT32 args);
d6ec7c2011-01-29Henrik Grubbström (Grubba)  /*! @decl protected void _deserialize_variable( @
9cded82011-02-04Henrik Grubbström (Grubba)  *! function(function(mixed:void), @ *! string, type: void) deserializer, @ *! function(mixed:void) setter, @
d6ec7c2011-01-29Henrik Grubbström (Grubba)  *! string symbol, @
9cded82011-02-04Henrik Grubbström (Grubba)  *! type symbol_type)
6220962011-01-28Henrik Grubbström (Grubba)  *! *! Default deserialization function for variables. *! *! @param deserializer *! Function to be called in turn. *!
9cded82011-02-04Henrik Grubbström (Grubba)  *! @param setter *! Function that sets the value of the variable. *!
6220962011-01-28Henrik Grubbström (Grubba)  *! @param symbol *! Variable name. *! *! @param symbol_type *! Type of the variable. *!
80095c2011-01-28Henrik Grubbström (Grubba)  *! This function is typically called from @[_deserialize()], and does *! something like:
6220962011-01-28Henrik Grubbström (Grubba)  *! @code
80095c2011-01-28Henrik Grubbström (Grubba)  *! if (object_typep(symbol_type)) { *! program p = program_from_type(symbol_type); *! if (p && !needs_parent(p) && is_deserializable(p)) { *! object value = p(); *! setter(value); *! Serializer.deserialize(value, deserializer); *! return; *! } *! }
9cded82011-02-04Henrik Grubbström (Grubba)  *! deserializer(setter, symbol, symbol_type);
6220962011-01-28Henrik Grubbström (Grubba)  *! @endcode *!
80095c2011-01-28Henrik Grubbström (Grubba)  *! @note *! The above takes care of the most common cases, but *! @ul *! @item *! Does not support anonymous object types. *! @item *! Does not support objects needing a parent. *! @item *! Does not support non-serializable objects. *! @item *! Selects one of the object types in case of a complex *! @[symbol_type]. The selected type is NOT deterministic *! in case there are multiple choices that satisfy the above. *! @item *! Is likely to throw errors if @tt{p()@} requires arguments. *! @endul *! *! These issues can all be solved by overloading this function.
6220962011-01-28Henrik Grubbström (Grubba)  *! *! @seealso
aad25e2013-11-16Henrik Grubbström (Grubba)  *! @[_deserialize()], @[_serialize_variable()], @[Builtin.Setter]
6220962011-01-28Henrik Grubbström (Grubba)  */
9cded82011-02-04Henrik Grubbström (Grubba)  PIKEFUN void _deserialize_variable(function(function(mixed:void), string, type: void) deserializer, function(mixed:void) setter, string symbol, type symbol_type)
6220962011-01-28Henrik Grubbström (Grubba)  flags ID_PROTECTED;
9cded82011-02-04Henrik Grubbström (Grubba)  rawtype tFunc(tFunc(tFunc(tMix, tVoid) tStr tType(tMix), tVoid) tFunc(tMix, tVoid) tStr tType(tMix), tVoid);
6220962011-01-28Henrik Grubbström (Grubba)  {
80095c2011-01-28Henrik Grubbström (Grubba)  struct program *p = find_type(symbol_type, find_program_from_object_type_cb); if (p) { struct object *o = clone_object(p, 0); push_object(o); /* Protection against errors and arg to deserialize. */ ref_push_object(o); apply_svalue(setter, 1); pop_stack(); push_svalue(deserializer); f_deserialize(2); return; }
6220962011-01-28Henrik Grubbström (Grubba)  f_call_function(args); }
d6ec7c2011-01-29Henrik Grubbström (Grubba)  /*! @decl protected void _deserialize(object o, @
9cded82011-02-04Henrik Grubbström (Grubba)  *! function(function(mixed:void), @ *! string, type: void) deserializer)
1031362011-01-21Henrik Grubbström (Grubba)  *! *! Dispatch function for deserialization. *! *! @param o *! Object to serialize. Always a context of the current object. *! *! @param deserializer
6220962011-01-28Henrik Grubbström (Grubba)  *! Function to typically be called once for every variable
1031362011-01-21Henrik Grubbström (Grubba)  *! in the inheriting class. *!
6220962011-01-28Henrik Grubbström (Grubba)  *! This function calls @[_deserialize_variable()] once
aad25e2013-11-16Henrik Grubbström (Grubba)  *! for every variable in the inheriting class, which *! in turn will call @[deserializer] with the arguments: *! @dl *! @item Argument 1 *! The setter for the variable. *! @item Argument 2 *! The name of the variable. *! @item Argument 3 *! The declared type of the variable. *! @enddl
1031362011-01-21Henrik Grubbström (Grubba)  *! *! @note *! The symbols will be listed in the order they were defined *! in the class. *! *! @note *! This function is typically called via @[Serializer.deserialize()].
aad25e2013-11-16Henrik Grubbström (Grubba)  *! *! @seealso *! @[Serializer.deserialize()], @[_deserialize_variable()], *! @[_serialize()], @[Builtin.Setter]
1031362011-01-21Henrik Grubbström (Grubba)  */ PIKEFUN void _deserialize(object o,
9cded82011-02-04Henrik Grubbström (Grubba)  function(function(mixed:void), string, type: void) deserializer)
1031362011-01-21Henrik Grubbström (Grubba)  flags ID_PROTECTED;
9cded82011-02-04Henrik Grubbström (Grubba)  rawtype tFunc(tObj tFunc(tFunc(tMix, tVoid) tStr tType(tMix), tVoid), tVoid);
1031362011-01-21Henrik Grubbström (Grubba)  { if (o != Pike_fp->current_object) {
f982742016-01-26Martin Nilsson  SIMPLE_ARG_TYPE_ERROR("_serialize", 1, "this");
1031362011-01-21Henrik Grubbström (Grubba)  }
017b572011-10-28Henrik Grubbström (Grubba)  low_serialize(SUBTYPEOF(Pike_sp[-args]), deserializer, 1,
6220962011-01-28Henrik Grubbström (Grubba)  f_Serializable_cq__deserialize_variable_fun_num);
1031362011-01-21Henrik Grubbström (Grubba)  } } /*! @endclass */ /*! @decl void serialize(object o, @
9cded82011-02-04Henrik Grubbström (Grubba)  *! function(mixed, string, type:void) serializer)
1031362011-01-21Henrik Grubbström (Grubba)  *!
0d47c72011-01-22Henrik Grubbström (Grubba)  *! Call @[lfun::_serialize()] in @[o].
1031362011-01-21Henrik Grubbström (Grubba)  *! *! @seealso
0d47c72011-01-22Henrik Grubbström (Grubba)  *! @[deserialize()], @[lfun::_serialize()],
1031362011-01-21Henrik Grubbström (Grubba)  *! @[Serializable()->_serialize()] */ PIKEFUN void serialize(object o,
9cded82011-02-04Henrik Grubbström (Grubba)  function(mixed, string, type:void) serializer) rawtype tFunc(tObj tFunc(tMix tStr tType(tMix), tVoid), tVoid);
1031362011-01-21Henrik Grubbström (Grubba) { struct inherit *inh; struct program *p; ptrdiff_t fun; if (!(p = o->prog)) { Pike_error("Indexing a destructed object.\n"); }
017b572011-10-28Henrik Grubbström (Grubba)  inh = p->inherits + SUBTYPEOF(Pike_sp[-args]);
1031362011-01-21Henrik Grubbström (Grubba)  p = inh->prog; if ((fun = low_find_lfun(p, LFUN__SERIALIZE)) == -1) { Pike_error("Serialization not supported by object.\n"); } apply_low(o, fun + inh->identifier_level, args); } /*! @decl void deserialize(object o, @
9cded82011-02-04Henrik Grubbström (Grubba)  *! function(function(mixed:void), @ *! string, type: void) deserializer)
1031362011-01-21Henrik Grubbström (Grubba)  *!
0d47c72011-01-22Henrik Grubbström (Grubba)  *! Call @[lfun::_deserialize()] in @[o].
1031362011-01-21Henrik Grubbström (Grubba)  *! *! @seealso
0d47c72011-01-22Henrik Grubbström (Grubba)  *! @[serialize()], @[lfun::_deserialize()],
1031362011-01-21Henrik Grubbström (Grubba)  *! @[Serializable()->_deserialize()] */ PIKEFUN void deserialize(object o,
9cded82011-02-04Henrik Grubbström (Grubba)  function(function(mixed:void), string, type:void) deserializer) rawtype tFunc(tObj tFunc(tFunc(tMix, tVoid) tStr tType(tMix), tVoid), tVoid);
1031362011-01-21Henrik Grubbström (Grubba) { struct inherit *inh; struct program *p; ptrdiff_t fun; if (!(p = o->prog)) { Pike_error("Indexing a destructed object.\n"); }
017b572011-10-28Henrik Grubbström (Grubba)  inh = p->inherits + SUBTYPEOF(Pike_sp[-args]);
1031362011-01-21Henrik Grubbström (Grubba)  p = inh->prog; if ((fun = low_find_lfun(p, LFUN__DESERIALIZE)) == -1) { Pike_error("Deserialization not supported by object.\n"); } apply_low(o, fun + inh->identifier_level, args); } /*! @endmodule */
83c38b2004-09-14Henrik Grubbström (Grubba) /*! @module ADT */
7b02672013-11-19Henrik Grubbström (Grubba) /* Linked list stuff. */ static struct block_allocator pike_list_node_allocator = BA_INIT_PAGES(sizeof(struct pike_list_node), 4); ATTRIBUTE((malloc)) static struct pike_list_node * alloc_pike_list_node() { struct pike_list_node * node = ba_alloc(&pike_list_node_allocator); node->next = node->prev = NULL; node->refs = 1; SET_SVAL(node->val, T_INT, NUMBER_UNDEFINED, integer, 0); return node; } void count_memory_in_pike_list_nodes(size_t * n, size_t * s) { ba_count_all(&pike_list_node_allocator, n, s); }
3b54e52014-08-21Martin Nilsson void free_all_pike_list_node_blocks(void) {
7b02672013-11-19Henrik Grubbström (Grubba)  ba_destroy(&pike_list_node_allocator); } PMOD_EXPORT void free_list_node(struct pike_list_node *node) { if (!sub_ref(node)) { if (node->prev) { free_list_node(node->prev); } if (node->next) { free_list_node(node->next); } free_svalue(&node->val); ba_free(&pike_list_node_allocator, node); } } PMOD_EXPORT void unlink_list_node(struct pike_list_node *n) { #ifdef PIKE_DEBUG if (!n) { Pike_fatal("Unlinking NULL node.\n"); } if (!n->next || !n->prev) { Pike_fatal("Unlinking unlinked node.\n"); } #endif /* PIKE_DEBUG */ if (n->prev->next == n) { #ifdef PIKE_DEBUG if (n->next->prev != n) { Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */ n->prev->next = n->next; n->next->prev = n->prev; n->next = n->prev = NULL; /* We've lost two references. */ free_list_node(n); free_list_node(n); } else { #ifdef PIKE_DEBUG if (n->next->prev == n) { Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */ /* The node is already detached. */ n->next = n->prev = NULL; } } PMOD_EXPORT void detach_list_node(struct pike_list_node *n) { #ifdef PIKE_DEBUG if (!n) { Pike_fatal("Detaching NULL node.\n"); } if (!n->next || !n->prev) { Pike_fatal("Detaching unlinked node.\n"); } #endif /* PIKE_DEBUG */ if (n->prev->next == n) { #ifdef PIKE_DEBUG if (n->next->prev != n) { Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */ n->prev->next = n->next; n->next->prev = n->prev; add_ref(n->next); add_ref(n->prev); /* We've lost two references. */ free_list_node(n); free_list_node(n); #ifdef PIKE_DEBUG } else if (n->next->prev == n) { Pike_fatal("Partially detached node.\n"); #endif /* PIKE_DEBUG */ } } PMOD_EXPORT void prepend_list_node(struct pike_list_node *node, struct pike_list_node *new_node) { #ifdef PIKE_DEBUG if (!node) { Pike_fatal("No node to prepend.\n"); } if (!node->prev) { Pike_fatal("Prepending unhooked node.\n"); } if (!new_node) { Pike_fatal("Prepending NULL node.\n"); } if (new_node->next || new_node->prev) { Pike_fatal("Prepending hooked node.\n"); } #endif /* PIKE_DEBUG */ new_node->next = node; new_node->prev = node->prev; new_node->prev->next = node->prev = new_node; add_ref(new_node); add_ref(new_node); } PMOD_EXPORT void append_list_node(struct pike_list_node *node, struct pike_list_node *new_node) { #ifdef PIKE_DEBUG if (!node) { Pike_fatal("No node to append.\n"); } if (!node->next) { Pike_fatal("Appending unhooked node.\n"); } if (!new_node) { Pike_fatal("Appending NULL node.\n"); } if (new_node->next || new_node->prev) { Pike_fatal("Appending hooked node.\n"); } #endif /* PIKE_DEBUG */ new_node->next = node->next; new_node->prev = node; new_node->next->prev = node->next = new_node; add_ref(new_node); add_ref(new_node); }
db628a2004-09-10Henrik Grubbström (Grubba) /*! @class List *! *! Linked list of values. */ PIKECLASS List {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  CVAR struct pike_list_node *head;
db628a2004-09-10Henrik Grubbström (Grubba)  CVAR INT32 head_sentinel_refs;
4b8ebf2008-03-09Henrik Grubbström (Grubba)  CVAR struct pike_list_node *tail; /* Always NULL. */
db628a2004-09-10Henrik Grubbström (Grubba)  CVAR INT32 tail_sentinel_refs;
4b8ebf2008-03-09Henrik Grubbström (Grubba)  CVAR struct pike_list_node *tail_pred;
ce2d402004-09-17Henrik Grubbström (Grubba)  CVAR INT32 num_elems;
db628a2004-09-10Henrik Grubbström (Grubba) 
4b8ebf2008-03-09Henrik Grubbström (Grubba) #define HEAD_SENTINEL(this) ((struct pike_list_node *)(&this->head)) #define TAIL_SENTINEL(this) ((struct pike_list_node *)(&this->tail))
db628a2004-09-10Henrik Grubbström (Grubba) 
cf8d5c2004-09-11Henrik Grubbström (Grubba)  /* Sentinel overlap description: * * List Head sentinel Tail sentinel * head next * head_sentinel_refs refs * tail prev next * tail_sentinel_refs refs * tail_pred prev */
d3438c2004-09-12Henrik Grubbström (Grubba)  /* Suggestions for future functionality: *
0319bd2004-09-14Henrik Grubbström (Grubba)  * o Pop tail
d3438c2004-09-12Henrik Grubbström (Grubba)  * o Join * o Copy segment * o Detach segment (requires new iterator implementation) * o Iterator copy
0319bd2004-09-14Henrik Grubbström (Grubba)  * o _equal() for iterators and lists. * o _values(), _search(), cast() * o _sizeof()?, _indices()??
d3438c2004-09-12Henrik Grubbström (Grubba)  * o Support for reverse(), filter() and map(). * o Initialization from array.
45e13d2008-06-23Martin Stjernholm  * o Support for Pike.count_memory.
d3438c2004-09-12Henrik Grubbström (Grubba)  */
2687f92013-09-20Per Hedbor  PIKEFUN int _size_object() { int q = THIS->num_elems; int res = q * sizeof(struct pike_list_node); struct mapping *m = NULL; struct pike_list_node *n = THIS->head; while( q-- ) { res += rec_size_svalue( &n->val, &m ); n = n->next; } if( m ) free_mapping( m ); RETURN res; }
db628a2004-09-10Henrik Grubbström (Grubba)  INIT { THIS->tail = NULL; THIS->head = TAIL_SENTINEL(THIS); THIS->tail_pred = HEAD_SENTINEL(THIS);
5d32cf2004-09-15Henrik Grubbström (Grubba)  THIS->head_sentinel_refs = THIS->tail_sentinel_refs = 2;
ce2d402004-09-17Henrik Grubbström (Grubba)  THIS->num_elems = 0;
db628a2004-09-10Henrik Grubbström (Grubba)  } EXIT
8dcb7d2008-05-29Martin Stjernholm  gc_trivial;
db628a2004-09-10Henrik Grubbström (Grubba)  {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  struct pike_list_node *node = THIS->head; struct pike_list_node *next;
db628a2004-09-10Henrik Grubbström (Grubba)  while ((next = node->next)) {
cf8d5c2004-09-11Henrik Grubbström (Grubba) #ifdef PIKE_DEBUG if (node->refs != 2) { Pike_fatal("Unexpected number of references for node: %d\n", node->refs); } #endif /* PIKE_DEBUG */
db628a2004-09-10Henrik Grubbström (Grubba)  unlink_list_node(node); node = next; } }
7468fd2004-09-14Henrik Grubbström (Grubba)  /* These two functions perform the same thing, * but are optimized to minimize recursion. */
4b8ebf2008-03-09Henrik Grubbström (Grubba)  static void gc_check_list_node_backward(struct pike_list_node *node,
7468fd2004-09-14Henrik Grubbström (Grubba)  const char *msg);
4b8ebf2008-03-09Henrik Grubbström (Grubba)  static void gc_check_list_node_forward(struct pike_list_node *node,
7468fd2004-09-14Henrik Grubbström (Grubba)  const char *msg) { while (node && !debug_gc_check(&node->refs, msg)) { if (node->next) debug_gc_check_svalues(&node->val, 1, " as a list node value"); gc_check_list_node_backward(node->prev, msg); node = node->next; } }
4b8ebf2008-03-09Henrik Grubbström (Grubba)  static void gc_check_list_node_backward(struct pike_list_node *node,
7468fd2004-09-14Henrik Grubbström (Grubba)  const char *msg) { while (node && !debug_gc_check(&node->refs, msg)) { if (node->prev) debug_gc_check_svalues(&node->val, 1, " as a list node value"); gc_check_list_node_forward(node->next, msg); node = node->prev; } }
cf8d5c2004-09-11Henrik Grubbström (Grubba)  /* Called at gc_check time. */ GC_CHECK {
7468fd2004-09-14Henrik Grubbström (Grubba)  gc_check_list_node_backward(HEAD_SENTINEL(THIS), " as a list node");
5d32cf2004-09-15Henrik Grubbström (Grubba)  gc_check_list_node_forward(TAIL_SENTINEL(THIS), " as a list node");
cf8d5c2004-09-11Henrik Grubbström (Grubba)  } /* Called at gc_mark time */ GC_RECURSE {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  struct pike_list_node *node = THIS->head; struct pike_list_node *next;
cf8d5c2004-09-11Henrik Grubbström (Grubba)  while ((next = node->next)) { gc_recurse_svalues(&node->val, 1); node = next; }
45e13d2008-06-23Martin Stjernholm  /* FIXME: mc_count_bytes */
cf8d5c2004-09-11Henrik Grubbström (Grubba)  }
0319bd2004-09-14Henrik Grubbström (Grubba)  /*! @decl int(0..1) is_empty() *! *! Check if the list is empty. *! *! @returns *! Returns @expr{1@} if the list is empty, *! and @expr{0@} (zero) if there are elements in the list. */ PIKEFUN int(0..1) is_empty() { push_int(!THIS->head->next); }
13a9fc2011-02-16Henrik Grubbström (Grubba)  /*! @decl protected int(0..) _sizeof()
ce2d402004-09-17Henrik Grubbström (Grubba)  *! *! Returns the number of elements in the list. */ PIKEFUN int(0..) _sizeof()
95489a2008-06-29Martin Nilsson  flags ID_PROTECTED;
ce2d402004-09-17Henrik Grubbström (Grubba)  { push_int(THIS->num_elems); }
13a9fc2011-02-16Henrik Grubbström (Grubba)  /*! @decl protected string _sprintf(int c, mapping(string:mixed)|void attr)
2122b62004-10-28Henrik Grubbström (Grubba)  *! *! Describe the list. *! *! @seealso *! @[sprintf()], @[lfun::_sprintf()] */ PIKEFUN string _sprintf(int c, mapping(string:mixed)|void attr)
95489a2008-06-29Martin Nilsson  flags ID_PROTECTED;
2122b62004-10-28Henrik Grubbström (Grubba)  { if (!THIS->num_elems) {
75367d2014-08-22Arne Goedeke  push_static_text("ADT.List(/* empty */)");
2122b62004-10-28Henrik Grubbström (Grubba)  } else if (c == 'O') {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  struct pike_list_node *node = THIS->head;
2122b62004-10-28Henrik Grubbström (Grubba)  if (THIS->num_elems == 1) {
75367d2014-08-22Arne Goedeke  push_static_text("ADT.List(/* 1 element */\n");
2122b62004-10-28Henrik Grubbström (Grubba)  } else {
75367d2014-08-22Arne Goedeke  push_static_text("ADT.List(/* %d elements */\n");
2122b62004-10-28Henrik Grubbström (Grubba)  push_int(THIS->num_elems); f_sprintf(2); } while (node->next) { if (node->next->next) {
75367d2014-08-22Arne Goedeke  push_static_text(" %O,\n");
2122b62004-10-28Henrik Grubbström (Grubba)  } else {
75367d2014-08-22Arne Goedeke  push_static_text(" %O\n");
2122b62004-10-28Henrik Grubbström (Grubba)  } push_svalue(&node->val); f_sprintf(2); node = node->next; }
75367d2014-08-22Arne Goedeke  push_static_text(")");
2122b62004-10-28Henrik Grubbström (Grubba)  f_add(THIS->num_elems + 2); } else { if (THIS->num_elems == 1) {
75367d2014-08-22Arne Goedeke  push_static_text("ADT.List(/* 1 element */)");
2122b62004-10-28Henrik Grubbström (Grubba)  } else {
75367d2014-08-22Arne Goedeke  push_static_text("ADT.List(/* %d elements */)");
2122b62004-10-28Henrik Grubbström (Grubba)  push_int(THIS->num_elems); f_sprintf(2); } } stack_pop_n_elems_keep_top(args); }
0319bd2004-09-14Henrik Grubbström (Grubba)  /*! @decl mixed head() *! *! Get the element at the head of the list. *! *! @throws *! Throws an error if the list is empty. *! *! @seealso *! @[is_empty()], @[tail()], @[pop()] */ PIKEFUN mixed head() { if (THIS->head->next) { push_svalue(&THIS->head->val); } else { Pike_error("Empty list.\n"); } } /*! @decl mixed tail() *! *! Get the element at the tail of the list. *! *! @throws *! Throws an error if the list is empty. *! *! @seealso
f9af422012-05-09Arne Goedeke  *! @[is_empty()], @[head()], @[pop_back()]
0319bd2004-09-14Henrik Grubbström (Grubba)  */ PIKEFUN mixed tail() {
dcb5ab2012-05-09Arne Goedeke  struct pike_list_node * node = TAIL_SENTINEL(THIS); if (THIS->head->next) { push_svalue(&node->prev->val);
0319bd2004-09-14Henrik Grubbström (Grubba)  } else { Pike_error("Empty list.\n"); } }
f9af422012-05-09Arne Goedeke  static inline void pop_node(struct pike_list_node * node) { push_svalue(&node->val); if (node->refs == 2) { unlink_list_node(node); } else { detach_list_node(node); } THIS->num_elems--; }
0319bd2004-09-14Henrik Grubbström (Grubba)  /*! @decl mixed pop() *! *! Pop the element at the head of the list from the list. *! *! @throws *! Throws an error if the list is empty. *! *! @seealso
f9af422012-05-09Arne Goedeke  *! @[is_empty()], @[head()], @[tail()], @[pop_back()]
0319bd2004-09-14Henrik Grubbström (Grubba)  */ PIKEFUN mixed pop() { if (THIS->head->next) {
f9af422012-05-09Arne Goedeke  pop_node(THIS->head);
0319bd2004-09-14Henrik Grubbström (Grubba)  } else { Pike_error("Empty list.\n"); } }
f9af422012-05-09Arne Goedeke  /*! @decl mixed pop_back() *! *! Pop the element at the tail of the list from the list. *! *! @throws *! Throws an error if the list is empty. *! *! @seealso *! @[is_empty()], @[head()], @[tail()], @[pop()] */ PIKEFUN mixed pop_back() { const struct pike_list_node * node = TAIL_SENTINEL(THIS); if (THIS->head->next) { pop_node(node->prev); } else { Pike_error("Empty list.\n"); } } /*! @decl array _values() *! *! Returns an array of elements in the list. */ PIKEFUN array _values() flags ID_PROTECTED; { struct array * a; push_int(THIS->num_elems); f_allocate(1); a = Pike_sp[-1].u.array; if (THIS->num_elems) { struct pike_list_node *node = THIS->head; int i; for (i = 0; i < THIS->num_elems; i++) { assign_svalue_no_free(ITEM(a) + i, &node->val); node = node->next; } } }
7a74cc2014-08-26Per Hedbor  /*! @decl array cast(string type)
f9af422012-05-09Arne Goedeke  *!
7a74cc2014-08-26Per Hedbor  *! Cast the lists. @expr{array@} is the only *! supported type.
f9af422012-05-09Arne Goedeke  */
7a74cc2014-08-26Per Hedbor  PIKEFUN array cast(string type)
f9af422012-05-09Arne Goedeke  flags ID_PROTECTED; {
68ec3f2014-08-18Martin Nilsson  pop_stack(); /* type as at least one more reference. */ if (type == literal_array_string) apply_current(f_List_cq__values_fun_num, 0); else push_undefined();
f9af422012-05-09Arne Goedeke  } /*! @decl mixed `[](mixed key) */ PIKEFUN mixed `[](mixed key) flags ID_PROTECTED; { struct pike_list_node *node; INT_TYPE n;
f982742016-01-26Martin Nilsson  if (TYPEOF(*key) != PIKE_T_INT) SIMPLE_ARG_TYPE_ERROR("`[]", 1, "int");
f9af422012-05-09Arne Goedeke  n = key->u.integer; if (n < 0) n = -(n+1); if (n >= THIS->num_elems) Pike_error("out of bounds"); if (n >= THIS->num_elems >> 1) { /* use shorter direction */ n = THIS->num_elems - n - 1; key->u.integer = - key->u.integer - 1; } if (key->u.integer < 0) { node = TAIL_SENTINEL(THIS)->prev; while (n--) node = node->prev; } else { node = THIS->head; while (n--) node = node->next; } pop_n_elems(args); push_svalue(&node->val); }
db628a2004-09-10Henrik Grubbström (Grubba)  /*! @decl void append(mixed ... values) *! *! Append @[values] to the end of the list. *! *! @seealso *! @[insert()] */ PIKEFUN void append(mixed ... values) {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  struct pike_list_node *node = TAIL_SENTINEL(THIS);
db628a2004-09-10Henrik Grubbström (Grubba)  while (args--) {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  struct pike_list_node *new_node = alloc_pike_list_node();
6699482004-09-28Henrik Grubbström (Grubba)  new_node->val = *(--Pike_sp); prepend_list_node(node, new_node); free_list_node(node = new_node);
ce2d402004-09-17Henrik Grubbström (Grubba)  THIS->num_elems++;
db628a2004-09-10Henrik Grubbström (Grubba)  } } /*! @decl void insert(mixed ... values) *! *! Insert @[values] at the front of the list. *! *! @seealso *! @[append()] */ PIKEFUN void insert(mixed ... values) {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  struct pike_list_node *node = THIS->head;
db628a2004-09-10Henrik Grubbström (Grubba)  while (args--) {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  struct pike_list_node *new_node = alloc_pike_list_node();
6699482004-09-28Henrik Grubbström (Grubba)  new_node->val = *(--Pike_sp); prepend_list_node(node, new_node); free_list_node(node = new_node);
ce2d402004-09-17Henrik Grubbström (Grubba)  THIS->num_elems++;
db628a2004-09-10Henrik Grubbström (Grubba)  } }
f9af422012-05-09Arne Goedeke  /*! @decl void flush() *! *! Empties the List. */ PIKEFUN void flush() { if (THIS->num_elems) { while (THIS->head->next) { if (THIS->head->refs == 2) unlink_list_node(THIS->head); else detach_list_node(THIS->head); } THIS->num_elems = 0; } }
13a9fc2011-02-16Henrik Grubbström (Grubba)  /*! @decl protected void create(mixed ... values)
db628a2004-09-10Henrik Grubbström (Grubba)  *! *! Create a new @[List], and initialize it with @[values]. */ PIKEFUN void create(mixed ... values)
95489a2008-06-29Martin Nilsson  flags ID_PROTECTED;
db628a2004-09-10Henrik Grubbström (Grubba)  {
f9af422012-05-09Arne Goedeke  if (THIS->num_elems) apply_current(f_List_flush_fun_num, 0);
db628a2004-09-10Henrik Grubbström (Grubba)  apply_current(f_List_append_fun_num, args); } /*! @class _get_iterator *! *! @[Iterator] that loops over the @[List]. */ PIKECLASS _get_iterator program_flags PROGRAM_USES_PARENT;
95489a2008-06-29Martin Nilsson  flags ID_PROTECTED;
db628a2004-09-10Henrik Grubbström (Grubba)  {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  CVAR struct pike_list_node *cur;
cf8d5c2004-09-11Henrik Grubbström (Grubba)  CVAR INT32 ind; /* Not meaningful, but requred by the API. */ /* NOTE: cur may never refer to an unlinked node. * cur may however refer to a detached node, or to sentinels. */
db628a2004-09-10Henrik Grubbström (Grubba) 
ce2d402004-09-17Henrik Grubbström (Grubba)  static struct List_struct *List__get_iterator_find_parent()
db628a2004-09-10Henrik Grubbström (Grubba)  { struct external_variable_context loc; loc.o = Pike_fp->current_object; loc.parent_identifier = Pike_fp->fun;
458d552012-05-10Henrik Grubbström (Grubba)  loc.inherit = Pike_fp->context;
db628a2004-09-10Henrik Grubbström (Grubba)  find_external_context(&loc, 1);
ce2d402004-09-17Henrik Grubbström (Grubba)  return (struct List_struct *)(loc.o->storage + loc.inherit->storage_offset); } INIT { add_ref(THIS->cur = List__get_iterator_find_parent()->head);
db628a2004-09-10Henrik Grubbström (Grubba)  THIS->ind = 0; } EXIT
8dcb7d2008-05-29Martin Stjernholm  gc_trivial;
db628a2004-09-10Henrik Grubbström (Grubba)  { if (THIS->cur) { free_list_node(THIS->cur); THIS->cur = NULL; } }
cf8d5c2004-09-11Henrik Grubbström (Grubba)  /* Called at gc_check time. */ GC_CHECK {
7468fd2004-09-14Henrik Grubbström (Grubba)  gc_check_list_node_forward(THIS->cur, " held by an iterator");
13670c2015-05-25Martin Nilsson  }
7468fd2004-09-14Henrik Grubbström (Grubba)  /* These two functions perform the same thing, * but are optimized to minimize recursion. */
4b8ebf2008-03-09Henrik Grubbström (Grubba)  static void gc_recurse_list_node_tree_backward(struct pike_list_node *node, struct pike_list_node *back); static void gc_recurse_list_node_tree_forward(struct pike_list_node *node, struct pike_list_node *back)
7468fd2004-09-14Henrik Grubbström (Grubba)  { if (!node || !node->next) return; if (node->next->prev == node) { /* List member. Recursed from the list recurse code. */
cf8d5c2004-09-11Henrik Grubbström (Grubba) #ifdef PIKE_DEBUG
7468fd2004-09-14Henrik Grubbström (Grubba)  if (node->prev->next != node) {
cf8d5c2004-09-11Henrik Grubbström (Grubba)  Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */ return; } #ifdef PIKE_DEBUG
7468fd2004-09-14Henrik Grubbström (Grubba)  if (node->prev->next == node) {
cf8d5c2004-09-11Henrik Grubbström (Grubba)  Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */
7468fd2004-09-14Henrik Grubbström (Grubba)  while (1) { gc_recurse_svalues(&node->val, 1); if (node->prev != back) gc_recurse_list_node_tree_backward(node->prev, node->next); back = node->prev; node = node->next; if (!node->next || (node->next->prev == node)) { /* List member. Recursed from the list recurse code. */ #ifdef PIKE_DEBUG if (node->prev->next != node) { Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */ break; } #ifdef PIKE_DEBUG if (node->prev->next == node) { Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */ } }
4b8ebf2008-03-09Henrik Grubbström (Grubba)  static void gc_recurse_list_node_tree_backward(struct pike_list_node *node, struct pike_list_node *next)
7468fd2004-09-14Henrik Grubbström (Grubba)  { if (!node || !node->prev) return; if (node->prev->next == node) { /* List member. Checked from the list check code. */ #ifdef PIKE_DEBUG if (node->next->prev != node) { Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */ return; } #ifdef PIKE_DEBUG if (node->next->prev == node) { Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */ while (1) { gc_recurse_svalues(&node->val, 1); if (node->next != next) gc_recurse_list_node_tree_forward(node->next, node->prev); next = node->next; node = node->prev; if (!node->prev || (node->prev->next == node)) { /* List member. Recursed from the list recurse code. */ #ifdef PIKE_DEBUG if (node->next->prev != node) { Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */ break; } #ifdef PIKE_DEBUG if (node->next->prev == node) { Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */ } }
cf8d5c2004-09-11Henrik Grubbström (Grubba)  /* Called at gc_mark time */ GC_RECURSE { if (!THIS->cur->next || !THIS->cur->prev) return; if (THIS->cur->next->prev == THIS->cur) { #ifdef PIKE_DEBUG if (THIS->cur->prev->next != THIS->cur) { Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */ return; } #ifdef PIKE_DEBUG if (THIS->cur->prev->next == THIS->cur) { Pike_fatal("Partially detached node.\n"); } #endif /* PIKE_DEBUG */ /* Detached node. */ gc_recurse_svalues(&THIS->cur->val, 1);
7468fd2004-09-14Henrik Grubbström (Grubba)  gc_recurse_list_node_tree_forward(THIS->cur->next, THIS->cur->prev); gc_recurse_list_node_tree_backward(THIS->cur->next, THIS->cur->prev);
cf8d5c2004-09-11Henrik Grubbström (Grubba)  }
db628a2004-09-10Henrik Grubbström (Grubba)  PIKEFUN int(0..1) `!()
95489a2008-06-29Martin Nilsson  flags ID_PROTECTED;
db628a2004-09-10Henrik Grubbström (Grubba)  {
91829a2015-11-08Martin Nilsson  RETURN (!THIS->cur->next || !THIS->cur->prev);
db628a2004-09-10Henrik Grubbström (Grubba)  } PIKEFUN int(0..) index() { pop_n_elems(args); if (THIS->cur->next && THIS->cur->prev) { push_int(THIS->ind); } else { push_undefined(); } } /*! @decl mixed value() *! *! @returns *! Returns the value at the current position. */ PIKEFUN mixed value() { pop_n_elems(args); if (THIS->cur->next && THIS->cur->prev) { push_svalue(&THIS->cur->val); } else { push_undefined(); } } /*! @decl int(0..1) first() *!
56e48a2008-06-30Henrik Grubbström (Grubba)  *! Reset the iterator to point to the first element in *! the list.
db628a2004-09-10Henrik Grubbström (Grubba)  *! *! @returns *! Returns @expr{1@} if there are elements in the list, *! and @expr{0@} (zero) if the list is empty. */ PIKEFUN int(0..1) first() { struct external_variable_context loc; struct List_struct *parent; pop_n_elems(args); /* Find our parent. */ loc.o = Pike_fp->current_object; loc.parent_identifier = Pike_fp->fun; loc.inherit = INHERIT_FROM_INT(loc.o->prog, loc.parent_identifier); find_external_context(&loc, 1); parent = (struct List_struct *)(loc.o->storage + loc.inherit->storage_offset); free_list_node(THIS->cur); add_ref(THIS->cur = parent->head); THIS->ind = 0; pop_n_elems(args); if (THIS->cur->next) { push_int(1); } else { push_undefined(); } } /*! @decl int(0..1) next() *! *! Advance to the next element in the list. *! *! @returns *! Returns @expr{1@} on success, and @expr{0@} (zero) *! at the end of the list. *! *! @seealso *! @[prev()] */ PIKEFUN int(0..1) next() {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  struct pike_list_node *next;
db628a2004-09-10Henrik Grubbström (Grubba)  if ((next = THIS->cur->next)) { free_list_node(THIS->cur); add_ref(THIS->cur = next); THIS->ind++;
91829a2015-11-08Martin Nilsson  if (next->next) RETURN 1;
db628a2004-09-10Henrik Grubbström (Grubba)  }
91829a2015-11-08Martin Nilsson  RETURN 0;
db628a2004-09-10Henrik Grubbström (Grubba)  } /*! @decl int(0..1) prev() *! *! Retrace to the previous element in the list. *! *! @returns *! Returns @expr{1@} on success, and @expr{0@} (zero) *! at the beginning of the list. *! *! @seealso *! @[next()] */ PIKEFUN int(0..1) prev() {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  struct pike_list_node *prev;
db628a2004-09-10Henrik Grubbström (Grubba)  if ((prev = THIS->cur->prev)) { free_list_node(THIS->cur); add_ref(THIS->cur = prev); THIS->ind--;
91829a2015-11-08Martin Nilsson  if (prev->prev) RETURN 1;
db628a2004-09-10Henrik Grubbström (Grubba)  }
91829a2015-11-08Martin Nilsson  RETURN 0;
db628a2004-09-10Henrik Grubbström (Grubba)  } /*! @decl Iterator `+=(int steps) *! *! Advance or retrace the specified number of @[steps]. *! *! @seealso *! @[next()], @[prev] */ PIKEFUN Iterator `+=(int steps) { if (!steps) return; if (steps > 0) { while (steps--) { apply_current(f_List_cq__get_iterator_next_fun_num, 0); pop_stack(); } } else { while (steps++) { apply_current(f_List_cq__get_iterator_prev_fun_num, 0); pop_stack(); } } pop_n_elems(args); ref_push_object(Pike_fp->current_object); } /*! @decl void insert(mixed val) *! *! Insert @[val] at the current position. *! *! @seealso *! @[append()], @[delete()], @[set()] */ PIKEFUN void insert(mixed val) {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  struct pike_list_node *new_node;
db628a2004-09-10Henrik Grubbström (Grubba)  if (!THIS->cur->prev) { Pike_error("Attempt to insert before the start sentinel.\n"); }
4b8ebf2008-03-09Henrik Grubbström (Grubba)  new_node = alloc_pike_list_node();
6699482004-09-28Henrik Grubbström (Grubba)  assign_svalue_no_free(&new_node->val, val); prepend_list_node(THIS->cur, new_node);
db628a2004-09-10Henrik Grubbström (Grubba)  free_list_node(THIS->cur);
6699482004-09-28Henrik Grubbström (Grubba)  THIS->cur = new_node;
ce2d402004-09-17Henrik Grubbström (Grubba)  List__get_iterator_find_parent()->num_elems++;
db628a2004-09-10Henrik Grubbström (Grubba)  } /*! @decl void append(mixed val) *! *! Append @[val] after the current position. *! *! @seealso *! @[insert()], @[delete()], @[set()] */ PIKEFUN void append(mixed val) {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  struct pike_list_node *new_node;
db628a2004-09-10Henrik Grubbström (Grubba)  if (!THIS->cur->next) { Pike_error("Attempt to append after the end sentinel.\n"); }
4b8ebf2008-03-09Henrik Grubbström (Grubba)  new_node = alloc_pike_list_node();
6699482004-09-28Henrik Grubbström (Grubba)  assign_svalue_no_free(&new_node->val, val); append_list_node(THIS->cur, new_node); free_list_node(new_node);
ce2d402004-09-17Henrik Grubbström (Grubba)  List__get_iterator_find_parent()->num_elems++;
db628a2004-09-10Henrik Grubbström (Grubba)  } /*! @decl void delete() *! *! Delete the current node. *! *! The current position will advance to the next node. *! This function thus performes the reverse operation *! of @[insert()]. *! *! @seealso *! @[insert()], @[append()], @[set()] */ PIKEFUN void delete() {
4b8ebf2008-03-09Henrik Grubbström (Grubba)  struct pike_list_node *next;
db628a2004-09-10Henrik Grubbström (Grubba)  if (!(next = THIS->cur->next) || !THIS->cur->prev) { Pike_error("Attempt to delete a sentinel.\n"); }
cf8d5c2004-09-11Henrik Grubbström (Grubba)  add_ref(next);
ce2d402004-09-17Henrik Grubbström (Grubba)  if (next->prev == THIS->cur) { if (THIS->cur->refs == 3) { unlink_list_node(THIS->cur); } else { /* There's some other iterator holding references to this node. */ detach_list_node(THIS->cur); } List__get_iterator_find_parent()->num_elems--;
cf8d5c2004-09-11Henrik Grubbström (Grubba)  }
db628a2004-09-10Henrik Grubbström (Grubba)  free_list_node(THIS->cur);
cf8d5c2004-09-11Henrik Grubbström (Grubba)  THIS->cur = next;
db628a2004-09-10Henrik Grubbström (Grubba)  } /*! @decl void set(mixed val) *! *! Set the value of the current position to @[val]. *! *! @seealso *! @[insert()], @[append()], @[delete()] */ PIKEFUN void set(mixed val) { if (!THIS->cur->next || !THIS->cur->prev) { Pike_error("Attempt to set a sentinel.\n"); } assign_svalue(&THIS->cur->val, val); } } /*! @endclass */ } /*! @endclass */
83c38b2004-09-14Henrik Grubbström (Grubba) /*! @endmodule */
fdb7422009-08-19Henrik Grubbström (Grubba) /*! @module Pike */
d8489a2009-08-18Henrik Grubbström (Grubba) /*! @class MasterCodec *!
74bc5f2009-08-19Henrik Grubbström (Grubba)  *! This is a bare-bones codec that is used when loading a dumped master.
d8489a2009-08-18Henrik Grubbström (Grubba)  *! *! @seealso *! @[Codec] */ PIKECLASS MasterCodec flags ID_PROTECTED; {
fdb7422009-08-19Henrik Grubbström (Grubba)  /*! @decl mixed functionof(mixed symbol) *! Look up a function in @[all_constants()].
d8489a2009-08-18Henrik Grubbström (Grubba)  */ PIKEFUN mixed functionof(mixed symbol) { mapping_index_no_free(Pike_sp, get_builtin_constants(), symbol); Pike_sp++; stack_pop_keep_top(); }
74bc5f2009-08-19Henrik Grubbström (Grubba)  /*! @decl mixed objectof(mixed symbol) *! Look up an object in @[all_constants()]. */ PIKEFUN mixed objectof(mixed symbol) { mapping_index_no_free(Pike_sp, get_builtin_constants(), symbol); Pike_sp++; stack_pop_keep_top(); } /*! @decl mixed programof(mixed symbol) *! Look up a program in @[all_constants()]. */ PIKEFUN mixed programof(mixed symbol) { mapping_index_no_free(Pike_sp, get_builtin_constants(), symbol); Pike_sp++; stack_pop_keep_top(); }
63ef652009-08-19Henrik Grubbström (Grubba)  /*! @decl object decode_object(object obj, mixed data)
c8c72a2009-08-20Martin Nilsson  *! Calls @expr{obj->_decode(@[data])@}.
63ef652009-08-19Henrik Grubbström (Grubba)  */ PIKEFUN object decode_object(object obj, mixed data) { apply(obj, "_decode", 1); pop_stack(); }
d8489a2009-08-18Henrik Grubbström (Grubba) }
fdb7422009-08-19Henrik Grubbström (Grubba) /*! @endclass */ /*! @endmodule */
3700122010-11-23Martin Stjernholm static struct object *val_module;
1eb1152009-11-12Henrik Grubbström (Grubba) 
3b54e52014-08-21Martin Nilsson static void get_val_module(void)
1eb1152009-11-12Henrik Grubbström (Grubba) {
3700122010-11-23Martin Stjernholm  assert (!val_module);
5e9fc02015-08-18Per Hedbor  push_static_text ("Val");
3700122010-11-23Martin Stjernholm  APPLY_MASTER ("resolv", 1);
017b572011-10-28Henrik Grubbström (Grubba)  if (TYPEOF(Pike_sp[-1]) != T_OBJECT)
3700122010-11-23Martin Stjernholm  Pike_error ("\"Val\" didn't resolve to a module object.\n"); val_module = (--Pike_sp)->u.object; } /* Always do the lookup in the Val module dynamically to allow the * values to be replaced. */ #define GET_VAL(NAME) \ PMOD_EXPORT struct object *PIKE_CONCAT (get_val_, NAME) (void) \ { \ struct svalue index, res; \ if (!val_module) get_val_module(); \
017b572011-10-28Henrik Grubbström (Grubba)  SET_SVAL(index, T_STRING, 0, string, NULL); \
3700122010-11-23Martin Stjernholm  MAKE_CONST_STRING (index.u.string, TOSTR (NAME)); \ object_index_no_free (&res, val_module, 0, &index); \
017b572011-10-28Henrik Grubbström (Grubba)  if (TYPEOF(res) != T_OBJECT) \
3700122010-11-23Martin Stjernholm  Pike_error ("\"Val." TOSTR (NAME) "\" didn't resolve to an object.\n"); \ return res.u.object; \ } GET_VAL (true) GET_VAL (false) GET_VAL (null) /* Kludge needed for the static null objects in the oracle module. It * ought to be fixed to use dynamic lookup of them instead. */ PMOD_EXPORT struct program *get_sql_null_prog(void) {
83045c2011-03-05Martin Stjernholm  return Null_program;
1eb1152009-11-12Henrik Grubbström (Grubba) }
7cd6fa2009-11-11Henrik Grubbström (Grubba) 
42d5b32012-01-09Henrik Grubbström (Grubba) PIKECLASS __Backtrace_Tester__ { INIT { Pike_error("__Backtrace_Tester__\n"); } }
3a5b1d2000-05-24Fredrik Hübinette (Hubbe) void init_builtin(void) {
b6a9792013-06-26Henrik Grubbström (Grubba)  SET_SVAL(gc_pre_cb, PIKE_T_INT, NUMBER_NUMBER, integer, 0); SET_SVAL(gc_post_cb, PIKE_T_INT, NUMBER_NUMBER, integer, 0); SET_SVAL(gc_destruct_cb, PIKE_T_INT, NUMBER_NUMBER, integer, 0); SET_SVAL(gc_done_cb, PIKE_T_INT, NUMBER_NUMBER, integer, 0);
c48ab32014-08-10Martin Nilsson  INIT;
3a5b1d2000-05-24Fredrik Hübinette (Hubbe) }
8650752001-06-25Henrik Grubbström (Grubba)  void exit_builtin(void) {
b6a9792013-06-26Henrik Grubbström (Grubba)  struct svalue zero;
3700122010-11-23Martin Stjernholm  if (val_module) free_object (val_module);
c48ab32014-08-10Martin Nilsson  EXIT;
b6a9792013-06-26Henrik Grubbström (Grubba)  SET_SVAL(zero, PIKE_T_INT, NUMBER_NUMBER, integer, 0); assign_svalue(&gc_pre_cb, &zero); assign_svalue(&gc_post_cb, &zero); assign_svalue(&gc_destruct_cb, &zero); assign_svalue(&gc_done_cb, &zero);
c1f4762008-11-02Henrik Grubbström (Grubba) #ifndef DO_PIKE_CLEANUP /* This is performed by exit_builtin_modules() at a later point * in this case, so that the pike_list_node's are valid at cleanup * time, thus avoiding "got invalid pointer" fatals at exit. */
d476592013-06-12Arne Goedeke  ba_destroy(&pike_list_node_allocator);
c1f4762008-11-02Henrik Grubbström (Grubba) #endif
687af42008-07-08Henrik Grubbström (Grubba) #ifndef USE_SETENV
8d401b2008-06-05Martin Stjernholm  if (env_allocs) free_mapping (env_allocs);
687af42008-07-08Henrik Grubbström (Grubba) #endif
4c11022016-01-17Henrik Grubbström (Grubba) #ifdef __NT__ if (crypto_handle) CloseHandle(crypto_handle); #else
ffaa5a2016-01-17Martin Nilsson  if (random_fd!=-1) close(random_fd);
4c11022016-01-17Henrik Grubbström (Grubba) #endif
8650752001-06-25Henrik Grubbström (Grubba) }