1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
74
  
75
  
76
  
77
  
78
  
79
  
80
  
81
  
82
  
83
  
84
  
85
  
86
  
87
  
88
  
89
  
90
  
91
  
92
  
93
  
94
  
95
  
96
  
97
  
98
  
99
  
100
  
101
  
102
  
103
  
104
  
105
  
106
  
#include "global.h" 
#include "interpret.h" 
#include "svalue.h" 
#include "opcodes.h" 
#include "pike_macros.h" 
#include "object.h" 
#include "program.h" 
#include "array.h" 
#include "error.h" 
#include "constants.h" 
#include "mapping.h" 
#include "stralloc.h" 
#include "multiset.h" 
#include "pike_types.h" 
#include "pike_memory.h" 
#include "threads.h" 
#include <math.h> 
#include <ctype.h> 
#include "module_support.h" 
#include "cyclic.h" 
#include "bignum.h" 
#include "main.h" 
 
 
PIKEFUN array column(array tmp, mixed val) 
  efun; 
  optflags OPT_TRY_OPTIMIZE; 
{ 
  INT32 e; 
  struct array *a; 
 
  DECLARE_CYCLIC(); 
 
  /* Optimization */ 
  if(tmp->refs == 1) 
  { 
    /* An array with one ref cannot possibly be cyclic */ 
    struct svalue sval; 
    tmp->type_field = BIT_MIXED | BIT_UNFINISHED; 
    for(e=0;e<tmp->size;e++) 
    { 
      index_no_free(&sval, ITEM(tmp)+e, val); 
      free_svalue(ITEM(tmp)+e); 
      ITEM(tmp)[e]=sval; 
    } 
    pop_stack(); 
    return; 
  } 
 
  if((a=(struct array *)BEGIN_CYCLIC(tmp,0))) 
  { 
    add_ref(a); 
  }else{ 
    push_array(a=allocate_array(tmp->size)); 
    SET_CYCLIC_RET(a); 
 
    for(e=0;e<a->size;e++) 
      index_no_free(ITEM(a)+e, ITEM(tmp)+e, val); 
 
    sp--; 
  } 
  END_CYCLIC(); 
  RETURN a; 
} 
 
PIKEFUN multiset(1) mkmultiset(array(1=mixed) a) 
  efun; 
  optflags OPT_TRY_OPTIMIZE; 
{ 
  RETURN mkmultiset(a); 
} 
 
PIKEFUN int trace(int t) 
  efun; 
  optflags OPT_SIDE_EFFECT; 
{ 
  pop_n_elems(args); 
  push_int(t_flag); 
  t_flag=t; 
} 
 
PIKEFUN string ctime(int x) 
  efun; 
  optflags OPT_TRY_OPTIMIZE; 
{ 
  time_t i=(time_t)x; 
  RETURN make_shared_string(ctime(&i)); 
} 
 
PIKEFUN mapping(1:2) mkmapping(array(1=mixed) a, array(2=mixed) b) 
  efun; 
  optflags OPT_TRY_OPTIMIZE; 
{ 
  if(a->size != b->size) 
    bad_arg_error("mkmapping", sp-args, args, 2, "array", sp+1-args, 
                  "mkmapping called on arrays of different sizes (%d != %d)\n", 
                  a->size, b->size); 
 
  RETURN mkmapping(a,b); 
} 
 
void init_builtin(void) 
{ 
INIT 
}