|
7017
|
1 ## Copyright (C) 2005, 2006, 2007 S�ren Hauberg |
|
5801
|
2 ## |
|
6440
|
3 ## This file is part of Octave. |
|
|
4 ## |
|
|
5 ## Octave is free software; you can redistribute it and/or modify it |
|
|
6 ## under the terms of the GNU General Public License as published by |
|
7016
|
7 ## the Free Software Foundation; either version 3 of the License, or (at |
|
|
8 ## your option) any later version. |
|
6440
|
9 ## |
|
|
10 ## Octave is distributed in the hope that it will be useful, but |
|
|
11 ## WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
12 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
|
13 ## General Public License for more details. |
|
|
14 ## |
|
5801
|
15 ## You should have received a copy of the GNU General Public License |
|
7016
|
16 ## along with Octave; see the file COPYING. If not, see |
|
|
17 ## <http://www.gnu.org/licenses/>. |
|
5801
|
18 |
|
|
19 ## -*- texinfo -*- |
|
6032
|
20 ## @deftypefn {Command} pkg @var{command} @var{pkg_name} |
|
|
21 ## @deftypefnx {Command} pkg @var{command} @var{option} @var{pkg_name} |
|
|
22 ## This command interacts with the package manager. Different actions will |
|
6378
|
23 ## be taken depending on the value of @var{command}. |
|
6032
|
24 ## |
|
|
25 ## @table @samp |
|
|
26 ## @item install |
|
6070
|
27 ## Install named packages. For example, |
|
|
28 ## @example |
|
|
29 ## pkg install image-1.0.0.tar.gz |
|
|
30 ## @end example |
|
|
31 ## @noindent |
|
|
32 ## installs the package found in the file @code{image-1.0.0.tar.gz}. |
|
|
33 ## |
|
6645
|
34 ## The @var{option} variable can contain options that affect the manner |
|
|
35 ## in which a package is installed. These options can be one or more of |
|
|
36 ## |
|
|
37 ## @table @code |
|
|
38 ## @item -nodeps |
|
|
39 ## The package manager will disable the dependency checking. That way it |
|
|
40 ## is possible to install a package even if it depends on another package |
|
|
41 ## that's not installed on the system. @strong{Use this option with care.} |
|
|
42 ## |
|
|
43 ## @item -noauto |
|
|
44 ## The package manager will not automatically load the installed package |
|
|
45 ## when starting Octave, even if the package requests that it is. |
|
6258
|
46 ## |
|
6645
|
47 ## @item -auto |
|
|
48 ## The package manager will automatically load the installed package when |
|
|
49 ## starting Octave, even if the package requests that it isn't. |
|
|
50 ## |
|
|
51 ## @item -local |
|
|
52 ## A local installation is forced, even if the user has system privileges. |
|
6258
|
53 ## |
|
6645
|
54 ## @item -global |
|
|
55 ## A global installation is forced, even if the user doesn't normally have |
|
|
56 ## system privileges |
|
6614
|
57 ## |
|
6645
|
58 ## @item -verbose |
|
|
59 ## The package manager will print the output of all of the commands that are |
|
|
60 ## performed. |
|
|
61 ## @end table |
|
|
62 ## |
|
6032
|
63 ## @item uninstall |
|
6070
|
64 ## Uninstall named packages. For example, |
|
|
65 ## @example |
|
|
66 ## pkg uninstall image |
|
|
67 ## @end example |
|
|
68 ## @noindent |
|
|
69 ## removes the @code{image} package from the system. If another installed |
|
|
70 ## package depends on the @code{image} package an error will be issued. |
|
|
71 ## The package can be uninstalled anyway by using the @code{-nodeps} option. |
|
6032
|
72 ## @item load |
|
6070
|
73 ## Add named packages to the path. After loading a package it is |
|
|
74 ## possible to use the functions provided by the package. For example, |
|
|
75 ## @example |
|
|
76 ## pkg load image |
|
|
77 ## @end example |
|
|
78 ## @noindent |
|
|
79 ## adds the @code{image} package to the path. It is possible to load all |
|
|
80 ## installed packages at once with the command |
|
|
81 ## @example |
|
|
82 ## pkg load all |
|
|
83 ## @end example |
|
6203
|
84 ## @item unload |
|
|
85 ## Removes named packages from the path. After unloading a package it is |
|
|
86 ## no longer possible to use the functions provided by the package. |
|
|
87 ## This command behaves like the @code{load} command. |
|
6032
|
88 ## @item list |
|
6070
|
89 ## Show a list of the currently installed packages. By requesting one or two |
|
|
90 ## output argument it is possible to get a list of the currently installed |
|
|
91 ## packages. For example, |
|
|
92 ## @example |
|
|
93 ## installed_packages = pkg list; |
|
|
94 ## @end example |
|
|
95 ## @noindent |
|
|
96 ## returns a cell array containing a structure for each installed package. |
|
|
97 ## The command |
|
|
98 ## @example |
|
|
99 ## [@var{user_packages}, @var{system_packages}] = pkg list |
|
|
100 ## @end example |
|
|
101 ## @noindent |
|
|
102 ## splits the list of installed packages into those who are installed by |
|
|
103 ## the current user, and those installed by the system administrator. |
|
7497
|
104 ## @item describe |
|
|
105 ## Show a short description of the named installed packages, with the option |
|
|
106 ## '-verbose' also list functions provided by the package, e.g.: |
|
|
107 ## @example |
|
|
108 ## pkg describe -verbose all |
|
|
109 ## @end example |
|
|
110 ## @noindent |
|
|
111 ## will describe all installed packages and the functions they provide. |
|
|
112 ## If one output is requested a cell of structure containing the |
|
|
113 ## description and list of functions of each package is returned as |
|
|
114 ## output rather than printed on screen: |
|
|
115 ## @example |
|
|
116 ## desc = pkg ("describe", "secs1d", "image") |
|
|
117 ## @end example |
|
|
118 ## @noindent |
|
|
119 ## If any of the requested packages is not installed, pkg returns an |
|
|
120 ## error, unless a second output is requested: |
|
|
121 ## @example |
|
|
122 ## [ desc, flag] = pkg ("describe", "secs1d", "image") |
|
|
123 ## @end example |
|
|
124 ## @noindent |
|
|
125 ## @var{flag} will take one of the values "Not installed", "Loaded" or |
|
|
126 ## "Not loaded" for each of the named packages. |
|
6034
|
127 ## @item prefix |
|
6070
|
128 ## Set the installation prefix directory. For example, |
|
|
129 ## @example |
|
|
130 ## pkg prefix ~/my_octave_packages |
|
|
131 ## @end example |
|
|
132 ## @noindent |
|
|
133 ## sets the installation prefix to @code{~/my_octave_packages}. |
|
|
134 ## Packages will be installed in this directory. |
|
6034
|
135 ## |
|
6070
|
136 ## It is possible to get the current installation prefix by requesting an |
|
|
137 ## output argument. For example, |
|
|
138 ## @example |
|
|
139 ## p = pkg prefix |
|
|
140 ## @end example |
|
6925
|
141 ## |
|
|
142 ## The location in which to install the architecture dependent files can be |
|
|
143 ## independent specified with an addition argument. For example |
|
|
144 ## |
|
|
145 ## @example |
|
|
146 ## pkg prefix ~/my_octave_packages ~/my_octave_packages_for_my_pc |
|
|
147 ## @end example |
|
6189
|
148 ## @item local_list |
|
|
149 ## Set the file in which to look for information on the locally |
|
|
150 ## installed packages. Locally installed packages are those that are |
|
|
151 ## typically available only to the current user. For example |
|
|
152 ## @example |
|
|
153 ## pkg local_list ~/.octave_packages |
|
|
154 ## @end example |
|
|
155 ## It is possible to get the current value of local_list with the following |
|
|
156 ## @example |
|
|
157 ## pkg local_list |
|
|
158 ## @end example |
|
|
159 ## @item global_list |
|
|
160 ## Set the file in which to look for, for information on the globally |
|
|
161 ## installed packages. Globally installed packages are those that are |
|
|
162 ## typically available to all users. For example |
|
|
163 ## @example |
|
|
164 ## pkg global_list /usr/share/octave/octave_packages |
|
|
165 ## @end example |
|
|
166 ## It is possible to get the current value of global_list with the following |
|
|
167 ## @example |
|
|
168 ## pkg global_list |
|
|
169 ## @end example |
|
6645
|
170 ## @item rebuild |
|
|
171 ## Rebuilds the package database from the installed directories. This can |
|
|
172 ## be used in cases where for some reason the package database is corrupted. |
|
|
173 ## It can also take the @code{-auto} and @code{-noauto} options to allow the |
|
|
174 ## autolaoding state of a package to be changed. For example |
|
|
175 ## |
|
|
176 ## @example |
|
|
177 ## pkg rebuild -noauto image |
|
|
178 ## @end example |
|
|
179 ## |
|
|
180 ## will remove the autoloading status of the image package. |
|
6675
|
181 ## @item build |
|
|
182 ## Builds a binary form of a package or packages. The binary file produced |
|
|
183 ## will itself be an Octave package that can be installed normally with |
|
|
184 ## @code{pkg}. The form of the command to build a binary package is |
|
|
185 ## |
|
|
186 ## @example |
|
|
187 ## pkg build builddir image-1.0.0.tar.gz @dots{} |
|
|
188 ## @end example |
|
|
189 ## |
|
|
190 ## @noindent |
|
|
191 ## where @code{buiddir} is the name of a directory where the temporary |
|
|
192 ## installation will be produced and the binary packages will be found. |
|
|
193 ## The options @code{-verbose} and @code{-nodeps} are respected, while |
|
|
194 ## the other options are ignored. |
|
6032
|
195 ## @end table |
|
5801
|
196 ## @end deftypefn |
|
5947
|
197 |
|
|
198 ## PKG_ADD: mark_as_command pkg |
|
|
199 |
|
6496
|
200 function [local_packages, global_packages] = pkg (varargin) |
|
|
201 ## Installation prefix (XXX: what should these be on windows?) |
|
6645
|
202 persistent user_prefix = false; |
|
6496
|
203 persistent prefix = -1; |
|
6925
|
204 persistent archprefix = -1; |
|
7498
|
205 persistent local_list = tilde_expand (fullfile ("~", ".octave_packages")); |
|
6496
|
206 persistent global_list = fullfile (OCTAVE_HOME (), "share", "octave", |
|
|
207 "octave_packages"); |
|
|
208 mlock (); |
|
6189
|
209 |
|
6925
|
210 global_install = issuperuser (); |
|
6683
|
211 |
|
6496
|
212 if (prefix == -1) |
|
6645
|
213 if (global_install) |
|
6496
|
214 prefix = fullfile (OCTAVE_HOME (), "share", "octave", "packages"); |
|
7498
|
215 archprefix = fullfile (octave_config_info ("libexecdir"), |
|
|
216 "octave", "packages"); |
|
6496
|
217 else |
|
|
218 prefix = fullfile ("~", "octave"); |
|
6925
|
219 archprefix = prefix; |
|
5801
|
220 endif |
|
6645
|
221 prefix = tilde_expand (prefix); |
|
6925
|
222 archprefix = tilde_expand (archprefix); |
|
6496
|
223 endif |
|
|
224 |
|
7498
|
225 available_actions = {"list", "install", "uninstall", "load", ... |
|
|
226 "unload", "prefix", "local_list", ... |
|
|
227 "global_list", "rebuild", "build","describe"}; |
|
6496
|
228 ## Handle input |
|
|
229 if (length (varargin) == 0 || ! iscellstr (varargin)) |
|
|
230 print_usage (); |
|
|
231 endif |
|
|
232 files = {}; |
|
|
233 deps = true; |
|
|
234 auto = 0; |
|
|
235 action = "none"; |
|
6614
|
236 verbose = false; |
|
6496
|
237 for i = 1:length (varargin) |
|
|
238 switch (varargin{i}) |
|
|
239 case "-nodeps" |
|
|
240 deps = false; |
|
|
241 case "-noauto" |
|
|
242 auto = -1; |
|
|
243 case "-auto" |
|
|
244 auto = 1; |
|
6614
|
245 case "-verbose" |
|
|
246 verbose = true; |
|
6645
|
247 case "-local" |
|
|
248 global_install = false; |
|
|
249 if (! user_prefix) |
|
6729
|
250 prefix = tilde_expand (fullfile ("~", "octave")); |
|
6645
|
251 endif |
|
|
252 case "-global" |
|
|
253 global_install = true; |
|
|
254 if (! user_prefix) |
|
|
255 prefix = fullfile (OCTAVE_HOME (), "share", "octave", "packages"); |
|
|
256 endif |
|
7497
|
257 case available_actions |
|
6925
|
258 if (strcmp (action, "none")) |
|
6687
|
259 action = varargin{i}; |
|
|
260 else |
|
|
261 error ("more than one action specified"); |
|
|
262 endif |
|
6496
|
263 otherwise |
|
|
264 files{end+1} = varargin{i}; |
|
5801
|
265 endswitch |
|
6496
|
266 endfor |
|
|
267 |
|
|
268 ## Take action |
|
|
269 switch (action) |
|
|
270 case "list" |
|
|
271 if (nargout == 0) |
|
|
272 installed_packages (local_list, global_list); |
|
|
273 elseif (nargout == 1) |
|
|
274 local_packages = installed_packages (local_list, global_list); |
|
|
275 elseif (nargout == 2) |
|
|
276 [local_packages, global_packages] = installed_packages (local_list, |
|
|
277 global_list); |
|
|
278 else |
|
|
279 error ("too many output arguments requested"); |
|
|
280 endif |
|
|
281 |
|
|
282 case "install" |
|
|
283 if (length (files) == 0) |
|
|
284 error ("you must specify at least one filename when calling 'pkg install'"); |
|
|
285 endif |
|
6925
|
286 install (files, deps, auto, prefix, archprefix, verbose, local_list, |
|
6645
|
287 global_list, global_install); |
|
6496
|
288 |
|
|
289 case "uninstall" |
|
|
290 if (length (files) == 0) |
|
|
291 error ("you must specify at least one package when calling 'pkg uninstall'"); |
|
|
292 endif |
|
6645
|
293 uninstall (files, deps, verbose, local_list, |
|
|
294 global_list, global_install); |
|
6496
|
295 |
|
|
296 case "load" |
|
|
297 if (length (files) == 0) |
|
|
298 error ("you must specify at least one package, 'all' or 'auto' when calling 'pkg load'"); |
|
|
299 endif |
|
|
300 load_packages (files, deps, local_list, global_list); |
|
|
301 |
|
|
302 case "unload" |
|
|
303 if (length (files) == 0) |
|
|
304 error ("you must specify at least one package or 'all' when calling 'pkg unload'"); |
|
|
305 endif |
|
|
306 unload_packages (files, deps, local_list, global_list); |
|
|
307 |
|
|
308 case "prefix" |
|
|
309 if (length (files) == 0 && nargout == 0) |
|
6925
|
310 printf ("Installation prefix: %s\n", prefix); |
|
|
311 printf ("Architecture dependent prefix: %s\n", archprefix); |
|
|
312 elseif (length (files) == 0 && nargout >= 1) |
|
6496
|
313 local_packages = prefix; |
|
6925
|
314 global_packages = archprefix; |
|
|
315 elseif (length (files) >= 1 && nargout <= 2 && ischar (files{1})) |
|
6496
|
316 prefix = files{1}; |
|
6675
|
317 prefix = absolute_pathname (prefix); |
|
|
318 local_packages = prefix; |
|
6645
|
319 user_prefix = true; |
|
6925
|
320 if (length (files) >= 2 && ischar (files{2})) |
|
|
321 archprefix = files{2}; |
|
|
322 try |
|
|
323 archprefix = absolute_pathname (archprefix); |
|
|
324 catch |
|
|
325 mkdir (archprefix); |
|
|
326 warning ("creating the directory %s\n", archprefix); |
|
|
327 archprefix = absolute_pathname (archprefix); |
|
|
328 end_try_catch |
|
|
329 global_packages = archprefix; |
|
|
330 endif |
|
6496
|
331 else |
|
|
332 error ("you must specify a prefix directory, or request an output argument"); |
|
|
333 endif |
|
|
334 |
|
|
335 case "local_list" |
|
|
336 if (length (files) == 0 && nargout == 0) |
|
|
337 disp (local_list); |
|
|
338 elseif (length (files) == 0 && nargout == 1) |
|
|
339 local_packages = local_list; |
|
|
340 elseif (length (files) == 1 && nargout == 0 && ischar (files{1})) |
|
6729
|
341 try |
|
|
342 local_list = absolute_pathname (files{1}); |
|
|
343 catch |
|
|
344 ## Force file to be created |
|
7498
|
345 fclose (fopen (files{1}, "wt")); |
|
6729
|
346 local_list = absolute_pathname (files{1}); |
|
|
347 end_try_catch |
|
6496
|
348 else |
|
|
349 error ("you must specify a local_list file, or request an output argument"); |
|
|
350 endif |
|
|
351 |
|
|
352 case "global_list" |
|
|
353 if (length (files) == 0 && nargout == 0) |
|
|
354 disp(global_list); |
|
|
355 elseif (length (files) == 0 && nargout == 1) |
|
|
356 local_packages = global_list; |
|
|
357 elseif (length (files) == 1 && nargout == 0 && ischar (files{1})) |
|
6729
|
358 try |
|
|
359 global_list = absolute_pathname (files{1}); |
|
|
360 catch |
|
|
361 ## Force file to be created |
|
7498
|
362 fclose (fopen (files{1}, "wt")); |
|
6729
|
363 global_list = absolute_pathname (files{1}); |
|
|
364 end_try_catch |
|
6496
|
365 else |
|
|
366 error ("you must specify a global_list file, or request an output argument"); |
|
|
367 endif |
|
6645
|
368 |
|
|
369 case "rebuild" |
|
|
370 if (global_install) |
|
6925
|
371 global_packages = rebuild (prefix, archprefix, global_list, files, |
|
|
372 auto, verbose); |
|
6695
|
373 global_packages = save_order (global_packages); |
|
6645
|
374 save (global_list, "global_packages"); |
|
6695
|
375 if (nargout > 0) |
|
|
376 local_packages = global_packages; |
|
|
377 endif |
|
6645
|
378 else |
|
6925
|
379 local_packages = rebuild (prefix, archprefix, local_list, files, auto, |
|
|
380 verbose); |
|
6695
|
381 local_packages = save_order (local_packages); |
|
6645
|
382 save (local_list, "local_packages"); |
|
6695
|
383 if (nargout == 0) |
|
|
384 clear ("local_packages"); |
|
|
385 endif |
|
6645
|
386 endif |
|
|
387 |
|
6675
|
388 case "build" |
|
|
389 if (length (files) < 2) |
|
|
390 error ("you must specify at least the build directory and one filename\nwhen calling 'pkg build'"); |
|
|
391 endif |
|
|
392 build (files, deps, auto, verbose); |
|
|
393 |
|
7497
|
394 case "describe" |
|
|
395 if (length (files) == 0) |
|
|
396 error ("you must specify at least one package or 'all' when calling 'pkg describe'"); |
|
|
397 endif |
|
|
398 ## XXX FIXME: the name of the output variables is inconsistent |
|
|
399 ## with their content |
|
|
400 switch (nargout) |
|
7498
|
401 case 0 |
|
|
402 describe (files, verbose, local_list, global_list); |
|
|
403 case 1 |
|
|
404 pkg_desc_list = describe (files, verbose, local_list, ... |
|
|
405 global_list); |
|
|
406 local_packages = pkg_desc_list; |
|
|
407 case 2 |
|
|
408 [pkg_desc_list, flag] = describe (files, verbose, local_list, ... |
|
|
409 global_list); |
|
|
410 local_packages = pkg_desc_list; |
|
|
411 global_packages = flag; |
|
|
412 otherwise |
|
|
413 error ("you can request at most two outputs when calling 'pkg describe'"); |
|
|
414 endswitch |
|
7497
|
415 |
|
6496
|
416 otherwise |
|
|
417 error ("you must specify a valid action for 'pkg'. See 'help pkg' for details"); |
|
|
418 endswitch |
|
|
419 endfunction |
|
|
420 |
|
6925
|
421 function descriptions = rebuild (prefix, archprefix, list, files, auto, verbose) |
|
6645
|
422 if (isempty (files)) |
|
|
423 [dirlist, err, msg] = readdir (prefix); |
|
|
424 if (err) |
|
|
425 error ("couldn't read directory %s: %s", prefix, msg); |
|
|
426 endif |
|
|
427 ## the two first entries of dirlist are "." and ".." |
|
|
428 dirlist([1,2]) = []; |
|
|
429 else |
|
|
430 old_descriptions = installed_packages (list, list); |
|
|
431 wd = pwd (); |
|
6663
|
432 unwind_protect |
|
|
433 cd (prefix); |
|
6696
|
434 dirlist = glob (cellfun(@(x) strcat(x, '-*'), files, 'UniformOutput', 0)); |
|
6663
|
435 unwind_protect_cleanup |
|
|
436 cd (wd); |
|
|
437 end_unwind_protect |
|
6645
|
438 endif |
|
|
439 descriptions = {}; |
|
|
440 for k = 1:length (dirlist) |
|
|
441 descfile = fullfile (prefix, dirlist{k}, "packinfo", "DESCRIPTION"); |
|
|
442 if (verbose) |
|
|
443 printf ("recreating package description from %s\n", dirlist{k}); |
|
|
444 endif |
|
|
445 if (exist (descfile, "file")) |
|
|
446 desc = get_description (descfile); |
|
|
447 desc.dir = fullfile (prefix, dirlist{k}); |
|
6925
|
448 desc.archprefix = fullfile (archprefix, strcat (desc.name, "-", |
|
|
449 desc.version)); |
|
6645
|
450 if (auto != 0) |
|
|
451 if (exist (fullfile (desc.dir, "packinfo", ".autoload"), "file")) |
|
|
452 unlink (fullfile (desc.dir, "packinfo", ".autoload")); |
|
|
453 endif |
|
|
454 if (auto < 0) |
|
|
455 desc.autoload = 0; |
|
|
456 elseif (auto > 0) |
|
|
457 desc.autoload = 1; |
|
|
458 fclose (fopen (fullfile (desc.dir, "packinfo", ".autoload"), "wt")); |
|
|
459 endif |
|
|
460 else |
|
|
461 if (exist (fullfile (desc.dir, "packinfo", ".autoload"), "file")) |
|
|
462 desc.autoload = 1; |
|
|
463 else |
|
|
464 desc.autoload = 0; |
|
|
465 endif |
|
|
466 endif |
|
|
467 descriptions{end + 1} = desc; |
|
|
468 elseif (verbose) |
|
|
469 warning ("directory %s is not a valid package", dirlist{k}); |
|
|
470 endif |
|
|
471 endfor |
|
|
472 |
|
6663
|
473 if (! isempty (files)) |
|
6645
|
474 ## We are rebuilding for a particular package(s) so we should take |
|
|
475 ## care to keep the other untouched packages in the descriptions |
|
6663
|
476 descriptions = {descriptions{:}, old_descriptions{:}}; |
|
6645
|
477 |
|
|
478 dup = []; |
|
|
479 for i = 1:length (descriptions) |
|
|
480 if (find (dup, i)) |
|
|
481 continue; |
|
|
482 endif |
|
|
483 for j = (i+1):length (descriptions) |
|
|
484 if (find (dup, j)) |
|
|
485 continue; |
|
|
486 endif |
|
|
487 if (strcmp (descriptions{i}.name, descriptions{j}.name)) |
|
|
488 dup = [dup, j]; |
|
|
489 endif |
|
|
490 endfor |
|
|
491 endfor |
|
|
492 if (! isempty (dup)) |
|
|
493 descriptions (dup) = []; |
|
|
494 endif |
|
|
495 endif |
|
|
496 endfunction |
|
|
497 |
|
6675
|
498 function build (files, handle_deps, autoload, verbose) |
|
|
499 if (length (files) < 1) |
|
|
500 error ("insufficient number of files"); |
|
|
501 endif |
|
|
502 builddir = files{1}; |
|
|
503 if (! exist (builddir, "dir")) |
|
|
504 warning ("creating build directory %s", builddir); |
|
|
505 [status, msg] = mkdir (builddir); |
|
|
506 if (status != 1) |
|
|
507 error ("could not create installation directory: %s", msg); |
|
|
508 endif |
|
6496
|
509 endif |
|
6675
|
510 builddir = absolute_pathname (builddir); |
|
|
511 installdir = fullfile (builddir, "install"); |
|
|
512 if (! exist (installdir, "dir")) |
|
|
513 [status, msg] = mkdir (installdir); |
|
|
514 if (status != 1) |
|
|
515 error ("could not create installation directory: %s", msg); |
|
|
516 endif |
|
|
517 endif |
|
|
518 files(1) = []; |
|
|
519 buildlist = fullfile (builddir, "octave_packages"); |
|
6925
|
520 install (files, handle_deps, autoload, installdir, installdir, verbose, |
|
6675
|
521 buildlist, "", false); |
|
|
522 unwind_protect |
|
|
523 repackage (builddir, buildlist); |
|
|
524 unwind_protect_cleanup |
|
|
525 unload_packages ({"all"}, handle_deps, buildlist, ""); |
|
|
526 if (exist (installdir, "dir")) |
|
|
527 rm_rf (installdir); |
|
|
528 endif |
|
|
529 if (exist (buildlist, "file")) |
|
|
530 unlink (buildlist); |
|
|
531 endif |
|
|
532 end_unwind_protect |
|
5801
|
533 endfunction |
|
|
534 |
|
6925
|
535 function install (files, handle_deps, autoload, prefix, archprefix, verbose, |
|
|
536 local_list, global_list, global_install) |
|
6496
|
537 |
|
|
538 # Check that the directory in prefix exist. If it doesn't: create it! |
|
|
539 if (! exist (prefix, "dir")) |
|
|
540 warning ("creating installation directory %s", prefix); |
|
|
541 [status, msg] = mkdir (prefix); |
|
|
542 if (status != 1) |
|
|
543 error ("could not create installation directory: %s", msg); |
|
|
544 endif |
|
|
545 endif |
|
|
546 |
|
|
547 ## Get the list of installed packages |
|
|
548 [local_packages, global_packages] = installed_packages (local_list, |
|
|
549 global_list); |
|
|
550 |
|
6820
|
551 installed_pkgs_lst = {local_packages{:}, global_packages{:}}; |
|
6496
|
552 |
|
|
553 if (global_install) |
|
|
554 packages = global_packages; |
|
|
555 else |
|
|
556 packages = local_packages; |
|
|
557 endif |
|
|
558 |
|
|
559 ## Uncompress the packages and read the DESCRIPTION files |
|
|
560 tmpdirs = packdirs = descriptions = {}; |
|
|
561 try |
|
6683
|
562 ## Warn about non existent files |
|
|
563 for i = 1:length (files) |
|
|
564 if (isempty (glob(files{i}))) |
|
|
565 warning ("file %s does not exist", files{i}); |
|
|
566 endif |
|
|
567 endfor |
|
|
568 |
|
6496
|
569 ## Unpack the package files and read the DESCRIPTION files |
|
|
570 files = glob (files); |
|
|
571 packages_to_uninstall = []; |
|
|
572 for i = 1:length (files) |
|
|
573 tgz = files{i}; |
|
|
574 |
|
6645
|
575 if (exist (tgz, "file")) |
|
|
576 ## Create a temporary directory |
|
|
577 tmpdir = tmpnam (); |
|
|
578 tmpdirs{end+1} = tmpdir; |
|
|
579 if (verbose) |
|
|
580 printf ("mkdir (%s)\n", tmpdir); |
|
|
581 endif |
|
|
582 [status, msg] = mkdir (tmpdir); |
|
|
583 if (status != 1) |
|
|
584 error ("couldn't create temporary directory: %s", msg); |
|
|
585 endif |
|
6496
|
586 |
|
6645
|
587 ## Uncompress the package |
|
|
588 if (verbose) |
|
|
589 printf ("untar (%s, %s)\n", tgz, tmpdir); |
|
|
590 endif |
|
|
591 untar (tgz, tmpdir); |
|
6496
|
592 |
|
6645
|
593 ## Get the name of the directories produced by tar |
|
|
594 [dirlist, err, msg] = readdir (tmpdir); |
|
|
595 if (err) |
|
|
596 error ("couldn't read directory produced by tar: %s", msg); |
|
|
597 endif |
|
6496
|
598 |
|
6645
|
599 if (length (dirlist) > 3) |
|
|
600 error ("bundles of packages are not allowed") |
|
6496
|
601 endif |
|
|
602 |
|
6645
|
603 ## the two first entries of dirlist are "." and ".." |
|
|
604 for k = 3:length (dirlist) |
|
|
605 packdir = fullfile (tmpdir, dirlist{k}); |
|
|
606 packdirs{end+1} = packdir; |
|
6496
|
607 |
|
6645
|
608 ## Make sure the package contains necessary files |
|
|
609 verify_directory (packdir); |
|
|
610 |
|
|
611 ## Read the DESCRIPTION file |
|
|
612 filename = fullfile (packdir, "DESCRIPTION"); |
|
|
613 desc = get_description (filename); |
|
6496
|
614 |
|
6645
|
615 ## Verify that package name corresponds with filename |
|
|
616 [dummy, nm] = fileparts (tgz); |
|
|
617 if ((length (nm) >= length (desc.name)) |
|
|
618 && ! strcmp (desc.name, nm(1:length(desc.name)))) |
|
6925
|
619 error ("package name '%s' doesn't correspond to its filename '%s'", |
|
|
620 desc.name, nm); |
|
6496
|
621 endif |
|
6645
|
622 |
|
|
623 ## Set default installation directory |
|
|
624 desc.dir = fullfile (prefix, strcat (desc.name, "-", desc.version)); |
|
|
625 |
|
6925
|
626 ## Set default architectire dependent installation directory |
|
|
627 desc.archprefix = fullfile (archprefix, strcat (desc.name, "-", |
|
|
628 desc.version)); |
|
|
629 |
|
6645
|
630 ## Save desc |
|
|
631 descriptions{end+1} = desc; |
|
|
632 |
|
|
633 ## Are any of the new packages already installed? |
|
|
634 ## If so we'll remove the old version. |
|
|
635 for j = 1:length (packages) |
|
|
636 if (strcmp (packages{j}.name, desc.name)) |
|
|
637 packages_to_uninstall(end+1) = j; |
|
|
638 endif |
|
|
639 endfor |
|
|
640 endfor |
|
|
641 endif |
|
6496
|
642 endfor |
|
|
643 catch |
|
|
644 ## Something went wrong, delete tmpdirs |
|
|
645 for i = 1:length (tmpdirs) |
|
|
646 rm_rf (tmpdirs{i}); |
|
|
647 endfor |
|
6655
|
648 rethrow (lasterror ()); |
|
6496
|
649 end_try_catch |
|
|
650 |
|
|
651 ## Check dependencies |
|
|
652 if (handle_deps) |
|
|
653 ok = true; |
|
|
654 error_text = ""; |
|
|
655 for i = 1:length (descriptions) |
|
|
656 desc = descriptions{i}; |
|
|
657 idx2 = complement (i, 1:length(descriptions)); |
|
6695
|
658 if (global_install) |
|
|
659 ## Global installation is not allowed to have dependencies on locally |
|
|
660 ## installed packages |
|
|
661 idx1 = complement (packages_to_uninstall, |
|
|
662 1:length(global_packages)); |
|
|
663 pseudo_installed_packages = {global_packages{idx1}, ... |
|
|
664 descriptions{idx2}}; |
|
|
665 else |
|
|
666 idx1 = complement (packages_to_uninstall, |
|
|
667 1:length(local_packages)); |
|
|
668 pseudo_installed_packages = {local_packages{idx1}, ... |
|
|
669 global_packages{:}, ... |
|
|
670 descriptions{idx2}}; |
|
|
671 endif |
|
6496
|
672 bad_deps = get_unsatisfied_deps (desc, pseudo_installed_packages); |
|
|
673 ## Are there any unsatisfied dependencies? |
|
|
674 if (! isempty (bad_deps)) |
|
|
675 ok = false; |
|
|
676 for i = 1:length (bad_deps) |
|
|
677 dep = bad_deps{i}; |
|
|
678 error_text = strcat (error_text, " ", desc.name, " needs ", |
|
|
679 dep.package, " ", dep.operator, " ", |
|
|
680 dep.version, "\n"); |
|
|
681 endfor |
|
|
682 endif |
|
|
683 endfor |
|
|
684 |
|
|
685 ## Did we find any unsatisfied dependencies? |
|
|
686 if (! ok) |
|
|
687 error ("the following dependencies where unsatisfied:\n %s", error_text); |
|
|
688 endif |
|
|
689 endif |
|
|
690 |
|
|
691 ## Prepare each package for installation |
|
|
692 try |
|
|
693 for i = 1:length (descriptions) |
|
|
694 desc = descriptions{i}; |
|
|
695 pdir = packdirs{i}; |
|
|
696 prepare_installation (desc, pdir); |
|
6614
|
697 configure_make (desc, pdir, verbose); |
|
6496
|
698 endfor |
|
|
699 catch |
|
|
700 ## Something went wrong, delete tmpdirs |
|
|
701 for i = 1:length (tmpdirs) |
|
|
702 rm_rf (tmpdirs{i}); |
|
|
703 endfor |
|
6655
|
704 rethrow (lasterror ()); |
|
6496
|
705 end_try_catch |
|
|
706 |
|
|
707 ## Uninstall the packages that will be replaced |
|
|
708 try |
|
|
709 for i = packages_to_uninstall |
|
6695
|
710 if (global_install) |
|
|
711 uninstall ({global_packages{i}.name}, false, verbose, local_list, |
|
|
712 global_list, global_install); |
|
|
713 else |
|
|
714 uninstall ({local_packages{i}.name}, false, verbose, local_list, |
|
|
715 global_list, global_install); |
|
|
716 endif |
|
6496
|
717 endfor |
|
|
718 catch |
|
|
719 ## Something went wrong, delete tmpdirs |
|
|
720 for i = 1:length (tmpdirs) |
|
|
721 rm_rf (tmpdirs{i}); |
|
|
722 endfor |
|
6655
|
723 rethrow (lasterror ()); |
|
6496
|
724 end_try_catch |
|
|
725 |
|
|
726 ## Install each package |
|
|
727 try |
|
|
728 for i = 1:length (descriptions) |
|
|
729 desc = descriptions{i}; |
|
|
730 pdir = packdirs{i}; |
|
6925
|
731 copy_files (desc, pdir, global_install); |
|
|
732 create_pkgadddel (desc, pdir, "PKG_ADD", global_install); |
|
|
733 create_pkgadddel (desc, pdir, "PKG_DEL", global_install); |
|
|
734 finish_installation (desc, pdir, global_install) |
|
6496
|
735 endfor |
|
|
736 catch |
|
|
737 ## Something went wrong, delete tmpdirs |
|
|
738 for i = 1:length (tmpdirs) |
|
|
739 rm_rf (tmpdirs{i}); |
|
|
740 endfor |
|
|
741 for i = 1:length (descriptions) |
|
|
742 rm_rf (descriptions{i}.dir); |
|
6925
|
743 rm_rf (getarchdir (descriptions{i})); |
|
6496
|
744 endfor |
|
6655
|
745 rethrow (lasterror ()); |
|
6496
|
746 end_try_catch |
|
|
747 |
|
|
748 ## Check if the installed directory is empty. If it is remove it |
|
|
749 ## from the list |
|
|
750 for i = length (descriptions):-1:1 |
|
6925
|
751 if (dirempty (descriptions{i}.dir, {"packinfo", "doc"}) && |
|
|
752 dirempty (getarchdir (descriptions{i}))) |
|
6655
|
753 warning ("package %s is empty\n", descriptions{i}.name); |
|
6496
|
754 rm_rf (descriptions{i}.dir); |
|
6925
|
755 rm_rf (getarchdir (descriptions{i})); |
|
6496
|
756 descriptions(i) = []; |
|
|
757 endif |
|
|
758 endfor |
|
|
759 |
|
|
760 ## If the package requested that it is autoloaded, or the installer |
|
|
761 ## requested that it is, then mark the package as autoloaded. |
|
|
762 for i = length (descriptions):-1:1 |
|
|
763 if (autoload > 0 || (autoload == 0 && isautoload (descriptions(i)))) |
|
|
764 fclose (fopen (fullfile (descriptions{i}.dir, "packinfo", |
|
|
765 ".autoload"), "wt")); |
|
6695
|
766 descriptions{i}.autoload = 1; |
|
6496
|
767 endif |
|
|
768 endfor |
|
|
769 |
|
|
770 ## Add the packages to the package list |
|
|
771 try |
|
|
772 if (global_install) |
|
|
773 idx = complement (packages_to_uninstall, 1:length(global_packages)); |
|
6695
|
774 global_packages = save_order ({global_packages{idx}, descriptions{:}}); |
|
6496
|
775 save (global_list, "global_packages"); |
|
6820
|
776 installed_pkgs_lst = {local_packages{:}, global_packages{:}}; |
|
6496
|
777 else |
|
|
778 idx = complement (packages_to_uninstall, 1:length(local_packages)); |
|
6695
|
779 local_packages = save_order ({local_packages{idx}, descriptions{:}}); |
|
6496
|
780 save (local_list, "local_packages"); |
|
6820
|
781 installed_pkgs_lst = {local_packages{:}, global_packages{:}}; |
|
6496
|
782 endif |
|
|
783 catch |
|
|
784 ## Something went wrong, delete tmpdirs |
|
|
785 for i = 1:length (tmpdirs) |
|
|
786 rm_rf (tmpdirs{i}); |
|
|
787 endfor |
|
|
788 for i = 1:length (descriptions) |
|
|
789 rm_rf (descriptions{i}.dir); |
|
|
790 endfor |
|
|
791 if (global_install) |
|
6695
|
792 printf ("error: couldn't append to %s\n", global_list); |
|
6496
|
793 else |
|
6695
|
794 printf ("error: couldn't append to %s\n", local_list); |
|
6496
|
795 endif |
|
6695
|
796 rethrow (lasterror ()); |
|
6496
|
797 end_try_catch |
|
|
798 |
|
|
799 ## All is well, let's clean up |
|
|
800 for i = 1:length (tmpdirs) |
|
|
801 [status, msg] = rm_rf (tmpdirs{i}); |
|
|
802 if (status != 1) |
|
|
803 warning ("couldn't clean up after my self: %s\n", msg); |
|
|
804 endif |
|
|
805 endfor |
|
|
806 |
|
|
807 ## Add the newly installed packages to the path, so the user |
|
7192
|
808 ## can begin using them. Only load them if they are marked autoload |
|
6496
|
809 if (length (descriptions) > 0) |
|
6695
|
810 idx = []; |
|
6496
|
811 for i = 1:length (descriptions) |
|
6695
|
812 if (isautoload (descriptions(i))) |
|
7192
|
813 nm = descriptions{i}.name; |
|
|
814 for j = 1:length (installed_pkgs_lst) |
|
|
815 if (strcmp (nm, installed_pkgs_lst{j}.name)) |
|
|
816 idx (end + 1) = j; |
|
|
817 break; |
|
|
818 endif |
|
|
819 endfor |
|
6614
|
820 endif |
|
6496
|
821 endfor |
|
6925
|
822 load_packages_and_dependencies (idx, handle_deps, installed_pkgs_lst, |
|
|
823 global_install); |
|
6496
|
824 endif |
|
|
825 endfunction |
|
|
826 |
|
6645
|
827 function uninstall (pkgnames, handle_deps, verbose, local_list, |
|
|
828 global_list, global_install) |
|
6496
|
829 ## Get the list of installed packages |
|
|
830 [local_packages, global_packages] = installed_packages(local_list, |
|
|
831 global_list); |
|
6645
|
832 if (global_install) |
|
6820
|
833 installed_pkgs_lst = {local_packages{:}, global_packages{:}}; |
|
6496
|
834 else |
|
6820
|
835 installed_pkgs_lst = local_packages; |
|
6496
|
836 endif |
|
|
837 |
|
6820
|
838 num_packages = length (installed_pkgs_lst); |
|
6496
|
839 delete_idx = []; |
|
|
840 for i = 1:num_packages |
|
6820
|
841 cur_name = installed_pkgs_lst{i}.name; |
|
6496
|
842 if (any (strcmp (cur_name, pkgnames))) |
|
|
843 delete_idx(end+1) = i; |
|
|
844 endif |
|
|
845 endfor |
|
|
846 |
|
|
847 ## Are all the packages that should be uninstalled already installed? |
|
|
848 if (length (delete_idx) != length (pkgnames)) |
|
6645
|
849 if (global_install) |
|
6496
|
850 ## Try again for a locally installed package |
|
6820
|
851 installed_pkgs_lst = local_packages; |
|
6496
|
852 |
|
6820
|
853 num_packages = length (installed_pkgs_lst); |
|
6496
|
854 delete_idx = []; |
|
|
855 for i = 1:num_packages |
|
6820
|
856 cur_name = installed_pkgs_lst{i}.name; |
|
6496
|
857 if (any (strcmp (cur_name, pkgnames))) |
|
|
858 delete_idx(end+1) = i; |
|
|
859 endif |
|
|
860 endfor |
|
|
861 if (length (delete_idx) != length (pkgnames)) |
|
|
862 ## XXX: We should have a better error message |
|
6655
|
863 warning ("some of the packages you want to uninstall are not installed"); |
|
6496
|
864 endif |
|
|
865 else |
|
|
866 ## XXX: We should have a better error message |
|
6655
|
867 warning ("some of the packages you want to uninstall are not installed."); |
|
6496
|
868 endif |
|
|
869 endif |
|
|
870 |
|
|
871 ## Compute the packages that will remain installed |
|
|
872 idx = complement (delete_idx, 1:num_packages); |
|
6820
|
873 remaining_packages = {installed_pkgs_lst{idx}}; |
|
6496
|
874 |
|
|
875 ## Check dependencies |
|
|
876 if (handle_deps) |
|
|
877 error_text = ""; |
|
|
878 for i = 1:length (remaining_packages) |
|
|
879 desc = remaining_packages{i}; |
|
|
880 bad_deps = get_unsatisfied_deps (desc, remaining_packages); |
|
|
881 |
|
|
882 ## Will the uninstallation break any dependencies? |
|
|
883 if (! isempty (bad_deps)) |
|
|
884 for i = 1:length (bad_deps) |
|
|
885 dep = bad_deps{i}; |
|
|
886 error_text = strcat (error_text, " ", desc.name, " needs ", |
|
|
887 dep.package, " ", dep.operator, " ", |
|
|
888 dep.version, "\n"); |
|
|
889 endfor |
|
|
890 endif |
|
|
891 endfor |
|
|
892 |
|
|
893 if (! isempty (error_text)) |
|
|
894 error ("the following dependencies where unsatisfied:\n %s", error_text); |
|
|
895 endif |
|
|
896 endif |
|
|
897 |
|
|
898 ## Delete the directories containing the packages |
|
|
899 for i = delete_idx |
|
6820
|
900 desc = installed_pkgs_lst{i}; |
|
6496
|
901 ## If an 'on_uninstall.m' exist, call it! |
|
|
902 if (exist (fullfile (desc.dir, "packinfo", "on_uninstall.m"), "file")) |
|
6614
|
903 wd = pwd (); |
|
7498
|
904 cd (fullfile (desc.dir, "packinfo")); |
|
6614
|
905 on_uninstall (desc); |
|
|
906 cd (wd); |
|
6496
|
907 endif |
|
|
908 ## Do the actual deletion |
|
6675
|
909 if (desc.loaded) |
|
|
910 rmpath (desc.dir); |
|
6925
|
911 if (exist (getarchdir (desc))) |
|
|
912 rmpath (getarchdir (desc)); |
|
6675
|
913 endif |
|
6614
|
914 endif |
|
6496
|
915 if (exist (desc.dir, "dir")) |
|
|
916 [status, msg] = rm_rf (desc.dir); |
|
|
917 if (status != 1) |
|
|
918 error ("couldn't delete directory %s: %s", desc.dir, msg); |
|
|
919 endif |
|
6925
|
920 [status, msg] = rm_rf (getarchdir (desc)); |
|
|
921 if (status != 1) |
|
|
922 error ("couldn't delete directory %s: %s", getarchdir (desc), msg); |
|
|
923 endif |
|
|
924 if (dirempty (desc.archprefix)) |
|
|
925 rm_rf (desc.archprefix); |
|
|
926 endif |
|
6496
|
927 else |
|
|
928 warning ("directory %s previously lost", desc.dir); |
|
|
929 endif |
|
|
930 endfor |
|
|
931 |
|
|
932 ## Write a new ~/.octave_packages |
|
6645
|
933 if (global_install) |
|
6496
|
934 if (length (remaining_packages) == 0) |
|
|
935 unlink (global_list); |
|
|
936 else |
|
6695
|
937 global_packages = save_order (remaining_packages); |
|
6496
|
938 save (global_list, "global_packages"); |
|
|
939 endif |
|
|
940 else |
|
|
941 if (length (remaining_packages) == 0) |
|
|
942 unlink (local_list); |
|
|
943 else |
|
6695
|
944 local_packages = save_order (remaining_packages); |
|
6496
|
945 save (local_list, "local_packages"); |
|
|
946 endif |
|
|
947 endif |
|
|
948 |
|
|
949 endfunction |
|
|
950 |
|
7497
|
951 function [pkg_desc_list, flag] = describe (pkgnames, verbose, |
|
|
952 local_list, global_list) |
|
|
953 |
|
|
954 ## Get the list of installed packages |
|
|
955 installed_pkgs_lst = installed_packages(local_list, global_list); |
|
7498
|
956 num_packages = length (installed_pkgs_lst); |
|
7497
|
957 |
|
|
958 |
|
7498
|
959 describe_all = false; |
|
|
960 if (any (strcmp ("all", pkgnames))) |
|
|
961 describe_all = true; |
|
7497
|
962 flag{1:num_packages} = "Not Loaded"; |
|
7498
|
963 num_pkgnames = num_packages; |
|
7497
|
964 else |
|
7498
|
965 num_pkgnames = length (pkgnames); |
|
7497
|
966 flag{1:num_pkgnames} = "Not installed"; |
|
7498
|
967 endif |
|
7497
|
968 |
|
|
969 for i = 1:num_packages |
|
|
970 curr_name= installed_pkgs_lst{i}.name; |
|
|
971 if (describe_all) |
|
|
972 name_pos = i; |
|
|
973 else |
|
|
974 name_pos = find(strcmp (curr_name, pkgnames)); |
|
7498
|
975 endif |
|
|
976 |
|
|
977 if (! isempty (name_pos)) |
|
7497
|
978 if (installed_pkgs_lst{i}.loaded) |
|
|
979 flag{name_pos} = "Loaded"; |
|
|
980 else |
|
|
981 flag{name_pos} = "Not loaded"; |
|
|
982 endif |
|
|
983 |
|
7498
|
984 pkg_desc_list{name_pos}.name = installed_pkgs_lst{i}.name; |
|
|
985 pkg_desc_list{name_pos}.description = installed_pkgs_lst{i}.description; |
|
|
986 pkg_desc_list{name_pos}.provides = parse_pkg_idx (installed_pkgs_lst{i}.dir); |
|
7497
|
987 |
|
|
988 endif |
|
|
989 endfor |
|
|
990 |
|
7498
|
991 non_inst = find (strcmp (flag, "Not installed")); |
|
|
992 if (! isempty (non_inst) && nargout < 2) |
|
|
993 non_inst_str = sprintf (" %s ", pkgnames{non_inst}); |
|
|
994 error ("some packages are not installed: %s", non_inst_str); |
|
7497
|
995 endif |
|
|
996 |
|
|
997 if (nargout == 0) |
|
7498
|
998 for i = 1:num_pkgnames |
|
7497
|
999 print_package_description (pkg_desc_list{i}.name, |
|
|
1000 pkg_desc_list{i}.provides, |
|
|
1001 pkg_desc_list{i}.description, |
|
|
1002 flag{i}, verbose); |
|
|
1003 endfor |
|
|
1004 endif |
|
|
1005 |
|
|
1006 endfunction |
|
|
1007 |
|
6496
|
1008 ########################################################## |
|
|
1009 ## A U X I L I A R Y F U N C T I O N S ## |
|
|
1010 ########################################################## |
|
|
1011 |
|
7497
|
1012 ## This function reads an INDEX file |
|
7498
|
1013 function [pkg_idx_struct] = parse_pkg_idx (packdir) |
|
7497
|
1014 |
|
7498
|
1015 index_file = fullfile (packdir, "packinfo", "INDEX"); |
|
|
1016 |
|
|
1017 if (! exist (index_file, "file")) |
|
|
1018 error ("could not find any INDEX file in directory %s, try 'pkg rebuild all' to generate missing INDEX files", packdir); |
|
7497
|
1019 endif |
|
|
1020 |
|
|
1021 |
|
7498
|
1022 [fid, msg] = fopen (index_file, "r"); |
|
7497
|
1023 if (fid == -1) |
|
7498
|
1024 error ("the INDEX file %s could not be read: %s", |
|
|
1025 index_file, msg); |
|
7497
|
1026 endif |
|
7498
|
1027 |
|
7497
|
1028 cat_num = 1; |
|
|
1029 pkg_idx_struct{1}.category = "Uncategorized"; |
|
|
1030 pkg_idx_struct{1}.functions = {}; |
|
|
1031 |
|
7498
|
1032 line = fgetl (fid); |
|
|
1033 while (isempty (strfind (line, ">>")) && ! feof (fid)) |
|
|
1034 line = fgetl (fid); |
|
7497
|
1035 endwhile |
|
|
1036 |
|
7498
|
1037 while (! feof (fid) || line != -1) |
|
|
1038 if (! any (! isspace (line)) || line(1) == "#" || any (line == "=")) |
|
7497
|
1039 ## Comments, blank lines or comments about unimplemented |
|
|
1040 ## functions: do nothing |
|
|
1041 ## XXX: probably comments and pointers to external functions |
|
|
1042 ## could be treated better when printing to screen? |
|
7498
|
1043 elseif (! isempty (strfind (line, ">>"))) |
|
7497
|
1044 ## Skip package name and description as they are in |
|
|
1045 ## DESCRIPTION already |
|
7498
|
1046 elseif (! isspace (line(1))) |
|
7497
|
1047 ## Category |
|
7498
|
1048 if (! isempty (pkg_idx_struct{cat_num}.functions)) |
|
|
1049 pkg_idx_struct{++cat_num}.functions = {}; |
|
7497
|
1050 endif |
|
7498
|
1051 pkg_idx_struct{cat_num}.category = deblank (line); |
|
7497
|
1052 else |
|
|
1053 ## Function names |
|
7498
|
1054 while (any (! isspace (line))) |
|
|
1055 [fun_name, line] = strtok (line); |
|
|
1056 pkg_idx_struct{cat_num}.functions{end+1} = deblank (fun_name); |
|
7497
|
1057 endwhile |
|
|
1058 endif |
|
7498
|
1059 line = fgetl (fid); |
|
7497
|
1060 endwhile |
|
|
1061 fclose (fid); |
|
|
1062 endfunction |
|
|
1063 |
|
|
1064 function print_package_description (pkg_name, pkg_idx_struct, |
|
|
1065 pkg_desc, status, verbose) |
|
|
1066 |
|
7498
|
1067 printf ("---\nPackage name:\n\t%s\n", pkg_name); |
|
|
1068 printf ("Short description:\n\t%s\n", pkg_desc); |
|
|
1069 printf ("Status:\n\t%s\n", status); |
|
7497
|
1070 if (verbose) |
|
7498
|
1071 printf ("---\nProvides:\n"); |
|
|
1072 for i = 1:length(pkg_idx_struct) |
|
|
1073 if (! isempty (pkg_idx_struct{i}.functions)) |
|
|
1074 printf ("%s\n", pkg_idx_struct{i}.category); |
|
|
1075 for j = 1:length(pkg_idx_struct{i}.functions) |
|
|
1076 printf ("\t%s\n", pkg_idx_struct{i}.functions{j}); |
|
7497
|
1077 endfor |
|
|
1078 endif |
|
|
1079 endfor |
|
|
1080 endif |
|
|
1081 |
|
|
1082 endfunction |
|
|
1083 |
|
|
1084 |
|
6675
|
1085 function pth = absolute_pathname (pth) |
|
7498
|
1086 [status, msg, msgid] = fileattrib (pth); |
|
6729
|
1087 if (status != 1) |
|
|
1088 error ("could not find the file or path %s", pth); |
|
|
1089 else |
|
|
1090 pth = msg.Name; |
|
|
1091 endif |
|
6675
|
1092 endfunction |
|
|
1093 |
|
|
1094 function repackage (builddir, buildlist) |
|
|
1095 packages = installed_packages (buildlist, buildlist); |
|
|
1096 |
|
|
1097 wd = pwd(); |
|
|
1098 for i = 1 : length(packages) |
|
|
1099 pack = packages{i}; |
|
|
1100 unwind_protect |
|
|
1101 cd (builddir); |
|
|
1102 mkdir (pack.name); |
|
|
1103 mkdir (fullfile (pack.name, "inst")); |
|
|
1104 copyfile (fullfile (pack.dir, "*"), fullfile (pack.name, "inst")); |
|
|
1105 movefile (fullfile (pack.name, "inst","packinfo", "*"), pack.name); |
|
|
1106 if (exist (fullfile (pack.name, "inst","packinfo", ".autoload"), "file")) |
|
|
1107 unlink (fullfile (pack.name, "inst","packinfo", ".autoload")); |
|
|
1108 endif |
|
|
1109 rmdir (fullfile (pack.name, "inst", "packinfo")); |
|
|
1110 if (exist (fullfile (pack.name, "inst", "doc"), "dir")) |
|
|
1111 movefile (fullfile (pack.name, "inst", "doc"), pack.name); |
|
|
1112 endif |
|
|
1113 if (exist (fullfile (pack.name, "inst", "bin"), "dir")) |
|
|
1114 movefile (fullfile (pack.name, "inst", "bin"), pack.name); |
|
|
1115 endif |
|
6925
|
1116 archdir = fullfile (pack.archprefix, strcat (pack.name, "-", |
|
|
1117 pack.version), getarch ()); |
|
6675
|
1118 if (exist (archdir, "dir")) |
|
|
1119 if (exist (fullfile (pack.name, "inst", "PKG_ADD"), "file")) |
|
|
1120 unlink (fullfile (pack.name, "inst", "PKG_ADD")); |
|
|
1121 endif |
|
|
1122 if (exist (fullfile (pack.name, "inst", "PKG_DEL"), "file")) |
|
|
1123 unlink (fullfile (pack.name, "inst", "PKG_DEL")); |
|
|
1124 endif |
|
|
1125 if (exist (fullfile (archdir, "PKG_ADD"), "file")) |
|
|
1126 movefile (fullfile (archdir, "PKG_ADD"), |
|
|
1127 fullfile (pack.name, "PKG_ADD")); |
|
|
1128 endif |
|
|
1129 if (exist (fullfile (archdir, "PKG_DEL"), "file")) |
|
|
1130 movefile (fullfile (archdir, "PKG_DEL"), |
|
|
1131 fullfile (pack.name, "PKG_DEL")); |
|
|
1132 endif |
|
|
1133 else |
|
|
1134 if (exist (fullfile (pack.name, "inst", "PKG_ADD"), "file")) |
|
|
1135 movefile (fullfile (pack.name, "inst", "PKG_ADD"), |
|
|
1136 fullfile (pack.name, "PKG_ADD")); |
|
|
1137 endif |
|
|
1138 if (exist (fullfile (pack.name, "inst", "PKG_DEL"), "file")) |
|
|
1139 movefile (fullfile (pack.name, "inst", "PKG_DEL"), |
|
|
1140 fullfile (pack.name, "PKG_DEL")); |
|
|
1141 endif |
|
|
1142 endif |
|
|
1143 tfile = strcat (pack.name, "-", pack.version, ".tar"); |
|
|
1144 tar (tfile, pack.name); |
|
6925
|
1145 try |
|
|
1146 gzip (tfile); |
|
|
1147 unlink (tfile); |
|
|
1148 catch |
|
|
1149 warning ("failed to compress %s", tfile); |
|
|
1150 end_try_catch |
|
6675
|
1151 unwind_protect_cleanup |
|
|
1152 if (exist (pack.name, "dir")) |
|
|
1153 rm_rf (pack.name); |
|
|
1154 endif |
|
|
1155 cd (wd); |
|
|
1156 end_unwind_protect |
|
|
1157 endfor |
|
|
1158 endfunction |
|
|
1159 |
|
|
1160 function auto = isautoload (desc) |
|
6695
|
1161 auto = false; |
|
|
1162 if (isfield (desc{1}, "autoload")) |
|
|
1163 a = desc{1}.autoload; |
|
|
1164 if ((isnumeric (a) && a > 0) |
|
|
1165 || (ischar (a) && (strcmpi (a, "true") |
|
6675
|
1166 || strcmpi (a, "on") |
|
|
1167 || strcmpi (a, "yes") |
|
|
1168 || strcmpi (a, "1")))) |
|
6695
|
1169 auto = true; |
|
|
1170 endif |
|
6675
|
1171 endif |
|
|
1172 endfunction |
|
|
1173 |
|
6496
|
1174 function prepare_installation (desc, packdir) |
|
|
1175 ## Is there a pre_install to call? |
|
|
1176 if (exist (fullfile (packdir, "pre_install.m"), "file")) |
|
|
1177 wd = pwd (); |
|
|
1178 try |
|
|
1179 cd (packdir); |
|
|
1180 pre_install (desc); |
|
|
1181 cd (wd); |
|
|
1182 catch |
|
|
1183 cd (wd); |
|
6695
|
1184 rethrow (lasterror ()); |
|
6496
|
1185 end_try_catch |
|
|
1186 endif |
|
|
1187 |
|
|
1188 ## If the directory "inst" doesn't exist, we create it |
|
|
1189 inst_dir = fullfile (packdir, "inst"); |
|
|
1190 if (! exist (inst_dir, "dir")) |
|
|
1191 [status, msg] = mkdir (inst_dir); |
|
|
1192 if (status != 1) |
|
|
1193 rm_rf (desc.dir); |
|
|
1194 error ("the 'inst' directory did not exist and could not be created: %s", |
|
|
1195 msg); |
|
6258
|
1196 endif |
|
|
1197 endif |
|
|
1198 endfunction |
|
|
1199 |
|
6614
|
1200 function configure_make (desc, packdir, verbose) |
|
6496
|
1201 ## Perform ./configure, make, make install in "src" |
|
|
1202 if (exist (fullfile (packdir, "src"), "dir")) |
|
|
1203 src = fullfile (packdir, "src"); |
|
|
1204 ## configure |
|
|
1205 if (exist (fullfile (src, "configure"), "file")) |
|
7111
|
1206 flags = ""; |
|
|
1207 if (isempty (getenv ("CC"))) |
|
|
1208 flags = strcat (flags, " CC=\"", octave_config_info ("CC"), "\""); |
|
|
1209 endif |
|
|
1210 if (isempty (getenv ("CXX"))) |
|
|
1211 flags = strcat (flags, " CXX=\"", octave_config_info ("CXX"), "\""); |
|
|
1212 endif |
|
|
1213 if (isempty (getenv ("AR"))) |
|
|
1214 flags = strcat (flags, " AR=\"", octave_config_info ("AR"), "\""); |
|
|
1215 endif |
|
|
1216 if (isempty (getenv ("RANLIB"))) |
|
|
1217 flags = strcat (flags, " RANLIB=\"", octave_config_info ("RANLIB"), "\""); |
|
|
1218 endif |
|
6645
|
1219 [status, output] = shell (strcat ("cd ", src, "; ./configure --prefix=\"", |
|
7111
|
1220 desc.dir, "\"", flags)); |
|
6496
|
1221 if (status != 0) |
|
|
1222 rm_rf (desc.dir); |
|
|
1223 error ("the configure script returned the following error: %s", output); |
|
6675
|
1224 elseif (verbose) |
|
|
1225 printf("%s", output); |
|
6496
|
1226 endif |
|
6675
|
1227 |
|
5801
|
1228 endif |
|
|
1229 |
|
6496
|
1230 ## make |
|
|
1231 if (exist (fullfile (src, "Makefile"), "file")) |
|
6645
|
1232 [status, output] = shell (strcat ("export INSTALLDIR=\"", desc.dir, |
|
|
1233 "\"; make -C ", src)); |
|
6496
|
1234 if (status != 0) |
|
|
1235 rm_rf (desc.dir); |
|
|
1236 error ("'make' returned the following error: %s", output); |
|
6675
|
1237 elseif (verbose) |
|
|
1238 printf("%s", output); |
|
6496
|
1239 endif |
|
5801
|
1240 endif |
|
|
1241 |
|
6614
|
1242 ## Copy files to "inst" and "inst/arch" (this is instead of 'make install') |
|
6496
|
1243 files = fullfile (src, "FILES"); |
|
|
1244 instdir = fullfile (packdir, "inst"); |
|
6614
|
1245 archdir = fullfile (packdir, "inst", getarch ()); |
|
6950
|
1246 |
|
6655
|
1247 ## Get file names |
|
6496
|
1248 if (exist (files, "file")) |
|
|
1249 [fid, msg] = fopen (files, "r"); |
|
|
1250 if (fid < 0) |
|
|
1251 error ("couldn't open %s: %s", files, msg); |
|
5971
|
1252 endif |
|
6496
|
1253 filenames = char (fread (fid))'; |
|
|
1254 fclose (fid); |
|
|
1255 if (filenames(end) == "\n") |
|
|
1256 filenames(end) = []; |
|
6258
|
1257 endif |
|
6655
|
1258 filenames = split_by (filenames, "\n"); |
|
6496
|
1259 delete_idx = []; |
|
6655
|
1260 for i = 1:length (filenames) |
|
|
1261 if (! all (isspace (filenames{i}))) |
|
|
1262 filenames{i} = fullfile (src, filenames{i}); |
|
6496
|
1263 else |
|
|
1264 delete_idx(end+1) = i; |
|
|
1265 endif |
|
5971
|
1266 endfor |
|
6655
|
1267 filenames(delete_idx) = []; |
|
6496
|
1268 else |
|
|
1269 m = dir (fullfile (src, "*.m")); |
|
|
1270 oct = dir (fullfile (src, "*.oct")); |
|
|
1271 mex = dir (fullfile (src, "*.mex")); |
|
6614
|
1272 archdependent = ""; |
|
|
1273 archindependent = ""; |
|
6496
|
1274 filenames = ""; |
|
|
1275 if (length (m) > 0) |
|
|
1276 filenames = sprintf (fullfile (src, "%s "), m.name); |
|
|
1277 endif |
|
|
1278 if (length (oct) > 0) |
|
7498
|
1279 filenames = strcat (filenames, " ", |
|
|
1280 sprintf (fullfile (src, "%s "), oct.name)); |
|
6496
|
1281 endif |
|
|
1282 if (length (mex) > 0) |
|
7498
|
1283 filenames = strcat (filenames, " ", |
|
|
1284 sprintf (fullfile (src, "%s "), mex.name)); |
|
6496
|
1285 endif |
|
6614
|
1286 filenames = split_by (filenames, " "); |
|
5971
|
1287 endif |
|
5801
|
1288 |
|
6950
|
1289 ## Split into architecture dependent and independent files |
|
7024
|
1290 if (isempty (filenames)) |
|
|
1291 idx = []; |
|
|
1292 else |
|
|
1293 idx = cellfun (@(x) is_architecture_dependent (x), filenames); |
|
|
1294 endif |
|
6950
|
1295 archdependent = filenames (idx); |
|
|
1296 archindependent = filenames (!idx); |
|
|
1297 |
|
6655
|
1298 ## Copy the files |
|
6496
|
1299 if (! all (isspace (filenames))) |
|
6655
|
1300 if (! exist (instdir, "dir")) |
|
|
1301 mkdir (instdir); |
|
|
1302 endif |
|
6614
|
1303 if (! all (isspace (archindependent))) |
|
6634
|
1304 if (verbose) |
|
|
1305 printf ("copyfile"); |
|
|
1306 printf (" %s", archindependent{:}); |
|
|
1307 printf ("%s\n", instdir); |
|
|
1308 endif |
|
6614
|
1309 [status, output] = copyfile (archindependent, instdir); |
|
|
1310 if (status != 1) |
|
6496
|
1311 rm_rf (desc.dir); |
|
|
1312 error ("Couldn't copy files from 'src' to 'inst': %s", output); |
|
6614
|
1313 endif |
|
|
1314 endif |
|
|
1315 if (! all (isspace (archdependent))) |
|
6634
|
1316 if (verbose) |
|
|
1317 printf ("copyfile"); |
|
|
1318 printf (" %s", archdependent{:}); |
|
|
1319 printf (" %s\n", archdir); |
|
|
1320 endif |
|
6655
|
1321 if (! exist (archdir, "dir")) |
|
|
1322 mkdir (archdir); |
|
|
1323 endif |
|
6614
|
1324 [status, output] = copyfile (archdependent, archdir); |
|
|
1325 if (status != 1) |
|
|
1326 rm_rf (desc.dir); |
|
|
1327 error ("Couldn't copy files from 'src' to 'inst': %s", output); |
|
|
1328 endif |
|
|
1329 endif |
|
5801
|
1330 endif |
|
6496
|
1331 endif |
|
5801
|
1332 endfunction |
|
|
1333 |
|
5971
|
1334 function pkg = extract_pkg (nm, pat) |
|
5955
|
1335 fid = fopen (nm, "rt"); |
|
5971
|
1336 pkg = ""; |
|
5955
|
1337 if (fid >= 0) |
|
6496
|
1338 while (! feof (fid)) |
|
5955
|
1339 ln = fgetl (fid); |
|
|
1340 if (ln > 0) |
|
6496
|
1341 t = regexp (ln, pat, "tokens"); |
|
|
1342 if (! isempty (t)) |
|
|
1343 pkg = strcat (pkg, "\n", t{1}{1}); |
|
5955
|
1344 endif |
|
|
1345 endif |
|
|
1346 endwhile |
|
6496
|
1347 if (! isempty (pkg)) |
|
|
1348 pkg = strcat (pkg, "\n"); |
|
5955
|
1349 endif |
|
|
1350 fclose (fid); |
|
|
1351 endif |
|
|
1352 endfunction |
|
|
1353 |
|
6925
|
1354 function create_pkgadddel (desc, packdir, nm, global_install) |
|
6675
|
1355 instpkg = fullfile (desc.dir, nm); |
|
|
1356 instfid = fopen (instpkg, "wt"); |
|
|
1357 ## If it is exists, most of the PKG_* file should go into the |
|
|
1358 ## architecture dependent directory so that the autoload/mfilename |
|
|
1359 ## commands work as expected. The only part that doesn't is the |
|
|
1360 ## part in the main directory. |
|
6925
|
1361 archdir = fullfile (getarchprefix (desc), strcat (desc.name, "-", |
|
|
1362 desc.version), getarch ()); |
|
|
1363 if (exist (getarchdir (desc, global_install), "dir")) |
|
|
1364 archpkg = fullfile (getarchdir (desc, global_install), nm); |
|
|
1365 archfid = fopen (archpkg, "at"); |
|
6675
|
1366 else |
|
|
1367 archpkg = instpkg; |
|
|
1368 archfid = instfid; |
|
|
1369 endif |
|
6634
|
1370 |
|
6675
|
1371 if (archfid >= 0 && instfid >= 0) |
|
5971
|
1372 ## Search all dot-m files for PKG commands |
|
7498
|
1373 lst = dir (fullfile (packdir, "inst", "*.m")); |
|
6496
|
1374 for i = 1:length (lst) |
|
7498
|
1375 nam = fullfile (packdir, "inst", lst(i).name); |
|
6675
|
1376 fwrite (instfid, extract_pkg (nam, ['^[#%][#%]* *' nm ': *(.*)$'])); |
|
5955
|
1377 endfor |
|
|
1378 |
|
5971
|
1379 ## Search all C++ source files for PKG commands |
|
7498
|
1380 lst = dir (fullfile (packdir, "src", "*.cc")); |
|
6496
|
1381 for i = 1:length (lst) |
|
7498
|
1382 nam = fullfile (packdir, "src", lst(i).name); |
|
6675
|
1383 fwrite (archfid, extract_pkg (nam, ['^//* *' nm ': *(.*)$'])); |
|
|
1384 fwrite (archfid, extract_pkg (nam, ['^/\** *' nm ': *(.*) *\*/$'])); |
|
5955
|
1385 endfor |
|
|
1386 |
|
5971
|
1387 ## Add developer included PKG commands |
|
6496
|
1388 packdirnm = fullfile (packdir, nm); |
|
|
1389 if (exist (packdirnm, "file")) |
|
6675
|
1390 fid = fopen (packdirnm, "rt"); |
|
|
1391 if (fid >= 0) |
|
|
1392 while (! feof (fid)) |
|
|
1393 ln = fgets (fid); |
|
5955
|
1394 if (ln > 0) |
|
6675
|
1395 fwrite (archfid, ln); |
|
5955
|
1396 endif |
|
|
1397 endwhile |
|
6675
|
1398 fclose (fid); |
|
5955
|
1399 endif |
|
|
1400 endif |
|
5971
|
1401 |
|
6675
|
1402 ## If the files is empty remove it |
|
|
1403 fclose (instfid); |
|
|
1404 t = dir (instpkg); |
|
5971
|
1405 if (t.bytes <= 0) |
|
6675
|
1406 unlink (instpkg); |
|
|
1407 endif |
|
|
1408 |
|
|
1409 if (instfid != archfid) |
|
|
1410 fclose (archfid); |
|
|
1411 t = dir (archpkg); |
|
|
1412 if (t.bytes <= 0) |
|
|
1413 unlink (archpkg); |
|
|
1414 endif |
|
5971
|
1415 endif |
|
5955
|
1416 endif |
|
|
1417 endfunction |
|
|
1418 |
|
6925
|
1419 function copy_files (desc, packdir, global_install) |
|
6496
|
1420 ## Create the installation directory |
|
|
1421 if (! exist (desc.dir, "dir")) |
|
|
1422 [status, output] = mkdir (desc.dir); |
|
|
1423 if (status != 1) |
|
|
1424 error ("couldn't create installation directory %s : %s", |
|
|
1425 desc.dir, output); |
|
6020
|
1426 endif |
|
6496
|
1427 endif |
|
6020
|
1428 |
|
6925
|
1429 octfiledir = getarchdir (desc); |
|
|
1430 |
|
6496
|
1431 ## Copy the files from "inst" to installdir |
|
|
1432 instdir = fullfile (packdir, "inst"); |
|
|
1433 if (! dirempty (instdir)) |
|
|
1434 [status, output] = copyfile (fullfile (instdir, "*"), desc.dir); |
|
|
1435 if (status != 1) |
|
|
1436 rm_rf (desc.dir); |
|
|
1437 error ("couldn't copy files to the installation directory"); |
|
5801
|
1438 endif |
|
6925
|
1439 if (exist (fullfile (desc.dir, getarch ()), "dir") && |
|
|
1440 ! strcmp (fullfile (desc.dir, getarch ()), octfiledir)) |
|
|
1441 if (! exist (octfiledir, "dir")) |
|
|
1442 ## Can be required to create upto three levels of dirs |
|
|
1443 octm1 = fileparts (octfiledir); |
|
|
1444 if (! exist (octm1, "dir")) |
|
|
1445 octm2 = fileparts (octm1); |
|
|
1446 if (! exist (octm2, "dir")) |
|
|
1447 octm3 = fileparts (octm2); |
|
|
1448 if (! exist (octm3, "dir")) |
|
|
1449 [status, output] = mkdir (octm3); |
|
|
1450 if (status != 1) |
|
|
1451 rm_rf (desc.dir); |
|
|
1452 error ("couldn't create installation directory %s : %s", |
|
|
1453 octm3, output); |
|
|
1454 endif |
|
|
1455 endif |
|
|
1456 [status, output] = mkdir (octm2); |
|
|
1457 if (status != 1) |
|
|
1458 rm_rf (desc.dir); |
|
|
1459 error ("couldn't create installation directory %s : %s", |
|
|
1460 octm2, output); |
|
|
1461 endif |
|
|
1462 endif |
|
|
1463 [status, output] = mkdir (octm1); |
|
|
1464 if (status != 1) |
|
|
1465 rm_rf (desc.dir); |
|
|
1466 error ("couldn't create installation directory %s : %s", |
|
|
1467 octm1, output); |
|
|
1468 endif |
|
|
1469 endif |
|
|
1470 [status, output] = mkdir (octfiledir); |
|
|
1471 if (status != 1) |
|
|
1472 rm_rf (desc.dir); |
|
|
1473 error ("couldn't create installation directory %s : %s", |
|
|
1474 octfiledir, output); |
|
|
1475 endif |
|
|
1476 endif |
|
|
1477 [status, output] = movefile (fullfile (desc.dir, getarch (), "*"), |
|
|
1478 octfiledir); |
|
|
1479 rm_rf (fullfile (desc.dir, getarch ())); |
|
|
1480 |
|
|
1481 if (status != 1) |
|
|
1482 rm_rf (desc.dir); |
|
|
1483 rm_rf (octfiledir); |
|
|
1484 error ("couldn't copy files to the installation directory"); |
|
|
1485 endif |
|
|
1486 endif |
|
|
1487 |
|
6496
|
1488 endif |
|
5801
|
1489 |
|
6496
|
1490 ## Create the "packinfo" directory |
|
|
1491 packinfo = fullfile (desc.dir, "packinfo"); |
|
|
1492 [status, msg] = mkdir (packinfo); |
|
|
1493 if (status != 1) |
|
|
1494 rm_rf (desc.dir); |
|
6925
|
1495 rm_rf (octfiledir); |
|
6496
|
1496 error ("couldn't create packinfo directory: %s", msg); |
|
|
1497 endif |
|
5801
|
1498 |
|
6496
|
1499 ## Copy DESCRIPTION |
|
|
1500 [status, output] = copyfile (fullfile (packdir, "DESCRIPTION"), packinfo); |
|
|
1501 if (status != 1) |
|
6925
|
1502 rm_rf (desc.dir); |
|
|
1503 rm_rf (octfiledir); |
|
|
1504 error ("couldn't copy DESCRIPTION: %s", output); |
|
6496
|
1505 endif |
|
5801
|
1506 |
|
6496
|
1507 ## Copy COPYING |
|
|
1508 [status, output] = copyfile (fullfile (packdir, "COPYING"), packinfo); |
|
|
1509 if (status != 1) |
|
6925
|
1510 rm_rf (desc.dir); |
|
|
1511 rm_rf (octfiledir); |
|
|
1512 error ("couldn't copy COPYING: %s", output); |
|
6496
|
1513 endif |
|
5993
|
1514 |
|
6496
|
1515 ## If the file ChangeLog exists, copy it |
|
7498
|
1516 changelog_file = fullfile (packdir, "ChangeLog"); |
|
|
1517 if (exist (changelog_file, "file")) |
|
|
1518 [status, output] = copyfile (changelog_file, packinfo); |
|
6496
|
1519 if (status != 1) |
|
|
1520 rm_rf (desc.dir); |
|
6925
|
1521 rm_rf (octfiledir); |
|
6496
|
1522 error ("couldn't copy ChangeLog file: %s", output); |
|
6254
|
1523 endif |
|
6496
|
1524 endif |
|
6254
|
1525 |
|
6496
|
1526 ## Is there an INDEX file to copy or should we generate one? |
|
7498
|
1527 index_file = fullfile (packdir, "INDEX"); |
|
|
1528 if (exist(index_file, "file")) |
|
|
1529 [status, output] = copyfile (index_file, packinfo); |
|
6496
|
1530 if (status != 1) |
|
|
1531 rm_rf (desc.dir); |
|
6925
|
1532 rm_rf (octfiledir); |
|
6496
|
1533 error ("couldn't copy INDEX file: %s", output); |
|
5801
|
1534 endif |
|
6496
|
1535 else |
|
|
1536 try |
|
7498
|
1537 write_index (desc, fullfile (packdir, "inst"), |
|
6925
|
1538 fullfile (packinfo, "INDEX"), global_install); |
|
6496
|
1539 catch |
|
|
1540 rm_rf (desc.dir); |
|
6925
|
1541 rm_rf (octfiledir); |
|
6695
|
1542 rethrow (lasterror ()); |
|
6496
|
1543 end_try_catch |
|
|
1544 endif |
|
5971
|
1545 |
|
6496
|
1546 ## Is there an 'on_uninstall.m' to install? |
|
7498
|
1547 fon_uninstall = fullfile (packdir, "on_uninstall.m"); |
|
6496
|
1548 if (exist (fon_uninstall, "file")) |
|
|
1549 [status, output] = copyfile (fon_uninstall, packinfo); |
|
|
1550 if (status != 1) |
|
|
1551 rm_rf (desc.dir); |
|
6925
|
1552 rm_rf (octfiledir); |
|
6496
|
1553 error ("couldn't copy on_uninstall.m: %s", output); |
|
5971
|
1554 endif |
|
6496
|
1555 endif |
|
5971
|
1556 |
|
6496
|
1557 ## Is there a doc/ directory that needs to be installed |
|
|
1558 docdir = fullfile (packdir, "doc"); |
|
|
1559 if (exist (docdir, "dir") && ! dirempty (docdir)) |
|
6925
|
1560 [status, output] = copyfile (docdir, desc.dir); |
|
6496
|
1561 endif |
|
|
1562 |
|
|
1563 ## Is there a bin/ directory that needs to be installed |
|
6950
|
1564 ## FIXME: Need to treat architecture dependent files in bin/ |
|
6496
|
1565 bindir = fullfile (packdir, "bin"); |
|
|
1566 if (exist (bindir, "dir") && ! dirempty (bindir)) |
|
6925
|
1567 [status, output] = copyfile (bindir, desc.dir); |
|
6496
|
1568 endif |
|
5801
|
1569 endfunction |
|
|
1570 |
|
6925
|
1571 function finish_installation (desc, packdir, global_install) |
|
6496
|
1572 ## Is there a post-install to call? |
|
|
1573 if (exist (fullfile (packdir, "post_install.m"), "file")) |
|
|
1574 wd = pwd (); |
|
|
1575 try |
|
|
1576 cd (packdir); |
|
|
1577 post_install (desc); |
|
|
1578 cd (wd); |
|
|
1579 catch |
|
|
1580 cd (wd); |
|
|
1581 rm_rf (desc.dir); |
|
6925
|
1582 rm_rf (getarchdir (desc), global_install); |
|
6695
|
1583 rethrow (lasterror ()); |
|
6496
|
1584 end_try_catch |
|
|
1585 endif |
|
5801
|
1586 endfunction |
|
|
1587 |
|
7498
|
1588 ## Make sure the package contains the essential files. |
|
6496
|
1589 function verify_directory (dir) |
|
|
1590 needed_files = {"COPYING", "DESCRIPTION"}; |
|
|
1591 for f = needed_files |
|
|
1592 if (! exist (fullfile (dir, f{1}), "file")) |
|
|
1593 error ("package is missing file: %s", f{1}); |
|
|
1594 endif |
|
|
1595 endfor |
|
5801
|
1596 endfunction |
|
|
1597 |
|
7498
|
1598 ## Parse the DESCRIPTION file |
|
6496
|
1599 function desc = get_description (filename) |
|
|
1600 [fid, msg] = fopen (filename, "r"); |
|
|
1601 if (fid == -1) |
|
|
1602 error ("the DESCRIPTION file %s could not be read: %s", filename, msg); |
|
|
1603 endif |
|
|
1604 |
|
|
1605 desc = struct (); |
|
5801
|
1606 |
|
6496
|
1607 line = fgetl (fid); |
|
|
1608 while (line != -1) |
|
|
1609 if (line(1) == "#") |
|
|
1610 ## Comments, do nothing |
|
|
1611 elseif (isspace(line(1))) |
|
|
1612 ## Continuation lines |
|
|
1613 if (exist ("keyword", "var") && isfield (desc, keyword)) |
|
|
1614 desc.(keyword) = strcat (desc.(keyword), " ", rstrip(line)); |
|
|
1615 endif |
|
5801
|
1616 else |
|
6496
|
1617 ## Keyword/value pair |
|
|
1618 colon = find (line == ":"); |
|
|
1619 if (length (colon) == 0) |
|
|
1620 disp ("skipping line"); |
|
|
1621 else |
|
|
1622 colon = colon(1); |
|
|
1623 keyword = tolower (strip (line(1:colon-1))); |
|
7498
|
1624 value = strip (line (colon+1:end)); |
|
6496
|
1625 if (length (value) == 0) |
|
|
1626 fclose (fid); |
|
|
1627 error ("the keyword %s has an empty value", desc.keywords{end}); |
|
|
1628 endif |
|
|
1629 desc.(keyword) = value; |
|
|
1630 endif |
|
5801
|
1631 endif |
|
6496
|
1632 line = fgetl (fid); |
|
|
1633 endwhile |
|
|
1634 fclose (fid); |
|
|
1635 |
|
|
1636 ## Make sure all is okay |
|
|
1637 needed_fields = {"name", "version", "date", "title", ... |
|
|
1638 "author", "maintainer", "description"}; |
|
|
1639 for f = needed_fields |
|
|
1640 if (! isfield (desc, f{1})) |
|
|
1641 error ("description is missing needed field %s", f{1}); |
|
|
1642 endif |
|
|
1643 endfor |
|
|
1644 desc.version = fix_version (desc.version); |
|
|
1645 if (isfield (desc, "depends")) |
|
|
1646 desc.depends = fix_depends (desc.depends); |
|
|
1647 else |
|
|
1648 desc.depends = ""; |
|
|
1649 endif |
|
|
1650 desc.name = tolower (desc.name); |
|
5801
|
1651 endfunction |
|
|
1652 |
|
7498
|
1653 ## Make sure the version string v is a valid x.y.z version string |
|
5801
|
1654 ## Examples: "0.1" => "0.1.0", "monkey" => error(...) |
|
6496
|
1655 function out = fix_version (v) |
|
|
1656 dots = find (v == "."); |
|
|
1657 if (length (dots) == 1) |
|
|
1658 major = str2num (v(1:dots-1)); |
|
|
1659 minor = str2num (v(dots+1:end)); |
|
|
1660 if (length (major) != 0 && length (minor) != 0) |
|
|
1661 out = sprintf ("%d.%d.0", major, minor); |
|
|
1662 return; |
|
5801
|
1663 endif |
|
6496
|
1664 elseif (length (dots) == 2) |
|
|
1665 major = str2num (v(1:dots(1)-1)); |
|
|
1666 minor = str2num (v(dots(1)+1:dots(2)-1)); |
|
7498
|
1667 rev = str2num (v(dots(2)+1:end)); |
|
6496
|
1668 if (length (major) != 0 && length (minor) != 0 && length (rev) != 0) |
|
|
1669 out = sprintf ("%d.%d.%d", major, minor, rev); |
|
|
1670 return; |
|
|
1671 endif |
|
|
1672 endif |
|
|
1673 error ("bad version string: %s", v); |
|
5801
|
1674 endfunction |
|
|
1675 |
|
7498
|
1676 ## Make sure the depends field is of the right format. |
|
5801
|
1677 ## This function returns a cell of structures with the following fields: |
|
|
1678 ## package, version, operator |
|
6496
|
1679 function deps_cell = fix_depends (depends) |
|
|
1680 deps = split_by (tolower (depends), ","); |
|
|
1681 deps_cell = cell (1, length (deps)); |
|
|
1682 |
|
|
1683 ## For each dependency |
|
|
1684 for i = 1:length (deps) |
|
|
1685 dep = deps{i}; |
|
|
1686 lpar = find (dep == "("); |
|
|
1687 rpar = find (dep == ")"); |
|
|
1688 ## Does the dependency specify a version |
|
|
1689 ## Example: package(>= version) |
|
|
1690 if (length (lpar) == 1 && length (rpar) == 1) |
|
|
1691 package = tolower (strip (dep(1:lpar-1))); |
|
|
1692 sub = dep(lpar(1)+1:rpar(1)-1); |
|
|
1693 parts = split_by (sub, " "); |
|
|
1694 idx = []; |
|
|
1695 for r = 1:size (parts, 1) |
|
|
1696 if (length (parts{r}) > 0) |
|
|
1697 idx(end+1) = r; |
|
|
1698 endif |
|
|
1699 endfor |
|
|
1700 |
|
|
1701 if (length (idx) != 2) |
|
|
1702 error ("incorrect syntax for dependency `%s' in the DESCRIPTION file\n", |
|
|
1703 dep); |
|
|
1704 endif |
|
|
1705 operator = parts{idx(1)}; |
|
|
1706 if (! any (strcmp (operator, {">", ">=", "<=", "<", "=="}))) |
|
|
1707 error ("unsupported operator: %s", operator); |
|
|
1708 endif |
|
|
1709 version = fix_version (parts{idx(2)}); |
|
|
1710 |
|
|
1711 ## If no version is specified for the dependency |
|
|
1712 ## we say that the version should be greater than |
|
|
1713 ## or equal to 0.0.0 |
|
|
1714 else |
|
|
1715 package = tolower (strip (dep)); |
|
|
1716 operator = ">="; |
|
|
1717 version = "0.0.0"; |
|
|
1718 endif |
|
|
1719 deps_cell{i} = struct ("package", package, "operator", operator, |
|
|
1720 "version", version); |
|
|
1721 endfor |
|
5801
|
1722 endfunction |
|
|
1723 |
|
7498
|
1724 ## Strip the text of spaces from the right |
|
5801
|
1725 ## Example: " hello world " => " hello world" (XXX: is this the same as deblank?) |
|
6496
|
1726 function text = rstrip (text) |
|
|
1727 chars = find (! isspace (text)); |
|
|
1728 if (length (chars) > 0) |
|
|
1729 ## XXX: shouldn't it be text = text(1:chars(end)); |
|
|
1730 text = text (chars(1):end); |
|
|
1731 else |
|
|
1732 text = ""; |
|
|
1733 endif |
|
5801
|
1734 endfunction |
|
|
1735 |
|
7498
|
1736 ## Strip the text of spaces from the left and the right |
|
5801
|
1737 ## Example: " hello world " => "hello world" |
|
6496
|
1738 function text = strip (text) |
|
|
1739 chars = find (! isspace (text)); |
|
|
1740 if (length (chars) > 0) |
|
|
1741 text = text(chars(1):chars(end)); |
|
|
1742 else |
|
|
1743 text = ""; |
|
|
1744 endif |
|
5801
|
1745 endfunction |
|
|
1746 |
|
7498
|
1747 ## Split the text into a cell array of strings by sep |
|
5801
|
1748 ## Example: "A, B" => {"A", "B"} (with sep = ",") |
|
6496
|
1749 function out = split_by (text, sep) |
|
|
1750 text_matrix = split (text, sep); |
|
|
1751 num_words = size (text_matrix, 1); |
|
|
1752 out = cell (num_words, 1); |
|
|
1753 for i = 1:num_words |
|
|
1754 out{i} = strip (text_matrix(i, :)); |
|
|
1755 endfor |
|
5801
|
1756 endfunction |
|
|
1757 |
|
7498
|
1758 ## Create an INDEX file for a package that doesn't provide one. |
|
5801
|
1759 ## 'desc' describes the package. |
|
7498
|
1760 ## 'dir' is the 'inst' directory in temporary directory. |
|
|
1761 ## 'index_file' is the name (including path) of resulting INDEX file. |
|
|
1762 function write_index (desc, dir, index_file, global_install) |
|
6496
|
1763 ## Get names of functions in dir |
|
|
1764 [files, err, msg] = readdir (dir); |
|
|
1765 if (err) |
|
|
1766 error ("couldn't read directory %s: %s", dir, msg); |
|
|
1767 endif |
|
|
1768 |
|
6634
|
1769 ## Check for architecture dependent files |
|
6925
|
1770 tmpdir = getarchdir (desc); |
|
6634
|
1771 if (exist (tmpdir, "dir")) |
|
|
1772 [files2, err, msg] = readdir (tmpdir); |
|
|
1773 if (err) |
|
|
1774 error ("couldn't read directory %s: %s", tmpdir, msg); |
|
|
1775 endif |
|
|
1776 files = [files; files2]; |
|
|
1777 endif |
|
|
1778 |
|
6496
|
1779 functions = {}; |
|
|
1780 for i = 1:length (files) |
|
|
1781 file = files{i}; |
|
|
1782 lf = length (file); |
|
|
1783 if (lf > 2 && strcmp (file(end-1:end), ".m")) |
|
|
1784 functions{end+1} = file(1:end-2); |
|
|
1785 elseif (lf > 4 && strcmp (file(end-3:end), ".oct")) |
|
|
1786 functions{end+1} = file(1:end-4); |
|
5801
|
1787 endif |
|
6496
|
1788 endfor |
|
|
1789 |
|
|
1790 ## Does desc have a categories field? |
|
|
1791 if (! isfield (desc, "categories")) |
|
|
1792 error ("the DESCRIPTION file must have a Categories field, when no INDEX file is given"); |
|
|
1793 endif |
|
|
1794 categories = split_by (desc.categories, ","); |
|
|
1795 if (length (categories) < 1) |
|
|
1796 error ("the Category field is empty"); |
|
|
1797 endif |
|
|
1798 |
|
|
1799 ## Write INDEX |
|
7498
|
1800 fid = fopen (index_file, "w"); |
|
6496
|
1801 if (fid == -1) |
|
7498
|
1802 error ("couldn't open %s for writing.", index_file); |
|
6496
|
1803 endif |
|
|
1804 fprintf (fid, "%s >> %s\n", desc.name, desc.title); |
|
|
1805 fprintf (fid, "%s\n", categories{1}); |
|
|
1806 fprintf (fid, " %s\n", functions{:}); |
|
|
1807 fclose (fid); |
|
5801
|
1808 endfunction |
|
|
1809 |
|
6820
|
1810 function bad_deps = get_unsatisfied_deps (desc, installed_pkgs_lst) |
|
6496
|
1811 bad_deps = {}; |
|
5801
|
1812 |
|
6496
|
1813 ## For each dependency |
|
|
1814 for i = 1:length (desc.depends) |
|
|
1815 dep = desc.depends{i}; |
|
5801
|
1816 |
|
6496
|
1817 ## Is the current dependency Octave? |
|
|
1818 if (strcmp (dep.package, "octave")) |
|
|
1819 if (! compare_versions (OCTAVE_VERSION, dep.version, dep.operator)) |
|
|
1820 bad_deps{end+1} = dep; |
|
6258
|
1821 endif |
|
6496
|
1822 ## Is the current dependency not Octave? |
|
|
1823 else |
|
|
1824 ok = false; |
|
6820
|
1825 for i = 1:length (installed_pkgs_lst) |
|
|
1826 cur_name = installed_pkgs_lst{i}.name; |
|
|
1827 cur_version = installed_pkgs_lst{i}.version; |
|
6496
|
1828 if (strcmp (dep.package, cur_name) |
|
|
1829 && compare_versions (cur_version, dep.version, dep.operator)) |
|
|
1830 ok = true; |
|
|
1831 break; |
|
6258
|
1832 endif |
|
|
1833 endfor |
|
6496
|
1834 if (! ok) |
|
|
1835 bad_deps{end+1} = dep; |
|
|
1836 endif |
|
5801
|
1837 endif |
|
6496
|
1838 endfor |
|
|
1839 endfunction |
|
|
1840 |
|
|
1841 function [out1, out2] = installed_packages (local_list, global_list) |
|
|
1842 ## Get the list of installed packages |
|
|
1843 try |
|
|
1844 local_packages = load (local_list).local_packages; |
|
|
1845 catch |
|
|
1846 local_packages = {}; |
|
|
1847 end_try_catch |
|
|
1848 try |
|
6675
|
1849 global_packages = load (global_list).global_packages; |
|
6496
|
1850 catch |
|
|
1851 global_packages = {}; |
|
|
1852 end_try_catch |
|
6820
|
1853 installed_pkgs_lst = {local_packages{:}, global_packages{:}}; |
|
6496
|
1854 |
|
|
1855 ## Eliminate duplicates in the installed package list. |
|
|
1856 ## Locally installed packages take precedence |
|
|
1857 dup = []; |
|
6820
|
1858 for i = 1:length (installed_pkgs_lst) |
|
6496
|
1859 if (find (dup, i)) |
|
|
1860 continue; |
|
5801
|
1861 endif |
|
6820
|
1862 for j = (i+1):length (installed_pkgs_lst) |
|
6496
|
1863 if (find (dup, j)) |
|
|
1864 continue; |
|
|
1865 endif |
|
6820
|
1866 if (strcmp (installed_pkgs_lst{i}.name, installed_pkgs_lst{j}.name)) |
|
6496
|
1867 dup = [dup, j]; |
|
|
1868 endif |
|
5987
|
1869 endfor |
|
6496
|
1870 endfor |
|
|
1871 if (! isempty(dup)) |
|
6820
|
1872 installed_pkgs_lst(dup) = []; |
|
6496
|
1873 endif |
|
|
1874 |
|
6616
|
1875 ## Now check if the package is loaded |
|
6645
|
1876 tmppath = strrep (path(), "\\", "/"); |
|
6820
|
1877 for i = 1:length (installed_pkgs_lst) |
|
|
1878 if (findstr (tmppath, strrep (installed_pkgs_lst{i}.dir, "\\", "/"))) |
|
|
1879 installed_pkgs_lst{i}.loaded = true; |
|
6616
|
1880 else |
|
6820
|
1881 installed_pkgs_lst{i}.loaded = false; |
|
6616
|
1882 endif |
|
|
1883 endfor |
|
6675
|
1884 for i = 1:length (local_packages) |
|
6776
|
1885 if (findstr (tmppath, strrep (local_packages{i}.dir, "\\", "/"))) |
|
6675
|
1886 local_packages{i}.loaded = true; |
|
|
1887 else |
|
|
1888 local_packages{i}.loaded = false; |
|
|
1889 endif |
|
|
1890 endfor |
|
|
1891 for i = 1:length (global_packages) |
|
6776
|
1892 if (findstr (tmppath, strrep (global_packages{i}.dir, "\\", "/"))) |
|
6675
|
1893 global_packages{i}.loaded = true; |
|
|
1894 else |
|
|
1895 global_packages{i}.loaded = false; |
|
|
1896 endif |
|
|
1897 endfor |
|
6616
|
1898 |
|
6496
|
1899 ## Should we return something? |
|
|
1900 if (nargout == 2) |
|
|
1901 out1 = local_packages; |
|
|
1902 out2 = global_packages; |
|
|
1903 return; |
|
|
1904 elseif (nargout == 1) |
|
6820
|
1905 out1 = installed_pkgs_lst; |
|
6496
|
1906 return; |
|
|
1907 endif |
|
|
1908 |
|
|
1909 ## We shouldn't return something, so we'll print something |
|
6820
|
1910 num_packages = length (installed_pkgs_lst); |
|
6496
|
1911 if (num_packages == 0) |
|
|
1912 printf ("no packages installed.\n"); |
|
|
1913 return; |
|
|
1914 endif |
|
|
1915 |
|
|
1916 ## Compute the maximal lengths of name, version, and dir |
|
|
1917 h1 = "Package Name"; |
|
|
1918 h2 = "Version"; |
|
|
1919 h3 = "Installation directory"; |
|
|
1920 max_name_length = length (h1); |
|
|
1921 max_version_length = length (h2); |
|
|
1922 names = cell (num_packages, 1); |
|
|
1923 for i = 1:num_packages |
|
|
1924 max_name_length = max (max_name_length, |
|
6820
|
1925 length (installed_pkgs_lst{i}.name)); |
|
6496
|
1926 max_version_length = max (max_version_length, |
|
6820
|
1927 length (installed_pkgs_lst{i}.version)); |
|
|
1928 names{i} = installed_pkgs_lst{i}.name; |
|
6496
|
1929 endfor |
|
6698
|
1930 max_dir_length = terminal_size()(2) - max_name_length - ... |
|
|
1931 max_version_length - 7; |
|
|
1932 if (max_dir_length < 20) |
|
|
1933 max_dir_length = Inf; |
|
|
1934 endif |
|
|
1935 |
|
6616
|
1936 h1 = postpad (h1, max_name_length + 1, " "); |
|
6496
|
1937 h2 = postpad (h2, max_version_length, " ");; |
|
|
1938 |
|
|
1939 ## Print a header |
|
|
1940 header = sprintf("%s | %s | %s\n", h1, h2, h3); |
|
|
1941 printf (header); |
|
|
1942 tmp = sprintf (repmat ("-", 1, length(header)-1)); |
|
|
1943 tmp(length(h1)+2) = "+"; |
|
|
1944 tmp(length(h1)+length(h2)+5) = "+"; |
|
|
1945 printf ("%s\n", tmp); |
|
|
1946 |
|
|
1947 ## Print the packages |
|
6616
|
1948 format = sprintf ("%%%ds %%1s| %%%ds | %%s\n", max_name_length, |
|
6496
|
1949 max_version_length); |
|
|
1950 [dummy, idx] = sort (names); |
|
|
1951 for i = 1:num_packages |
|
6820
|
1952 cur_name = installed_pkgs_lst{idx(i)}.name; |
|
|
1953 cur_version = installed_pkgs_lst{idx(i)}.version; |
|
|
1954 cur_dir = installed_pkgs_lst{idx(i)}.dir; |
|
6698
|
1955 if (length (cur_dir) > max_dir_length) |
|
|
1956 first_char = length (cur_dir) - max_dir_length + 4; |
|
|
1957 first_filesep = strfind (cur_dir(first_char:end), filesep()); |
|
|
1958 if (! isempty (first_filesep)) |
|
|
1959 cur_dir = strcat ("...", |
|
|
1960 cur_dir((first_char + first_filesep(1) - 1):end)); |
|
|
1961 else |
|
|
1962 cur_dir = strcat ("...", cur_dir(first_char:end)); |
|
|
1963 endif |
|
|
1964 endif |
|
6820
|
1965 if (installed_pkgs_lst{idx(i)}.loaded) |
|
6616
|
1966 cur_loaded = "*"; |
|
|
1967 else |
|
|
1968 cur_loaded = " "; |
|
|
1969 endif |
|
|
1970 printf (format, cur_name, cur_loaded, cur_version, cur_dir); |
|
6496
|
1971 endfor |
|
5801
|
1972 endfunction |
|
|
1973 |
|
6496
|
1974 function load_packages (files, handle_deps, local_list, global_list) |
|
6820
|
1975 installed_pkgs_lst = installed_packages (local_list, global_list); |
|
|
1976 num_packages = length (installed_pkgs_lst); |
|
6496
|
1977 |
|
|
1978 ## Read package names and installdirs into a more convenient format |
|
|
1979 pnames = pdirs = cell (1, num_packages); |
|
|
1980 for i = 1:num_packages |
|
6820
|
1981 pnames{i} = installed_pkgs_lst{i}.name; |
|
|
1982 pdirs{i} = installed_pkgs_lst{i}.dir; |
|
6496
|
1983 endfor |
|
|
1984 |
|
|
1985 ## load all |
|
|
1986 if (length (files) == 1 && strcmp (files{1}, "all")) |
|
6820
|
1987 idx = [1:length(installed_pkgs_lst)]; |
|
6496
|
1988 ## load auto |
|
6695
|
1989 elseif (length (files) == 1 && strcmp (files{1}, "auto")) |
|
|
1990 idx = []; |
|
6820
|
1991 for i = 1:length (installed_pkgs_lst) |
|
6496
|
1992 if (exist (fullfile (pdirs{i}, "packinfo", ".autoload"), "file")) |
|
6695
|
1993 idx (end + 1) = i; |
|
6496
|
1994 endif |
|
6037
|
1995 endfor |
|
6496
|
1996 ## load package_name1 ... |
|
|
1997 else |
|
6695
|
1998 idx = []; |
|
6496
|
1999 for i = 1:length (files) |
|
6695
|
2000 idx2 = find (strcmp (pnames, files{i})); |
|
|
2001 if (! any (idx2)) |
|
6496
|
2002 error ("package %s is not installed", files{i}); |
|
|
2003 endif |
|
6695
|
2004 idx (end + 1) = idx2; |
|
6496
|
2005 endfor |
|
|
2006 endif |
|
6037
|
2007 |
|
6695
|
2008 ## Load the packages, but take care of the ordering of dependencies |
|
6925
|
2009 load_packages_and_dependencies (idx, handle_deps, installed_pkgs_lst, true); |
|
5801
|
2010 endfunction |
|
5928
|
2011 |
|
6496
|
2012 function unload_packages (files, handle_deps, local_list, global_list) |
|
6820
|
2013 installed_pkgs_lst = installed_packages (local_list, global_list); |
|
|
2014 num_packages = length (installed_pkgs_lst); |
|
6496
|
2015 |
|
|
2016 ## Read package names and installdirs into a more convenient format |
|
|
2017 pnames = pdirs = cell (1, num_packages); |
|
|
2018 for i = 1:num_packages |
|
6820
|
2019 pnames{i} = installed_pkgs_lst{i}.name; |
|
|
2020 pdirs{i} = installed_pkgs_lst{i}.dir; |
|
|
2021 pdeps{i} = installed_pkgs_lst{i}.depends; |
|
6496
|
2022 endfor |
|
|
2023 |
|
|
2024 ## Get the current octave path |
|
|
2025 p = split_by (path(), pathsep ()); |
|
6203
|
2026 |
|
6496
|
2027 ## unload all |
|
|
2028 if (length (files) == 1 && strcmp (files{1}, "all")) |
|
|
2029 dirs = pdirs; |
|
6925
|
2030 desc = installed_pkgs_lst; |
|
6496
|
2031 ## unload package_name1 ... |
|
|
2032 else |
|
|
2033 dirs = {}; |
|
6925
|
2034 desc = {}; |
|
6496
|
2035 for i = 1:length (files) |
|
7208
|
2036 idx = strcmp (pnames, files{i}); |
|
6496
|
2037 if (! any (idx)) |
|
|
2038 error ("package %s is not installed", files{i}); |
|
|
2039 endif |
|
7208
|
2040 dirs{end+1} = pdirs{idx}; |
|
|
2041 desc{end+1} = installed_pkgs_lst{idx}; |
|
6496
|
2042 endfor |
|
|
2043 endif |
|
|
2044 |
|
6614
|
2045 ## Check for architecture dependent directories |
|
|
2046 archdirs = {}; |
|
|
2047 for i = 1:length (dirs) |
|
7208
|
2048 tmpdir = getarchdir (desc{i}); |
|
6614
|
2049 if (exist (tmpdir, "dir")) |
|
7208
|
2050 archdirs{end+1} = dirs{i}; |
|
|
2051 archdirs{end+1} = tmpdir; |
|
6925
|
2052 else |
|
7208
|
2053 archdirs{end+1} = dirs{i}; |
|
6614
|
2054 endif |
|
|
2055 endfor |
|
|
2056 |
|
6496
|
2057 ## Unload the packages |
|
6925
|
2058 for i = 1:length (archdirs) |
|
|
2059 d = archdirs{i}; |
|
6496
|
2060 idx = strcmp (p, d); |
|
|
2061 if (any (idx)) |
|
|
2062 rmpath (d); |
|
|
2063 ## XXX: We should also check if we need to remove items from EXEC_PATH |
|
6203
|
2064 endif |
|
6496
|
2065 endfor |
|
6203
|
2066 endfunction |
|
|
2067 |
|
5928
|
2068 function [status_out, msg_out] = rm_rf (dir) |
|
6925
|
2069 if (exist (dir)) |
|
|
2070 crr = confirm_recursive_rmdir (); |
|
|
2071 unwind_protect |
|
|
2072 confirm_recursive_rmdir (false); |
|
|
2073 [status, msg] = rmdir (dir, "s"); |
|
|
2074 unwind_protect_cleanup |
|
|
2075 confirm_recursive_rmdir (crr); |
|
|
2076 end_unwind_protect |
|
|
2077 else |
|
|
2078 status = 1; |
|
|
2079 msg = ""; |
|
|
2080 endif |
|
5928
|
2081 if (nargout > 0) |
|
|
2082 status_out = status; |
|
|
2083 endif |
|
|
2084 if (nargout > 1) |
|
|
2085 msg_out = msg; |
|
|
2086 endif |
|
|
2087 endfunction |
|
5971
|
2088 |
|
|
2089 function emp = dirempty (nm, ign) |
|
6925
|
2090 if (exist (nm, "dir")) |
|
|
2091 if (nargin < 2) |
|
|
2092 ign = {".", ".."}; |
|
|
2093 else |
|
|
2094 ign = [{".", ".."}, ign]; |
|
|
2095 endif |
|
|
2096 l = dir (nm); |
|
|
2097 for i = 1:length (l) |
|
|
2098 found = false; |
|
|
2099 for j = 1:length (ign) |
|
|
2100 if (strcmp (l(i).name, ign{j})) |
|
|
2101 found = true; |
|
|
2102 break; |
|
|
2103 endif |
|
|
2104 endfor |
|
|
2105 if (! found) |
|
|
2106 emp = false; |
|
|
2107 return |
|
5971
|
2108 endif |
|
|
2109 endfor |
|
6925
|
2110 emp = true; |
|
|
2111 else |
|
|
2112 emp = true; |
|
|
2113 endif |
|
5971
|
2114 endfunction |
|
6614
|
2115 |
|
|
2116 function arch = getarch () |
|
6675
|
2117 persistent _arch = strcat (octave_config_info("canonical_host_type"), ... |
|
|
2118 "-", octave_config_info("api_version")); |
|
6614
|
2119 arch = _arch; |
|
|
2120 endfunction |
|
6645
|
2121 |
|
6925
|
2122 function archprefix = getarchprefix (desc, global_install) |
|
|
2123 if ((nargin == 2 && global_install) || (nargin < 2 && issuperuser ())) |
|
|
2124 archprefix = fullfile (octave_config_info ("libexecdir"), "octave", |
|
|
2125 "packages", strcat(desc.name, "-", desc.version)); |
|
|
2126 else |
|
|
2127 archprefix = desc.dir; |
|
|
2128 endif |
|
|
2129 endfunction |
|
|
2130 |
|
|
2131 function archdir = getarchdir (desc) |
|
|
2132 archdir = fullfile (desc.archprefix, getarch()); |
|
|
2133 endfunction |
|
|
2134 |
|
|
2135 function s = issuperuser () |
|
|
2136 if ((ispc () && ! isunix ()) || (geteuid() == 0)) |
|
|
2137 s = true; |
|
|
2138 else |
|
|
2139 s = false; |
|
|
2140 endif |
|
|
2141 endfunction |
|
|
2142 |
|
6645
|
2143 function [status, output] = shell (cmd) |
|
|
2144 persistent have_sh; |
|
|
2145 |
|
|
2146 cmd = strrep (cmd, "\\", "/"); |
|
|
2147 if (ispc () && ! isunix ()) |
|
|
2148 if (isempty(have_sh)) |
|
|
2149 if (system("sh.exe -c \"exit\"")) |
|
|
2150 have_sh = false; |
|
|
2151 else |
|
|
2152 have_sh = true; |
|
|
2153 endif |
|
|
2154 endif |
|
|
2155 if (have_sh) |
|
6675
|
2156 [status, output] = system (strcat ("sh.exe -c \"", cmd, "\"")); |
|
6645
|
2157 else |
|
|
2158 error ("Can not find the command shell") |
|
|
2159 endif |
|
|
2160 else |
|
|
2161 [status, output] = system (cmd); |
|
|
2162 endif |
|
|
2163 endfunction |
|
6695
|
2164 |
|
|
2165 function newdesc = save_order (desc) |
|
|
2166 newdesc = {}; |
|
|
2167 for i = 1 : length(desc) |
|
|
2168 deps = desc{i}.depends; |
|
|
2169 if (isempty (deps) || (length (deps) == 1 && |
|
|
2170 strcmp(deps{1}.package, "octave"))) |
|
|
2171 newdesc {end + 1} = desc{i}; |
|
|
2172 else |
|
|
2173 tmpdesc = {}; |
|
|
2174 for k = 1 : length (deps) |
|
|
2175 for j = 1 : length (desc) |
|
|
2176 if (strcmp (desc{j}.name, deps{k}.package)) |
|
7208
|
2177 tmpdesc{end+1} = desc{j}; |
|
6695
|
2178 break; |
|
|
2179 endif |
|
|
2180 endfor |
|
|
2181 endfor |
|
|
2182 if (! isempty (tmpdesc)) |
|
|
2183 newdesc = {newdesc{:}, save_order(tmpdesc){:}, desc{i}}; |
|
|
2184 else |
|
7208
|
2185 newdesc{end+1} = desc{i}; |
|
6695
|
2186 endif |
|
|
2187 endif |
|
|
2188 endfor |
|
|
2189 ## Eliminate the duplicates |
|
|
2190 idx = []; |
|
|
2191 for i = 1 : length (newdesc) |
|
|
2192 for j = (i + 1) : length (newdesc) |
|
|
2193 if (strcmp (newdesc{i}.name, newdesc{j}.name)) |
|
|
2194 idx (end + 1) = j; |
|
|
2195 endif |
|
|
2196 endfor |
|
|
2197 endfor |
|
|
2198 newdesc(idx) = []; |
|
|
2199 endfunction |
|
|
2200 |
|
6925
|
2201 function load_packages_and_dependencies (idx, handle_deps, installed_pkgs_lst, |
|
|
2202 global_install) |
|
6820
|
2203 idx = load_package_dirs (idx, [], handle_deps, installed_pkgs_lst); |
|
6695
|
2204 dirs = {}; |
|
|
2205 execpath = EXEC_PATH (); |
|
|
2206 for i = idx; |
|
6820
|
2207 ndir = installed_pkgs_lst{i}.dir; |
|
7208
|
2208 dirs{end+1} = ndir; |
|
6695
|
2209 if (exist (fullfile (dirs{end}, "bin"), "dir")) |
|
7498
|
2210 execpath = strcat (fullfile (dirs{end}, "bin"), ":", execpath); |
|
6695
|
2211 endif |
|
7208
|
2212 tmpdir = getarchdir (installed_pkgs_lst{i}); |
|
6695
|
2213 if (exist (tmpdir, "dir")) |
|
|
2214 dirs{end + 1} = tmpdir; |
|
6950
|
2215 if (exist (fullfile (dirs{end}, "bin"), "dir")) |
|
7498
|
2216 execpath = strcat (fullfile (dirs{end}, "bin"), ":", execpath); |
|
6950
|
2217 endif |
|
6695
|
2218 endif |
|
|
2219 endfor |
|
|
2220 |
|
|
2221 ## Load the packages |
|
|
2222 if (length (dirs) > 0) |
|
|
2223 addpath (dirs{:}); |
|
|
2224 endif |
|
|
2225 |
|
|
2226 ## Add the binaries to exec_path |
|
|
2227 if (! strcmp (EXEC_PATH, execpath)) |
|
|
2228 EXEC_PATH (execpath); |
|
|
2229 endif |
|
|
2230 endfunction |
|
|
2231 |
|
6820
|
2232 function idx = load_package_dirs (lidx, idx, handle_deps, installed_pkgs_lst) |
|
6695
|
2233 for i = lidx |
|
6820
|
2234 if (isfield (installed_pkgs_lst{i}, "loaded") && |
|
|
2235 installed_pkgs_lst{i}.loaded) |
|
6695
|
2236 continue; |
|
|
2237 else |
|
|
2238 if (handle_deps) |
|
6820
|
2239 deps = installed_pkgs_lst{i}.depends; |
|
6695
|
2240 if ((length (deps) > 1) || (length (deps) == 1 && |
|
|
2241 ! strcmp(deps{1}.package, "octave"))) |
|
|
2242 tmplidx = []; |
|
|
2243 for k = 1 : length (deps) |
|
6820
|
2244 for j = 1 : length (installed_pkgs_lst) |
|
|
2245 if (strcmp (installed_pkgs_lst{j}.name, deps{k}.package)) |
|
6695
|
2246 tmplidx (end + 1) = j; |
|
|
2247 break; |
|
|
2248 endif |
|
|
2249 endfor |
|
|
2250 endfor |
|
|
2251 idx = load_package_dirs (tmplidx, idx, handle_deps, |
|
6820
|
2252 installed_pkgs_lst); |
|
6695
|
2253 endif |
|
|
2254 endif |
|
|
2255 if (isempty (find(idx == i))) |
|
|
2256 idx (end + 1) = i; |
|
|
2257 endif |
|
|
2258 endif |
|
|
2259 endfor |
|
|
2260 endfunction |
|
6950
|
2261 |
|
|
2262 function dep = is_architecture_dependent (nm) |
|
7329
|
2263 persistent archdepsuffix = {".oct",".mex",".a",".lib",".so",".so.*",".dll","dylib"}; |
|
6950
|
2264 |
|
|
2265 dep = false; |
|
|
2266 for i = 1 : length (archdepsuffix) |
|
7208
|
2267 ext = archdepsuffix{i}; |
|
6950
|
2268 if (ext(end) == "*") |
|
|
2269 isglob = true; |
|
|
2270 ext(end) = []; |
|
|
2271 else |
|
|
2272 isglob = false; |
|
|
2273 endif |
|
|
2274 pos = findstr (nm, ext); |
|
|
2275 if (pos) |
|
7208
|
2276 if (! isglob && (length(nm) - pos(end) != length(ext) - 1)) |
|
6950
|
2277 continue; |
|
|
2278 endif |
|
|
2279 dep = true; |
|
|
2280 break; |
|
|
2281 endif |
|
|
2282 endfor |
|
|
2283 endfunction |
