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
  
107
  
108
  
109
  
110
  
111
  
112
  
113
  
114
  
115
  
116
  
117
  
118
  
119
  
120
  
121
  
122
  
123
  
124
  
125
  
126
  
127
  
128
  
129
  
130
  
131
  
This is what you need to do to install Pike: 
 
1) Run ./configure, this is a sh script that will generate machine.h and 
   Makefile from machine.h.in and Makefile.in. 
 
  Some options for ./configure are: 
  --prefix=/foo/bar         if you want to install Pike in /foo/bar, 
                            default is /usr/local. 
  --without-gdbm            compile without gdbm support 
  --without-gmp             compile without gmp support 
  --without-rtldebug        compile without runtime debugging 
  --without-cdebug          compile without debug symbols (-g) 
  --without-debug           compile without rtldbug and cdebug 
  --without-threads         compile without threads support (See below) 
  --without-zlib            compile without gzip compression libary support 
  --without-dynamic-modules compile statically, no dynamic loading used. 
                            (makes binary larger) 
  --without-mysql           compile without mysql support 
  --with-profiling          enables profiling pike code but slows 
                            down interpreter a little 
  --with-poll               use poll instead of select 
  --with-dmalloc            compile with memory tracking, makes pike 
                            very slow, use for debugging only. 
  --without-copt            compile without -O2 
  --without-bignums         disable support for large integers 
  --with-security           enable internal object security system 
 
   You might also want to set the following environment variables: 
   CFLAGS     Put extra flags for your C compiler here. 
   CPPFLAGS   Put extra flags for your C preprocessor here 
              (such as -I/usr/gnu/include) 
   LDFLAGS    Put extra flags to your linker here, such as -L/usr/gnu/lib 
              and -R/usr/gnu/lib 
 
   Use the above flags to make sure the configure script finds the 
   gdbm and gmp libraries and include files if you need or want those 
   modules. If the configure script doesn't find them, Pike will still 
   compile, but without those modules. 
 
2) If needed, edit config.h and Makefile to suit your purposes. 
   I've tried to make it so that you don't have to change config.h or 
   Makefile at all. If you need to do what you consider 'unnessecary 
   changes' then mail me and I'll try to fit it into configure.  If 
   possible, use gnu make, gcc, gnu sed and bison. 
 
3) Run make. 
 
4) Optionally, run 'make verify' to check that the compiled driver works 
   as it should (might be a good idea) This will take a little time 
   and use quite a lot of memory, because the testprogram is quite 
   large. If everything works out fine no extra messages are written. 
 
5) If you want to install Pike, write 'make install' 
 
6) Optionally do 'make html_docs' to create a directory called docs which 
   will contain the Pike documentation in html. This directory can then 
   be copied to anywhere you want. 
 
IF IT DOESN'T WORK: 
 
 o Try again. 
 
 o Your sh might be too buggy to run ./configure. (This is the case on A/UX) 
   Try using bash, zsh or possibly ksh. To use bash, first run /bin/sh and 
   type: 
   $ CONFIG_SHELL=full_path_for_bash 
   $ export CONFIG_SHELL 
   $ $CONFIG_SHELL ./configure 
 
 o If you are not using GNU make, compile in he source dir rather than 
   using a separate build dir. 
 
 o ./configure relies heavily on sed, if you have several sed in your path 
   try another sed. (preferably gnu sed) 
 
 o configure might have done something wrong, check machine.h and report 
   any errors back to me. 
 
 o Your gmp/gdbm libraries might not be working or incorrectly  
   installed, start over by running configure with the approperiate 
   --without-xxx arguments. Also note that threads might give problems 
   with I/O and signals. If so you need to run configure --without-threads. 
 
 o Try a different compiler, malloc, compiler-compiler and/or make. 
   (if you have any other) 
 
 
 
THREADS SUPPORT 
 
Getting threads support might be hairy on some platforms, most platforms 
have threads support but quite a few have problems running external 
processes (through create_process). By default threads support is disabled 
on platforms where threading is known not to work 100% properly. 
 
IRIX: Starting many processes causes a resource error which 
      sometimes causes a complete hang and 100% cpu usage. 
 
FreeBSD 3.x: Symptoms are similar to IRIX, but the problem has 
      something to do with signal handling. (And as you may know, 
      process handling uses signals on UNIX...) 
 
Linux: Not all linux variations have 100% working threads, in 
      fact most libc5 systems do not work very well with threads. 
      Threads support is enabled by default on Linux, but I 
      recommend running 'make verify' after compilation. This 
      will (hopefully) tell you if your threads are not working. 
 
 
BUGS 
 
If you find a bug in the interpreter, the first thing to do is to make sure 
the interpreter is compiled with PIKE_DEBUG defined. If not, recompile with 
PIKE_DEBUG and see if you get another error. When you've done this, please 
report the bug to hubbe@hubbe.net and include as much as you can muster of 
the following: 
 
  o The version of the driver. (Try pike --version or look in src/version.h) 
  o What kind of system hardware/software you use (OS, compiler, etc.) 
  o The piece of code that crashes or bugs. 
    (preferably in a very small pike-script with the bug isolated) 
    Please send a complete running example of something that makes the 
    interpreter bug. 
  o A description of what it is that bugs and when. 
  o If you know how, then also give me a backtrace and dump of vital variables 
    at the point of crash. 
  o Or, if you found the error and corrected it, just send me the bugfix along 
    with a description of what you did and why. 
 
  /Fredrik Hubinette