summaryrefslogtreecommitdiffstats
path: root/src/RELEASE.txt
blob: 0dab6ce6f9f7d482d9ece2d9a20281a66dbdf64d (plain)
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
# Copyright (c) 2001, 2002 Steven Knight
# __FILE__ __REVISION__ __DATE__ __DEVELOPER__


                 SCons - a software construction tool

                            Release Notes


This is an alpha release of SCons, a tool for building software (and
other files).  SCons is implemented in Python, and its "configuration
files" are actually Python scripts, allowing you to use the full power
of a real scripting language to solve build problems.  You do not,
however, need to know Python to use SCons effectively.

So that everyone using SCons can help each other learn how to use it
more effectively, please sign up for the scons-users mailing list at:

    http://lists.sourceforge.net/lists/listinfo/scons-users



RELEASE 0.08 - Mon, 15 Jul 2002 12:08:51 -0500

  This is the eighth alpha release of SCons.  Please consult the
  CHANGES.txt file for a list of specific changes since last release.

  Please note the following important changes since release 0.07:

    - Builder objects no longer automatically split target and source
      file strings on white space.  SCons will interpret the string
      arguments for the target or source files as the complete name of
      the file, even if the name contains white space.

      Consequently, any builder calls that you have defined which supply
      multiple file names in a single string, such as:

          env.Program(target = 'foo', source = 'f1.c f2.c')

      These calls will need to be changed by next release.  You may
      either split up the string into an array of individual file name
      strings by hand:

          env.Program(target = 'foo', source = ['f1.c', 'f2.c'])

      Or you may use the newly-provided Split() function to turn a
      string of white-space separated file names into an array:

          env.Program(target = 'foo', source = Split('f1.c f2.c'))

      The Split() function preserves the functionality that the builder
      objects currently invoke internally: if the argument is a string,
      it will be split on white space; if the argument is already a list,
      the list will be returned.

      (You may, of course, also use the string.split() function from
      the standard Python library to convert your strings.)

   -  The Object and Library builders no longer use the "shared"
      keyword argument to specify if the target object or library is a
      shared library.  Instead, separate StaticObject, SharedObject,
      StaticLibrary and SharedLibrary builders exist to explicitly build
      the appropriate target.  The Object and Library buidlers are now
      synonyms for StaticObject and StaticLibrary, respecitvely.

    - The prefix, suffix, and src_suffix keyword arguments to the
      Builder() function may no longer be callable functions.

  Please note the following important changes since release 0.06:

    - The functionality of the -U option has changed.  It now works
      exactly like the -u option (searches up the directory tree for an
      SConstruct file) but, when no targets are specified on the command
      line, it will build all targets that are defined in any SConscript
      files in the current directory.

      The previous functionality of this option is now available in the
      -D option:  when no targets are specified on the command line,
      SCons will build *all* Default() targets, not just those at or
      below the current directory,

    - The default Fortran compilation command on Windows systems now
      uses Windows conventions (/Fo) instead of UNIX conventions (-o).

    - The $SOURCE construction variable is now a synonym for
      ${SOURCES[0]}.  This will affect you if you previously set $SOURCE
      explicitly in a construction environment.

    - Scanner functions now take three or four arguments.  The target
      Node is now passed in as the third argument; the fourth argument
      is an optional SCons.Node.FS.FS object.  You will need to update
      the interfaces of any local Scanner functions you have defined.

    - Command generator functions now take a fourth argument,
      for_signature.  You will need to add this argument to any
      generator functions you have defined.

  Owing to an extensive test suite, the SCons team believes that this
  release is of sufficient quality that you can use it for real work,
  despite the "alpha" label.

  Nevertheless, because this is an alpha release, heed the following
  disclaimers:

    - There may, of course, be bugs.  Please report any bugs or other
      problems that you find to our bug tracker at our SourceForge
      project page:

      http://sourceforge.net/tracker/?func=add&group_id=30337&atid=398971

      We have a reliable bug-fixing methodology already in place and aim
      to respond to problems relatively quickly.

    - It is possible that interfaces will change in future releases.  We
      will strive to hold this to a minimum, but you may need to modify
      your SConscript files in the future if there is a compelling reason
      to change an interface.

    - Documentation is spottier than we'd like.  You may need to dive
      into the source code to figure out how to do something.  Asking
      questions on the scons-users mailing list is also welcome.  We
      will be addressing the documentation in upcoming releases, but
      would be more than glad to have your assistance in correcting this
      problem... :-)

      In particular, the "SCons Design" documentation on the SCons web
      site is currently out of date, as we made significant changes to
      portions of the interface as we figured out what worked and what
      didn't during implementation.L

    - There may be performance issues.  Improving SCons performance
      is an ongoing priority.  If you still find the performance
      unacceptable, we would very much like to hear from you and learn
      more about your configuration so we can optimize the right things.

    - Error messages don't always exist where they'd be helpful.
      Please let us know about any errors you ran into that would
      have benefitted from a (more) descriptive message.

  KNOWN PROBLEMS IN THIS RELEASE:

    For a complete list of known problems, consult the SCons bug tracker
    page at SourceForge:

        http://sourceforge.net/tracker/?atid=398971&group_id=30337&func=browse

    - Support for parallel builds (-j) does not work on WIN32 systems
      prior to *official* Python release 2.2 (not 2.2 pre-releases).

      Prior to Python 2.2, there is a bug in Python's Win32
      implementation such that when a thread spawns an external command,
      it blocks all threads from running.  This breaks the SCons
      multithreading architecture used to support -j builds.

      We have included a patch file, os_spawnv_fix.diff, that you can
      use if you you want to fix your version of Python to support
      parallel builds in SCons.

    - Again, the "SCons Design" documentation on the SCons web
      site is currently out of date.  Take what you read there with a
      grain of salt.

    - SCons does not yet support file names with quotes (" or ') in the
      file name when an external command is used to create or process a
      file.  Results will be unpredictable based on the interaction with
      the shell used to execute the external command.

    - If a file is specified to be built in multiple ways, the last
      processed builder specification overwrites all other builders,
      without any warning.

    - There is not yet a mechanism to configure using file timestamps
      instead of MD5 signatures to determine if a file is up-to-date.

    - Executing the -u or -U option from a source directory that has an
      associated BuildDir() does not build the targets in the BuildDir().

    - No support yet for the following future features:

        - Configurable signature calculation

        - No support for caching built files.

        - No support yet for the following command-line options:

             -d -e -l --list-actions --list-derived --list-where
             -o -p -r -R --random -w --write-filenames -W
             --warn-undefined-variables

  Thank you for your interest, and please let us know how we can help
  improve SCons for your needs.