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"
99218e2017-11-06Martin Nilsson #include "pike_cpulib.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"
9d1f542017-01-25Henrik Grubbström (Grubba) #include "sprintf.h"
e0ac352018-01-18Martin Nilsson #include "pike_search.h"
6c15cb2008-06-10Martin Stjernholm  #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
041afd2017-12-25Stephen R. van den Berg #ifdef STRUCT_TM_HAS___TM_GMTOFF struct tm_extra { }; #define tm_zone __tm_zone #define tm_gmtoff __tm_gmtoff #define GET_GMTOFF(TM) ((TM)->tm_gmtoff) #define GET_ZONE(this) ((this)->t.tm_zone) #define SET_GMTOFF(TM, VAL) (((TM)->tm_gmtoff) = (VAL)) #define SET_ZONE(this, VAL) ((this)->t.tm_zone = (VAL)) #elif defined(STRUCT_TM_HAS_GMTOFF) struct tm_extra { }; #define GET_GMTOFF(TM) ((TM)->tm_gmtoff) #define GET_ZONE(this) ((this)->t.tm_zone) #define SET_GMTOFF(TM, VAL) (((TM)->tm_gmtoff) = (VAL)) #define SET_ZONE(this, VAL) ((this)->t.tm_zone = (VAL)) #else
8e10fb2017-12-26Martin Nilsson  struct tm_extra { const char *tm_zone; };
041afd2017-12-25Stephen R. van den Berg #define GET_GMTOFF(TM) 0 #define GET_ZONE(this) ((this)->extra.tm_zone) #define SET_GMTOFF(TM, VAL) (VAL) #define SET_ZONE(this, VAL) ((this)->extra.tm_zone = (VAL)) #endif
56c0642008-07-31Martin Stjernholm 
041afd2017-12-25Stephen R. van den Berg 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;
041afd2017-12-25Stephen R. van den Berg  CVAR struct tm_extra extra;
12327f2013-05-22Per Hedbor  #define strftime_zone strftime #define strptime_zone strptime #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)
4cbf072017-12-26Stephen R. van den Berg #define FIX_THIS() do { \
5fbae42017-12-25Stephen R. van den Berg  if(THIS->modified) \
4cbf072017-12-26Stephen R. van den Berg  fix_tm(THIS); \
12327f2013-05-22Per Hedbor  } while(0)
4cbf072017-12-26Stephen R. van den Berg  static void fix_tm(struct TM_struct *this)
ae3ca92017-12-26Martin Nilsson  { const char *tm_zone = GET_ZONE(this); int is_utc_zone = tm_zone && !strcmp(tm_zone, "UTC"); if (is_utc_zone) this->t.tm_isdst = 0;
4cbf072017-12-26Stephen R. van den Berg  this->unix_time = mktime_zone(&this->t, is_utc_zone, 0);
ae3ca92017-12-26Martin Nilsson  this->modified = 0; }
5fbae42017-12-25Stephen R. van den Berg 
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  *!
8cd0db2018-01-31Stephen R. van den Berg  *! @note *! The @expr{format@} and @expr{data@} are reversed.
12327f2013-05-22Per Hedbor  *!
8cd0db2018-01-31Stephen R. van den Berg  *! @seealso *! @[strptime]
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 ) *!
8cd0db2018-01-31Stephen R. van den Berg  *! @seealso
87d5d42018-02-09Stephen R. van den Berg  *! @[strftime], @[Gettext.setlocale]
6bd26d2013-11-17Henrik Grubbström (Grubba)  */
ff3e252018-01-08Stephen R. van den Berg  PIKEFUN string(1..255) strftime(string(1..255) format)
12327f2013-05-22Per Hedbor  {
8cd0db2018-01-31Stephen R. van den Berg  char buffer[8192];
12327f2013-05-22Per Hedbor  buffer[0] = 0;
8cd0db2018-01-31Stephen R. van den Berg  strftime_zone(buffer, sizeof(buffer), format->str, &THIS->t); push_text(buffer);
12327f2013-05-22Per Hedbor  }
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. */
4cbf072017-12-26Stephen R. van den Berg  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; }
12327f2013-05-22Per Hedbor 
4cbf072017-12-26Stephen R. van den Berg  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 *!
53354e2017-12-13Stephen R. van den Berg  *! True if daylight-saving is in effect. If this field is -1
12327f2013-05-22Per Hedbor  *! (the default) it (and the timezone info) will be updated *! automatically using the timezone rules. */ PIKEFUN int(-1..1) `isdst() {
4cbf072017-12-26Stephen R. van den Berg  FIX_THIS();
12327f2013-05-22Per Hedbor  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. */
4cbf072017-12-26Stephen R. van den Berg  PIKEFUN int(0..6) `wday() { FIX_THIS(); RETURN THIS->t.tm_wday; }
12327f2013-05-22Per Hedbor  /*! @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. */
4cbf072017-12-26Stephen R. van den Berg  PIKEFUN int(0..365) `yday() { FIX_THIS(); RETURN THIS->t.tm_yday; }
12327f2013-05-22Per Hedbor  /*! @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() {
4cbf072017-12-26Stephen R. van den Berg  FIX_THIS();
12327f2013-05-22Per Hedbor  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() {
4cbf072017-12-26Stephen R. van den Berg  FIX_THIS();
12327f2013-05-22Per Hedbor  {
7c76812017-04-20Henrik Grubbström (Grubba) #define STRFTIME_MAXSIZE 26 char s[STRFTIME_MAXSIZE];
fb0eb02017-12-06Stephen R. van den Berg  if( !strftime(s, STRFTIME_MAXSIZE, "%c\n", &THIS->t) )
aa3db12017-04-19Martin Nilsson  push_undefined(); else push_text(s);
12327f2013-05-22Per Hedbor  } }
91829a2015-11-08Martin Nilsson  PIKEFUN string _sprintf( int flag, mapping options )
12327f2013-05-22Per Hedbor  {
fb0eb02017-12-06Stephen R. van den Berg  int post_sum = 0;
12327f2013-05-22Per Hedbor  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");
041afd2017-12-25Stephen R. van den Berg  if( GET_ZONE(THIS) )
12327f2013-05-22Per Hedbor  {
75367d2014-08-22Arne Goedeke  push_static_text(" ");
041afd2017-12-25Stephen R. van den Berg  push_text( GET_ZONE(THIS) );
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() {
4cbf072017-12-26Stephen R. van den Berg  FIX_THIS();
041afd2017-12-25Stephen R. van den Berg  if( GET_ZONE(THIS) ) push_text( GET_ZONE(THIS) );
12327f2013-05-22Per Hedbor  else push_undefined(); } /*! @decl int gmtoff *! The offset from GMT for the time in this tm-struct */ PIKEFUN int `gmtoff() {
4cbf072017-12-26Stephen R. van den Berg  FIX_THIS();
09b6e22013-07-08Henrik Grubbström (Grubba)  push_int( GET_GMTOFF(&(THIS->t)) );
12327f2013-05-22Per Hedbor  } /*! @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  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;
041afd2017-12-25Stephen R. van den Berg  SET_ZONE(THIS, "UTC"); /* Override timezone */
12327f2013-05-22Per Hedbor  THIS->modified = 1; RETURN 1; }
9e5ac42017-12-26Henrik Grubbström (Grubba)  /*! @decl int(0..1) gmtime( Gmp.mpz time ) *! Initialize the struct tm to the UTC time for the specified *! unix time_t. */ PIKEFUN int(0..1) gmtime( object(Gmp.mpz)|object(Gmp.bignum) _t ) { INT64 t_int64 = 0; time_t t; struct tm *res; if (!low_int64_from_bignum(&t_int64, _t)) RETURN 0; t = t_int64; res = gmtime( &t ); if( !res ) RETURN 0; THIS->t = *res; SET_ZONE(THIS, "UTC"); /* Override timezone */ THIS->modified = 1; RETURN 1; } /*! @decl void create(int|Gmp.mpz t)
8e94242013-05-28Henrik Grubbström (Grubba)  *! Create a new @[TM] initialized from a unix time_t.
12327f2013-05-22Per Hedbor  *! The timezone will always be UTC when using this function. */
9e5ac42017-12-26Henrik Grubbström (Grubba)  PIKEFUN void create( int|object(Gmp.mpz)|object(Gmp.bignum) _t )
12327f2013-05-22Per Hedbor  { f_TM_gmtime( 1 ); if( Pike_sp[-1].u.integer == 0 ) Pike_error("time out of range\n");
65810c2017-12-28Martin Nilsson  pop_stack();
12327f2013-05-22Per Hedbor  }
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;
e3fbc42017-02-01Martin Nilsson  THIS->t.tm_mday = 1;
12327f2013-05-22Per Hedbor  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;
8e10fb2017-12-26Martin Nilsson  int use_utc = 0; 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;
5fbae42017-12-25Stephen R. van den Berg  if (timezone) { if (strcmp(timezone->str, "UTC")) Pike_error("Timezone must either be UTC or omitted.\n"); use_utc = 1; } if (use_utc) t->tm_isdst = 0;
4cbf072017-12-26Stephen R. van den Berg  THIS->unix_time = mktime_zone(&THIS->t, use_utc, 0);
fb0eb02017-12-06Stephen R. van den Berg  /* Setting it to other timezones than UTC is not supported (yet) */
5fbae42017-12-25Stephen R. van den Berg  if (use_utc)
041afd2017-12-25Stephen R. van den Berg  SET_ZONE(THIS, "UTC");
65810c2017-12-28Martin Nilsson  pop_n_elems(args);
12327f2013-05-22Per Hedbor  }
b467522017-06-25Martin Nilsson #ifdef PIKE_NULL_IS_SPECIAL
12327f2013-05-22Per Hedbor  INIT { THIS->modified = 0; }
b467522017-06-25Martin Nilsson #endif
12327f2013-05-22Per Hedbor }
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)  } }
0f83542016-11-07Stephen R. van den Berg /*! @decl int siphash24(string data, void|int key)
6865722016-11-05Martin Nilsson  *! @appears Crypto.siphash24 *! *! Hashes a string, with an optional key, to a 64 bit integer using *! the siphash-2-4 algorithm. Currently the 64 bit @[key] parameter *! is used both for the high and low part of the 128 bit key. *! */ #include "siphash24.h" PIKEFUN int siphash24(string s, void|int key) { mpz_t ret; mpz_init(ret); mpz_set_ui(ret, pike_string_siphash24(s, key && key->u.integer) ); push_bignum(ret); }
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 
16a0f62018-05-13Henrik Grubbström (Grubba) /*! @decl string string2hex(string data, void|int(0..) flags)
b2d3ca2003-08-26Martin Nilsson  *! @appears String.string2hex *! *! Convert a string of binary data to a hexadecimal string. *!
16a0f62018-05-13Henrik Grubbström (Grubba)  *! @param flags *! The binary or of the following flags: *! @int *! @value 1 *! Use upper case characters. *! *! @value 2 *! The input is in little-endian byte order. *! @endint
f744d62016-08-28Martin Nilsson  *!
b2d3ca2003-08-26Martin Nilsson  *! @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' };
f744d62016-08-28Martin Nilsson static const char HEXCHAR[] = { '0','1','2','3','4','5','6','7','8','9', 'A','B','C','D','E','F' };
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
16a0f62018-05-13Henrik Grubbström (Grubba)  PIKEFUN string(48..102) string2hex(string s, void|int flags)
f744d62016-08-28Martin Nilsson  efun;
b2d3ca2003-08-26Martin Nilsson  optflags OPT_TRY_OPTIMIZE; { struct pike_string *hex;
b2f5ff2011-11-04Per Hedbor  unsigned char *p,*st = (unsigned char *)s->str;
16a0f62018-05-13Henrik Grubbström (Grubba)  const char *hextab = hexchar; int i, l, d = 1;
b2d3ca2003-08-26Martin Nilsson  if (s->size_shift) Pike_error("Bad argument 1 to string2hex(), expected 8-bit string.\n");
16a0f62018-05-13Henrik Grubbström (Grubba)  if (flags && (flags->u.integer & 1)) { hextab = HEXCHAR; }
b2d3ca2003-08-26Martin Nilsson  hex = begin_shared_string(2 * s->len);
b2f5ff2011-11-04Per Hedbor  p = (unsigned char *)hex->str; l = s->len;
8d251e2003-09-05Martin Nilsson 
16a0f62018-05-13Henrik Grubbström (Grubba)  if (flags && (flags->u.integer & 2)) { d = -1; st += l-1;
f744d62016-08-28Martin Nilsson  }
16a0f62018-05-13Henrik Grubbström (Grubba)  for (i=0; i<l; i++) { *p++ = hextab[*st>>4]; *p++ = hextab[*st&15]; st += d;
f744d62016-08-28Martin Nilsson  }
b2d3ca2003-08-26Martin Nilsson  RETURN end_shared_string(hex); }
a958662017-11-07Martin Nilsson extern const unsigned char hexdecode[256];
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 {
212c392018-02-25Martin Nilsson  bad_arg_error("trace", args, 2,
50d97a2003-02-01Martin Stjernholm  "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
d4df992018-02-09Stephen R. van den Berg  *! @[strftime()], @[time()], @[localtime()], @[gmtime()], @[mktime()]
0498332001-02-10Henrik Grubbström (Grubba)  */
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;
0a3c552016-05-09Martin Nilsson #if SIZEOF_TIME_T < SIZEOF_INT64
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)
212c392018-02-25Martin Nilsson  bad_arg_error("mkmapping", 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;
99fecd2017-10-19Henrik Grubbström (Grubba)  if(whitespace) { if(!(wlen = whitespace->len)) {
fa5fcc2010-01-08Stephen R. van den Berg  REF_RETURN s;
99fecd2017-10-19Henrik Grubbström (Grubba)  } else {
fa5fcc2010-01-08Stephen R. van den Berg  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; } }
99fecd2017-10-19Henrik Grubbström (Grubba)  } 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); }
8ff89d2016-07-04Martin Nilsson /*! @decl string trim (string s)
31acb72001-07-26Martin Nilsson  *! @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
8ff89d2016-07-04Martin Nilsson PIKEFUN string string_trim (string s) errname trim;
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); }
95432b2018-12-07Henrik Grubbström (Grubba) /*! @decl mixed m_delete(object|mapping|multiset map, mixed index)
0498332001-02-10Henrik Grubbström (Grubba)  *! *! 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)  *!
95432b2018-12-07Henrik Grubbström (Grubba)  *! Otherwise if @[map] is a mapping or multiset the entry with *! index @[index] will be removed from @[map] destructively.
0498332001-02-10Henrik Grubbström (Grubba)  *!
95432b2018-12-07Henrik Grubbström (Grubba)  *! If the mapping or multiset does not have an entry with *! index @[index], nothing is done.
0498332001-02-10Henrik Grubbström (Grubba)  *! *! @returns
95432b2018-12-07Henrik Grubbström (Grubba)  *! The value that was removed will be returned, *! and @expr{UNDEFINED@} otherwise.
0498332001-02-10Henrik Grubbström (Grubba)  *! *! @note *! Note that @[m_delete()] changes @[map] destructively. *! *! @seealso *! @[mappingp()] */
28ab1d2006-07-05Martin Stjernholm PMOD_EXPORT
95432b2018-12-07Henrik Grubbström (Grubba) PIKEFUN mixed m_delete(object|mapping|multiset map, mixed index)
7f80d42000-06-19Fredrik Hübinette (Hubbe)  efun; optflags OPT_SIDE_EFFECT;
95432b2018-12-07Henrik Grubbström (Grubba)  rawtype tOr3(tFunc(tMap(tSetvar(0,tMix),tSetvar(1,tMix)) tVar(0),tVar(1)), tFunc(tSet(tSetvar(0,tMix)) tVar(0),tInt01), 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();
95432b2018-12-07Henrik Grubbström (Grubba)  } else if (TYPEOF(*map) == T_MULTISET) { struct svalue s; multiset_delete_2(map->u.multiset, index, &s); pop_n_elems(args); *Pike_sp = s; Pike_sp++; dmalloc_touch_svalue(Pike_sp-1);
79f6982001-02-05Henrik Grubbström (Grubba)  } else {
95432b2018-12-07Henrik Grubbström (Grubba)  SIMPLE_ARG_TYPE_ERROR("m_delete", 1, "object|mapping|multiset");
a3453e2001-02-05Per Hedbor  }
7f80d42000-06-19Fredrik Hübinette (Hubbe) }
4664e12018-12-08Henrik Grubbström (Grubba) /*! @decl void m_clear(mapping|multiset|object map)
c5a09f2018-09-03Henrik Grubbström (Grubba)  *!
4664e12018-12-08Henrik Grubbström (Grubba)  *! Clear the contents of a mapping or multiset.
c5a09f2018-09-03Henrik Grubbström (Grubba)  *!
4664e12018-12-08Henrik Grubbström (Grubba)  *! This function clears the content of the mapping *! or multiset @[map] so that it becomes empty. *! This is an atomic operation. *! *! If @[map] is an object @[lfun::_m_clear()] will be called *! in it.
c5a09f2018-09-03Henrik Grubbström (Grubba)  *! *! @seealso *! @[m_delete()] */ PMOD_EXPORT
4664e12018-12-08Henrik Grubbström (Grubba) PIKEFUN void m_clear(mapping|multiset|object map) efun;
c5a09f2018-09-03Henrik Grubbström (Grubba)  optflags OPT_SIDE_EFFECT; {
4664e12018-12-08Henrik Grubbström (Grubba)  struct program *p; if (TYPEOF(*map) == PIKE_T_MAPPING) { clear_mapping(map->u.mapping); } else if (TYPEOF(*map) == PIKE_T_MULTISET) { clear_multiset(map->u.multiset); } else if ((TYPEOF(*map) == PIKE_T_OBJECT) && (p = map->u.object->prog)) { int id = FIND_LFUN(p->inherits[SUBTYPEOF(*map)].prog, LFUN__M_CLEAR); if( id == -1 ) { SIMPLE_ARG_TYPE_ERROR("m_clear", 1, "object with lfun::_m_clear()"); } apply_low(map->u.object, id + p->inherits[SUBTYPEOF(*map)].identifier_level, 0); pop_stack(); } else { SIMPLE_ARG_TYPE_ERROR("m_clear", 1, "mapping|multiset"); } pop_n_elems(args);
c5a09f2018-09-03Henrik Grubbström (Grubba) }
a170612018-12-09Henrik Grubbström (Grubba) /*! @decl void m_add(multiset|object l, mixed val) *! *! Add a member to a multiset. *! *! @seealso *! @[m_delete()] */ PMOD_EXPORT PIKEFUN void m_add(multiset|object l, mixed val) efun; optflags OPT_SIDE_EFFECT; rawtype tFunc(tSet(tSetvar(0, tMix)) tVar(0), tVoid); { struct program *p; if (TYPEOF(*l) == PIKE_T_MULTISET) { multiset_add(l->u.multiset, val); } else if ((TYPEOF(*l) == PIKE_T_OBJECT) && (p = l->u.object->prog)) { int id = FIND_LFUN(p->inherits[SUBTYPEOF(*l)].prog, LFUN__M_ADD); if( id == -1 ) { SIMPLE_ARG_TYPE_ERROR("m_add", 1, "object with lfun::_m_add()"); } apply_low(l->u.object, id + p->inherits[SUBTYPEOF(*l)].identifier_level, 1); } else { SIMPLE_ARG_TYPE_ERROR("m_add", 1, "multiset|object"); } pop_n_elems(args); }
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))
212c392018-02-25Martin Nilsson  bad_arg_error("function_name", args, 1,
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  "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); }
8b27342016-08-06Henrik Grubbström (Grubba) /*! @class RandomInterface */
1f12012016-01-13Martin Nilsson PIKECLASS RandomInterface {
0c6cca2016-04-20Henrik Grubbström (Grubba)  CVAR UINT64 int_buffer;
1f12012016-01-13Martin Nilsson  CVAR int buffer_bits;
b467522017-06-25Martin Nilsson #ifdef PIKE_NULL_IS_SPECIAL
1f12012016-01-13Martin Nilsson  INIT { THIS->int_buffer = 0; THIS->buffer_bits = 0; }
b467522017-06-25Martin Nilsson #endif
1f12012016-01-13Martin Nilsson 
8b27342016-08-06Henrik Grubbström (Grubba)  /*! @decl string(8bit) random_string(int(0..)) *! *! Prototype for the randomness generating function. *!
88d6b12016-08-08Martin Nilsson  *! Override this symbol to implement a usable class.
8b27342016-08-06Henrik Grubbström (Grubba)  */
1f12012016-01-13Martin Nilsson  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. */
2912e12018-03-28Henrik Grubbström (Grubba)  { int i; for (i = 0; i < 8; i++) { ((p_wchar0 *)&THIS->int_buffer)[i] = STR0(Pike_sp[-1].u.string)[7-i]; }
78c5682016-03-24Henrik Grubbström (Grubba)  } #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  {
b08a872016-11-15Henrik Grubbström (Grubba)  int bits; UINT64 mask;
3926242016-09-26Stephen R. van den Berg  int i;
b08a872016-11-15Henrik Grubbström (Grubba)  if(limit <= 1) return 0; bits = my_log2(limit-1)+1; mask = (((UINT64)1)<<bits)-1;
3926242016-09-26Stephen R. van den Berg  for(i=0; i<1000; i++)
1f12012016-01-13Martin Nilsson  {
b08a872016-11-15Henrik Grubbström (Grubba)  INT_TYPE ret;
1f12012016-01-13Martin Nilsson  if(THIS->buffer_bits < bits) fill_int_buffer();
b08a872016-11-15Henrik Grubbström (Grubba)  ret = THIS->int_buffer & mask;
1f12012016-01-13Martin Nilsson  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) {
30f5b22016-04-09Martin Nilsson  UINT64 value;
202bf02017-04-16Henrik Grubbström (Grubba)  if(f<=0.0) RETURN 0.0;
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].
88d6b12016-08-08Martin Nilsson  *! *! @throws *! Throws an exception if the array or multiset is empty.
b7a4a02016-01-18Martin Nilsson  */
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.
88d6b12016-08-08Martin Nilsson  *! *! @array *! @elem mixed 0 *! The index of the mapping entry. *! @elem mixed 1 *! The value f the mapping entry. *! @endarray *! *! @throws *! Throws an exception if the mapping is empty.
b7a4a02016-01-18Martin Nilsson  */
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; } }
08ed362018-09-15Henrik Grubbström (Grubba)  UNREACHABLE(return);
1f12012016-01-13Martin Nilsson  }
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. *!
88d6b12016-08-08Martin Nilsson  *! @throws
c99f522016-09-09Chris Angelico  *! Throws an exception if the object doesn't have a _random method.
88d6b12016-08-08Martin Nilsson  *!
b7a4a02016-01-18Martin Nilsson  *! @seealso *! @[lfun::_random()] */
1f12012016-01-13Martin Nilsson  PIKEFUN mixed random(object o) { int f = low_find_lfun(o->prog, LFUN__RANDOM);
b08a872016-11-15Henrik Grubbström (Grubba)  struct object *co;
1f12012016-01-13Martin Nilsson  if (f < 0) Pike_error("Calling undefined lfun::%s.\n", lfun_names[LFUN__RANDOM]);
b08a872016-11-15Henrik Grubbström (Grubba)  co = Pike_fp->current_object;
d7fdf72016-03-09Martin Nilsson  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  } }
8b27342016-08-06Henrik Grubbström (Grubba) /*! @endclass */
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);
7157b62016-08-28Arne Goedeke  if(TYPEOF(Pike_sp[-1])!=T_STRING || Pike_sp[-1].u.string->len != (ptrdiff_t)len ||
4ae9502016-03-19Martin Nilsson  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
8b27342016-08-06Henrik Grubbström (Grubba) /*! @class RandomSystem */
2918542016-01-15Martin Nilsson PIKECLASS RandomSystem {
8b27342016-08-06Henrik Grubbström (Grubba)  /*! @decl inherit RandomInterface */
2918542016-01-15Martin Nilsson  INHERIT RandomInterface;
8b27342016-08-06Henrik Grubbström (Grubba)  /*! @decl string(8bit) random_string(int(0..) len) *! *! Return a string of random data from the system randomness pool. *! *! On POSIX platforms this reads random data from @tt{/dev/urandom@} *! on other platforms it may use other methods. *! *! @throws *! May throw errors on unexpected state. */
b919a72016-04-02Henrik Grubbström (Grubba)  PIKEFUN string(8bit) random_string(int(0..) len)
2918542016-01-15Martin Nilsson  {
b08a872016-11-15Henrik Grubbström (Grubba)  struct pike_string *ret; char *str;
b919a72016-04-02Henrik Grubbström (Grubba)  if( !len )
7fae652017-08-11Henrik Grubbström (Grubba)  REF_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"); }
b08a872016-11-15Henrik Grubbström (Grubba)  ret = begin_shared_string(len); str = ret->str; if( !CryptGenRandom(crypto_handle, len, (BYTE*)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__ */
52186c2016-09-13Henrik Grubbström (Grubba)  while( random_fd == -1 )
1f12012016-01-13Martin Nilsson  {
ffaa5a2016-01-17Martin Nilsson  random_fd = open("/dev/urandom", O_RDONLY);
52186c2016-09-13Henrik Grubbström (Grubba)  if( random_fd==-1 ) { if (errno == EINTR) continue; /* Retry */
1f12012016-01-13Martin Nilsson  Pike_error("Failed to open /dev/urandom.\n");
52186c2016-09-13Henrik Grubbström (Grubba)  }
1f12012016-01-13Martin Nilsson  }
b08a872016-11-15Henrik Grubbström (Grubba)  ret = begin_shared_string(len); str = ret->str;
1f12012016-01-13Martin Nilsson  while( len ) {
ffaa5a2016-01-17Martin Nilsson  int sz = read(random_fd, str, len);
403a452016-04-02Henrik Grubbström (Grubba)  if (sz < 0) {
52186c2016-09-13Henrik Grubbström (Grubba)  if (errno == EINTR) continue; /* Retry */
403a452016-04-02Henrik Grubbström (Grubba)  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  } }
8b27342016-08-06Henrik Grubbström (Grubba) /*! @endclass */
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 */
b6b1162018-12-18Henrik Grubbström (Grubba) /*! @class FakeObject *! *! Used as a place holder in eg backtraces for objects that *! are unsuitable to have references to in backtraces. *! *! Examples of such objects are instances of @[Thread.MutexKey], *! and @[Nettle.Cipher.State]. *! *! @seealso *! @[backtrace()] */ PIKECLASS FakeObject program_flags PROGRAM_CONSTANT; { PIKEVAR program prog flags ID_PRIVATE|ID_PROTECTED|ID_HIDDEN; PIKEFUN void create(program|function|void prog) flags ID_PROTECTED; { struct program *p = prog ? program_from_svalue(prog):NULL; do_free_program(THIS->prog); THIS->prog = p; if (p) add_ref(p); } PIKEFUN string _sprintf(int c, mapping|void ignored) flags ID_PROTECTED; { push_text("%O()"); if (THIS->prog) { ref_push_program(THIS->prog); } else { ref_push_program(Pike_fp->current_program); } f_sprintf(2); } } /*! @endclass */ static struct object *clone_fake_object(struct program *p) { if (p) ref_push_program(p); else push_undefined(); return clone_object(FakeObject_program, 1); }
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;
c12faf2019-02-06Henrik Grubbström (Grubba)  PIKEVAR array vars; PIKEVAR array _var_names flags ID_PROTECTED|ID_PRIVATE; PIKEVAR array _var_types flags ID_PROTECTED|ID_PRIVATE;
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
aa633e2017-06-25Martin Nilsson  * fun as long as lineno == 0. */
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) 
aa633e2017-06-25Martin Nilsson #ifdef PIKE_NULL_IS_SPECIAL
d27df52001-06-18Henrik Grubbström (Grubba)  INIT {
90f8762002-04-08Martin Stjernholm  THIS->pc = NULL;
aa633e2017-06-25Martin Nilsson  THIS->lineno = 0;
0f47db2001-06-19Henrik Grubbström (Grubba)  THIS->filename = NULL;
d27df52001-06-18Henrik Grubbström (Grubba)  }
aa633e2017-06-25Martin Nilsson #endif
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;
aa633e2017-06-25Martin Nilsson  THIS->lineno = 0;
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)  }
c12faf2019-02-06Henrik Grubbström (Grubba)  static void fill_in_file_and_line(int with_var_info)
73b08f2003-01-31Martin Stjernholm  {
0469ba2004-02-10Martin Stjernholm  struct pike_string *file = NULL;
c12faf2019-02-06Henrik Grubbström (Grubba)  struct local_variable_info vars = { {0,}, {0, }, 0 }; assert ((THIS->lineno == 0) || with_var_info);
73b08f2003-01-31Martin Stjernholm  if (THIS->pc && THIS->prog) {
c12faf2019-02-06Henrik Grubbström (Grubba)  file = low_get_line(THIS->pc, THIS->prog, &THIS->lineno, with_var_info?&vars:NULL);
73b08f2003-01-31Martin Stjernholm  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),
aa633e2017-06-25Martin Nilsson  &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 
c12faf2019-02-06Henrik Grubbström (Grubba)  if (with_var_info) { int i; struct array *names = allocate_array(vars.num_local); struct array *types = allocate_array(vars.num_local); if (THIS->prog) { for (i = 0; i < vars.num_local; i++) { SET_SVAL(ITEM(names)[i], PIKE_T_STRING, 0, string, THIS->prog->strings[vars.names[i]]); add_ref(ITEM(names)[i].u.string); assign_svalue_no_free(ITEM(types) + i, &THIS->prog->constants[vars.types[i]].sval); } } THIS->_var_names = names; THIS->_var_types = types; if (THIS->prog) { free_program(THIS->prog); THIS->prog = NULL; }
73b08f2003-01-31Martin Stjernholm  } }
9cd38a2019-01-11Henrik Grubbström (Grubba)  PIKEFUN string `filename() { if (!THIS->lineno) {
c12faf2019-02-06Henrik Grubbström (Grubba)  fill_in_file_and_line(0);
9cd38a2019-01-11Henrik Grubbström (Grubba)  } if (THIS->filename) { ref_push_string(THIS->filename); return; } push_undefined(); } PIKEFUN string `line() { if (!THIS->lineno) {
c12faf2019-02-06Henrik Grubbström (Grubba)  fill_in_file_and_line(0);
9cd38a2019-01-11Henrik Grubbström (Grubba)  } push_int(THIS->lineno); }
c12faf2019-02-06Henrik Grubbström (Grubba)  PIKEFUN array `->var_names() { if (!THIS->_var_names) { fill_in_file_and_line(1); } ref_push_array(THIS->_var_names); } PIKEFUN array `->var_types() { if (!THIS->_var_types) { fill_in_file_and_line(1); } ref_push_array(THIS->_var_types); }
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)
52efb72018-05-19Henrik Grubbström (Grubba)  flags ID_PROTECTED;
d27df52001-06-18Henrik Grubbström (Grubba)  { 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 
c12faf2019-02-06Henrik Grubbström (Grubba)  if (THIS->lineno == 0) fill_in_file_and_line(0);
73b08f2003-01-31Martin Stjernholm 
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()
52efb72018-05-19Henrik Grubbström (Grubba)  flags ID_PROTECTED;
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)
52efb72018-05-19Henrik Grubbström (Grubba)  flags ID_PROTECTED;
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)
782ed62018-02-22Martin Nilsson  index_error("pike_frame->`[]", args, NULL, Pike_sp-args,
d2cd4e2001-06-18Henrik Grubbström (Grubba)  "Indexing with negative index (%"PRINTPIKEINT"d)\n", index);
d398fc2014-08-25Stephen R. van den Berg  else if (index >= numargs)
782ed62018-02-22Martin Nilsson  index_error("pike_frame->`[]", args, NULL, Pike_sp-args,
d2cd4e2001-06-18Henrik Grubbström (Grubba)  "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 */
c12faf2019-02-06Henrik Grubbström (Grubba)  if (THIS->lineno == 0) fill_in_file_and_line(0);
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 */
c12faf2019-02-06Henrik Grubbström (Grubba)  if (THIS->lineno == 0) fill_in_file_and_line(0);
73b08f2003-01-31Martin Stjernholm  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; }
212c392018-02-25Martin Nilsson  bad_arg_error("`[]", 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)
52efb72018-05-19Henrik Grubbström (Grubba)  flags ID_PROTECTED;
1073bf2001-06-26Henrik Grubbström (Grubba)  {
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))
782ed62018-02-22Martin Nilsson  index_error("pike_frame->`[]=", 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 */
c12faf2019-02-06Henrik Grubbström (Grubba)  if (THIS->lineno == 0) fill_in_file_and_line(0);
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 */
c12faf2019-02-06Henrik Grubbström (Grubba)  if (THIS->lineno == 0) fill_in_file_and_line(0);
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 */
c12faf2019-02-06Henrik Grubbström (Grubba)  if (THIS->lineno == 0) fill_in_file_and_line(0);
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@}.
d11ab12018-06-08Henrik Grubbström (Grubba)  *! @member int "time_size" *! The number of bits in the native @tt{time_t@} type. *! This is typically the same value as @expr{"int_size"@}.
5809812006-03-25Henrik Grubbström (Grubba)  *! @member int "float_size" *! The number of bits in the native floating point type. *! Usually @expr{32@} or @expr{64@}.
bc57862016-05-01Martin Nilsson  *! @member int(1..1) "auto_bignum" *! Integers larger than the native size are now always *! automatically converted into bignums.
5809812006-03-25Henrik Grubbström (Grubba)  *! @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);
d11ab12018-06-08Henrik Grubbström (Grubba)  push_static_text("time_size"); push_int(sizeof(time_t) * 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);
d11ab12018-06-08Henrik Grubbström (Grubba)  f_aggregate_mapping(7*2);
5809812006-03-25Henrik Grubbström (Grubba) }
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) {
cff6342017-06-17Martin Nilsson  struct object *o = fast_clone_object(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) 
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);
21c6462018-01-01Henrik Grubbström (Grubba)  SET_SVAL(bf->_fun, PIKE_T_INT, NUMBER_DESTRUCTED, integer, 0); if (!f->context) { if (f->pc == (void *)do_gc) { SET_SVAL(bf->_fun, PIKE_T_STRING, 0, string, make_shared_string("gc")); } continue; }
fa93a52008-02-28Henrik Grubbström (Grubba)  if ((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)  }
017b572011-10-28Henrik Grubbström (Grubba)  if (f->current_object && f->current_object->prog) {
42d5b32012-01-09Henrik Grubbström (Grubba)  if (f->fun == FUNCTION_BUILTIN) { /* 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) {
c12faf2019-02-06Henrik Grubbström (Grubba)  INT32 numlocals = (INT32)(stack_top - f->locals); INT32 numargs = (INT32) MINIMUM(f->num_args, numlocals);
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 * */
c12faf2019-02-06Henrik Grubbström (Grubba)  numlocals = (INT32)MINIMUM(numlocals, of->locals - f->locals);
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) 
c12faf2019-02-06Henrik Grubbström (Grubba)  numlocals = MAXIMUM(numlocals, 0);
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; }
c12faf2019-02-06Henrik Grubbström (Grubba)  if (numlocals) { bf->vars = allocate_array_no_init(numlocals, 0); bf->vars->type_field = assign_svalues_no_free(bf->vars->item, f->locals, numlocals, BIT_MIXED); if (bf->vars->type_field & BIT_OBJECT) { ptrdiff_t i; for (i = 0; i < bf->vars->size; i++) { /* FIXME: What about arrays of objects (eg varargs). */ struct svalue *s = ITEM(bf->vars) + i; if ((TYPEOF(*s) == T_OBJECT) && s->u.object->prog && (s->u.object->prog->flags & (PROGRAM_DESTRUCT_IMMEDIATE|PROGRAM_CLEAR_STORAGE))) { /* It is typically a bad idea to have extra references * to objects with these flags. The flags are usually * used by stuff like mutex keys and encryption keys * respectively. */ struct object *o = clone_fake_object(s->u.object->prog); free_object(s->u.object); SET_SVAL(*s, T_OBJECT, 0, object, o); } } } }
e89d722002-01-04Henrik Grubbström (Grubba)  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)  }
b6b1162018-12-18Henrik Grubbström (Grubba)  if (bf->args->type_field & BIT_OBJECT) { ptrdiff_t i; for (i = 0; i < bf->args->size; i++) { struct svalue *s = ITEM(bf->args) + i; if ((TYPEOF(*s) == T_OBJECT) && s->u.object->prog && (s->u.object->prog->flags & (PROGRAM_DESTRUCT_IMMEDIATE|PROGRAM_CLEAR_STORAGE))) { /* It is typically a bad idea to have extra references * to objects with these flags. The flags are usually * used by stuff like mutex keys and encryption keys * respectively. */ struct object *o = clone_fake_object(s->u.object->prog); free_object(s->u.object); SET_SVAL(*s, T_OBJECT, 0, object, o); } } }
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); }
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)  }
b498ad2017-12-28Martin Nilsson  else 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)  }
b498ad2017-12-28Martin Nilsson  else if (from_arg->u.array->size != to_arg->u.array->size) {
6f6d2b2006-03-11Henrik Grubbström (Grubba)  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 {
b498ad2017-12-28Martin Nilsson  pop_n_elems(args);
e8c54a2016-02-24Henrik Grubbström (Grubba)  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. */
b498ad2017-12-28Martin Nilsson  pop_n_elems(args);
d5c9e22005-01-07Henrik Grubbström (Grubba)  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);
b498ad2017-12-28Martin Nilsson  pop_n_elems(args);
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); }
b467522017-06-25Martin Nilsson #ifdef PIKE_NULL_IS_SPECIAL
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)  }
b467522017-06-25Martin Nilsson #endif
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; }
b498ad2017-12-28Martin Nilsson  if (!del) { pop_n_elems(args); 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... */
b498ad2017-12-28Martin Nilsson  pop_n_elems(args);
0c4ad02001-07-05Henrik Grubbström (Grubba)  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)  }
b498ad2017-12-28Martin Nilsson  pop_n_elems(args);
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) {
92be2b2017-11-04Arne Goedeke  case eightbit: f = (replace_searchfunc)THIS->mojt.vtab->func0; break; case sixteenbit: f = (replace_searchfunc)THIS->mojt.vtab->func1; break; case thirtytwobit: f = (replace_searchfunc)THIS->mojt.vtab->func2; break;
08ed362018-09-15Henrik Grubbström (Grubba)  default: UNREACHABLE(break);
0c4ad02001-07-05Henrik Grubbström (Grubba)  } 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;
38990e2017-12-30Martin Nilsson  pop_n_elems(2);
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  } 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__",
782ed62018-02-22Martin Nilsson  args,
a241e02001-09-27Fredrik Hübinette (Hubbe)  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)  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 
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  if(d == depth) apply_svalue(fun,args); else low_automap(d+1,depth,fun,real_args,args);
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)  }
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 */
6a66f82018-08-05Marcus Comstedt /*! @class DestructImmediate *! An empty class that can be intherited to get the PROGRAM_DESTRUCT_IMMEDIATE *! flag set. */ PIKECLASS DestructImmediate program_flags PROGRAM_DESTRUCT_IMMEDIATE; { } /*! @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 */
e5ba1c2018-07-01Henrik Grubbström (Grubba) /*! @module __builtin */ /*! @class Stack *! This class implements a simple stack. Instead of adding and removing *! elements to an array, and thus making it vary in size for every push *! and pop operation, this stack tries to keep the stack size constant. *! If however the stack risks to overflow, it will allocate double its *! current size, i.e. pushing an element on an full 32 slot stack will *! result in a 64 slot stack with 33 elements. *! *! @note *! This class is usually accessed as @[ADT.LowLevelStack]. */ PIKECLASS Stack { PIKEVAR array arr; /*! @decl void push(mixed val) *! Push an element on the top of the stack. */ PIKEFUN void push(mixed val) { if (!THIS->arr) { THIS->arr = real_allocate_array(1, 31); array_set_index_no_free(THIS->arr, 0, val); } else { THIS->arr = array_insert(THIS->arr, val, THIS->arr->size); } push_int(0); } /*! @decl mixed top() *! Returns the top element from the stack, without *! popping it. *! @throws *! Throws an error if called on an empty stack. */ PIKEFUN mixed top() { if (THIS->arr && THIS->arr->size) { push_svalue(ITEM(THIS->arr) + THIS->arr->size - 1); return; } Pike_error("Stack underflow\n"); } /*! @decl mixed pop(void|int val) *! Pops and returns entry @[val] from the stack, counting *! from the top. If no value is given the top element is *! popped and returned. All popped entries are freed from *! the stack. */ PIKEFUN mixed pop(void|int val) { if (!THIS->arr || !THIS->arr->size) { Pike_error("Stack underflow\n"); } if (val && (val->u.integer > 0)) { ptrdiff_t new_size; ptrdiff_t old_size; new_size = THIS->arr->size - val->u.integer; if (new_size < 0) new_size = 0; /* NB: Steal reference from the array element. */ *Pike_sp = ITEM(THIS->arr)[new_size]; old_size = THIS->arr->size; THIS->arr->size = new_size; Pike_sp++; free_svalues(ITEM(THIS->arr) + new_size + 1, old_size - (new_size + 1), THIS->arr->type_field); } else { /* NB: Steal reference from the array element. */ THIS->arr->size--; *Pike_sp = ITEM(THIS->arr)[THIS->arr->size]; Pike_sp++; } } /*! @decl void quick_pop(void|int val) *! Pops @[val] entries from the stack, or one entry *! if no value is given. The popped entries are not *! returned. */ PIKEFUN void quick_pop(void|int val) { apply_current(f_Stack_pop_fun_num, args); push_int(0); } /*! @decl void reset(int|void initial_size) *! Empties the stack, resets the stack pointer *! and shrinks the stack size to the given value *! or 32 if none is given. *! @seealso *! @[create] */ PIKEFUN void reset(int|void initial_size) { ptrdiff_t size = 32; if (initial_size && (initial_size->u.integer > 0)) { size = initial_size->u.integer; } if (THIS->arr) { free_array(THIS->arr); THIS->arr = NULL; } /* NB: The initial size MUST != 0 else the empty array will be returned. */ THIS->arr = real_allocate_array(1, size-1); THIS->arr->size = 0; } /*! @decl void create(int|void initial_size) *! An initial stack size can be given when *! a stack is cloned. The default value is *! 32. */ PIKEFUN void create(int|void initial_size) { apply_current(f_Stack_reset_fun_num, args); } /*! @decl void set_stack(array stack) *! Sets the stacks content to the provided array. */ PIKEFUN void set_stack(array stack) { if (THIS->arr) { free_array(THIS->arr); } add_ref(THIS->arr = stack); } /*! @decl int _sizeof() *! @[sizeof] on a stack returns the number of entries *! in the stack. */ PIKEFUN int _sizeof() flags ID_PROTECTED; { push_int(THIS->arr ? THIS->arr->size : 0); } /*! @decl array _values() *! @[values] on a stack returns all the entries in *! the stack, in order. */ PIKEFUN array _values() flags ID_PROTECTED; { if (THIS->arr) { push_array(copy_array(THIS->arr)); } else { ref_push_array(&empty_array); } } /*! @decl int _search(mixed item) *! Return the stack-depth to @[item]. *! *! This function makes it possible to use *! eg @[search()] and @[has_value()] on the stack. */ PIKEFUN int _search(mixed item) flags ID_PROTECTED; { if (!THIS->arr || !THIS->arr->size) { push_int(-1); } else { push_int(array_search(THIS->arr, item, 0)); } } /*! @decl this_program `+(this_program s) *! A stack added with another stack yields a new *! stack with all the elements from both stacks, *! and the elements from the second stack at the *! top of the new stack. */ PIKEFUN Stack `+(Stack s) flags ID_PROTECTED; { struct Stack_struct *other_st = get_storage(s, Stack_program); int cnt = 0; if (!other_st) { SIMPLE_BAD_ARG_ERROR("`+", 1, "Stack"); } if (THIS->arr) { ref_push_array(THIS->arr); cnt++; } if (other_st->arr) { ref_push_array(other_st->arr); cnt++; } if (cnt == 1) { ref_push_array(&empty_array); } if (cnt) { f_add(2); #ifdef PIKE_DEBUG if (TYPEOF(Pike_sp[-1]) != PIKE_T_ARRAY) { Pike_fatal("Stack addition failure.\n"); } #endif push_object(s = fast_clone_object(Stack_program)); other_st = get_storage(s, Stack_program); #ifdef PIKE_DEBUG if (!other_st) { Pike_fatal("Stack lost storage.\n"); } #endif add_ref(other_st->arr = Pike_sp[-2].u.array); return; } push_object(clone_object(Stack_program, 0)); } PIKEFUN mixed cast(string to) flags ID_PROTECTED; { if( to == MK_STRING("array") ) { apply_current(f_Stack_cq__values_fun_num, 0); } else { push_undefined(); } } PIKEFUN string _sprintf(int t) flags ID_PROTECTED; { if (t != '0') { push_undefined(); } push_constant_text("%O%O"); ref_push_program(Pike_fp->current_program); apply_current(f_Stack_cq__values_fun_num, 0); f_sprintf(3); } } /*! @endclass */ /*! @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"); } }
76a8f52017-02-07Henrik Grubbström (Grubba) #undef DEFAULT_CMOD_STORAGE #define DEFAULT_CMOD_STORAGE static PIKECLASS pike_trampoline { CVAR struct pike_trampoline trampoline; DECLARE_STORAGE;
b467522017-06-25Martin Nilsson #ifdef PIKE_NULL_IS_SPECIAL
76a8f52017-02-07Henrik Grubbström (Grubba)  INIT { THIS->trampoline.frame=0; }
b467522017-06-25Martin Nilsson #endif
76a8f52017-02-07Henrik Grubbström (Grubba)  EXIT { if(THIS->trampoline.frame) { free_pike_scope(THIS->trampoline.frame); THIS->trampoline.frame=0; } } static void gc_check_frame(struct pike_frame *f) { if(f->flags & PIKE_FRAME_MALLOCED_LOCALS) { if(f->current_object) debug_gc_check (f->current_object, " as current_object in trampoline frame"); if(f->current_program) debug_gc_check (f->current_program, " as current_program in trampoline frame"); debug_gc_check_svalues (f->locals, f->num_locals, " in locals of trampoline frame"); if(f->scope && !debug_gc_check (f->scope, " as scope frame of trampoline frame")) gc_check_frame(f->scope); } } GC_CHECK { if (THIS->trampoline.frame && !debug_gc_check(THIS->trampoline.frame, " as trampoline frame")) gc_check_frame(THIS->trampoline.frame); } static void gc_recurse_frame(struct pike_frame *f) { if(f->current_object) gc_recurse_object(f->current_object); if(f->current_program) gc_recurse_program(f->current_program); if(f->flags & PIKE_FRAME_MALLOCED_LOCALS) gc_recurse_svalues(f->locals,f->num_locals); if(f->scope) gc_recurse_frame(f->scope); } GC_RECURSE { if (THIS->trampoline.frame) gc_recurse_frame(THIS->trampoline.frame); } PIKEFUN void `()(mixed ... ignored) { Pike_error("Internal error: Trampoline magic failed!\n"); } PIKEFUN int(0..1) `!() { if (!THIS->trampoline.frame || !THIS->trampoline.frame->current_object || !THIS->trampoline.frame->current_object->prog) { push_int(1); } else { push_int(0); } } PIKEFUN string _sprintf(int c, mapping|void opts) { struct byte_buffer buf = BUFFER_INIT(); if (!args || TYPEOF(Pike_sp[-args]) != T_INT || Pike_sp[-args].u.integer != 'O' || !THIS->trampoline.frame || !THIS->trampoline.frame->current_object) { pop_n_elems (args); push_int (0); return; } pop_n_elems (args); ref_push_function (THIS->trampoline.frame->current_object, THIS->trampoline.func); describe_svalue (&buf, Pike_sp - 1, 0, 0); pop_stack(); push_string(buffer_finish_pike_string(&buf)); } }
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) }