|
5801
|
1 ## Copyright (C) 2005 S�ren Hauberg |
|
|
2 ## |
|
|
3 ## This program is free software; you can redistribute it and/or modify |
|
|
4 ## it under the terms of the GNU General Public License as published by |
|
|
5 ## the Free Software Foundation; either version 2 of the License, or |
|
|
6 ## (at your option) any later version. |
|
|
7 ## |
|
|
8 ## This program is distributed in the hope that it will be useful, |
|
|
9 ## but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
10 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
|
11 ## GNU General Public License for more details. |
|
|
12 ## |
|
|
13 ## You should have received a copy of the GNU General Public License |
|
|
14 ## along with this program; if not, write to the Free Software |
|
|
15 ## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
|
16 |
|
|
17 ## -*- texinfo -*- |
|
|
18 ## @deftypefn {Command} pkg list |
|
|
19 ## @deftypefnx{Command} @var{installed_packages} = pkg list |
|
|
20 ## @deftypefnx{Command} [@var{user_packages}, @var{system_packages}] = pkg list |
|
|
21 ## @deftypefnx{Command} pkg install @var{pkg-name} ... |
|
|
22 ## @deftypefnx{Command} pkg install -nodeps @var{pkg-name} ... |
|
|
23 ## @deftypefnx{Command} pkg uninstall @var{pkg-name} ... |
|
|
24 ## @deftypefnx{Command} pkg uninstall -nodeps @var{pkg-name} ... |
|
|
25 ## @deftypefnx{Command} pkg load all |
|
|
26 ## @deftypefnx{Command} pkg load @var{pkg-name} ... |
|
|
27 ## @deftypefnx{Command} pkg load -nodeps @var{pkg-name} ... |
|
|
28 ## XXX: Where's the docs? |
|
|
29 ## @end deftypefn |
|
5947
|
30 |
|
|
31 ## PKG_ADD: mark_as_command pkg |
|
|
32 |
|
5801
|
33 function [local_packages, global_packages] = pkg(varargin) |
|
|
34 ## Handle input |
|
|
35 if (length(varargin) == 0 || !iscellstr(varargin)) |
|
5928
|
36 print_usage(); |
|
5801
|
37 endif |
|
|
38 files = {}; |
|
|
39 deps = true; |
|
|
40 action = "none"; |
|
|
41 for i = 1:length(varargin) |
|
|
42 switch (varargin{i}) |
|
|
43 case "-nodeps" |
|
|
44 deps = false; |
|
|
45 case {"list", "install", "uninstall", "load"} |
|
|
46 action = varargin{i}; |
|
|
47 otherwise |
|
|
48 files{end+1} = varargin{i}; |
|
|
49 endswitch |
|
|
50 endfor |
|
|
51 |
|
|
52 ## Take action |
|
|
53 switch (action) |
|
|
54 case "list" |
|
|
55 if (nargout == 0) |
|
|
56 installed_packages(); |
|
|
57 elseif (nargout == 1) |
|
|
58 local_packages = installed_packages(); |
|
|
59 elseif (nargout == 2) |
|
|
60 [local_packages, global_packages] = installed_packages(); |
|
|
61 else |
|
|
62 error("Too many output arguments requested.\n"); |
|
|
63 endif |
|
|
64 case "install" |
|
|
65 if (length(files) == 0) |
|
|
66 error("You must specify at least one filename when calling 'pkg install'\n"); |
|
|
67 endif |
|
|
68 install(files, deps); |
|
|
69 case "uninstall" |
|
|
70 if (length(files) == 0) |
|
|
71 error("You must specify at least one package when calling 'pkg uninstall'\n"); |
|
|
72 endif |
|
|
73 uninstall(files, deps); |
|
|
74 case "load" |
|
|
75 if (length(files) == 0) |
|
|
76 error("You must specify at least one package or 'all' when calling 'pkg load'\n"); |
|
|
77 endif |
|
|
78 load_packages(files, deps); |
|
|
79 otherwise |
|
|
80 error("You must specify a valid action for 'pkg'. See 'help pkg' for details\n"); |
|
|
81 endswitch |
|
|
82 endfunction |
|
|
83 |
|
|
84 function install(files, handle_deps) |
|
|
85 ## Set parameters depending on wether or not the installation |
|
|
86 ## is system-wide (global) or local. |
|
|
87 local_list = tilde_expand("~/.octave_packages"); |
|
|
88 global_list = [OCTAVE_HOME "share/octave/octave_packages"]; |
|
|
89 global OCTAVE_PACKAGE_PREFIX; |
|
|
90 prefix_exist = (length(OCTAVE_PACKAGE_PREFIX) != 0 && ischar(OCTAVE_PACKAGE_PREFIX)); |
|
|
91 |
|
|
92 if (issuperuser()) |
|
|
93 global_install = true; |
|
|
94 if (!prefix_exist) |
|
5947
|
95 if (strcmp(OCTAVE_HOME()(end),"/")) |
|
|
96 OCTAVE_PACKAGE_PREFIX = [OCTAVE_HOME "share/octave/packages/"]; |
|
|
97 else |
|
|
98 OCTAVE_PACKAGE_PREFIX = [OCTAVE_HOME "/share/octave/packages/"]; |
|
|
99 endif |
|
5801
|
100 endif |
|
|
101 else |
|
|
102 global_install = false; |
|
|
103 if (!prefix_exist) |
|
|
104 OCTAVE_PACKAGE_PREFIX = "~/octave/"; |
|
|
105 endif |
|
|
106 endif |
|
|
107 prefix = tilde_expand(OCTAVE_PACKAGE_PREFIX); |
|
|
108 if (!prefix_exist) |
|
|
109 warning(["You have not defined an installation prefix, " ... |
|
|
110 "so the following will be used: %s"], prefix); |
|
|
111 endif |
|
|
112 |
|
|
113 # Check that the directory in prefix exist. If it doesn't: create it! |
|
|
114 if (!exist(prefix, "dir")) |
|
|
115 warning("Creating installation directory %s", prefix); |
|
|
116 [status, msg] = mkdir(prefix); |
|
|
117 if (status != 1) |
|
|
118 error("Could not create installation directory: %s\n", msg); |
|
|
119 endif |
|
|
120 endif |
|
|
121 |
|
|
122 ## Get the list of installed packages |
|
|
123 [local_packages, global_packages] = installed_packages(); |
|
|
124 installed_packages = {local_packages{:} global_packages{:}}; |
|
|
125 |
|
|
126 if (global_install) |
|
|
127 packages = global_packages; |
|
|
128 else |
|
|
129 packages = local_packages; |
|
|
130 endif |
|
|
131 |
|
|
132 ## Uncompress the packages and read the DESCRIPTION files |
|
5947
|
133 tmpdirs = packdirs = descriptions = {}; |
|
5801
|
134 try |
|
|
135 ## Unpack the package files and read the DESCRIPTION files |
|
|
136 packages_to_uninstall = []; |
|
|
137 for i = 1:length(files) |
|
|
138 tgz = files{i}; |
|
|
139 |
|
|
140 ## Create a temporary directory |
|
|
141 tmpdir = tmpnam(); |
|
5947
|
142 tmpdirs{end+1} = tmpdir; |
|
5801
|
143 [status, msg] = mkdir(tmpdir); |
|
|
144 if (status != 1) |
|
|
145 error("Couldn't create temporary directory: %s\n", msg); |
|
|
146 endif |
|
|
147 |
|
|
148 ## Uncompress the package |
|
|
149 untar(tgz, tmpdir); |
|
5928
|
150 |
|
5947
|
151 ## Get the name of the directories produced by tar |
|
5801
|
152 [dirlist, err, msg] = readdir(tmpdir); |
|
|
153 if (err) |
|
|
154 error("Couldn't read directory produced by tar: %s\n", msg); |
|
|
155 endif |
|
5947
|
156 |
|
|
157 for k = 3:length(dirlist) # the two first entries of dirlist are "." and ".." |
|
|
158 packdir = [tmpdir "/" dirlist{k} "/"]; |
|
|
159 packdirs{end+1} = packdir; |
|
5801
|
160 |
|
5947
|
161 ## Make sure the package contains necessary files |
|
|
162 verify_directory(packdir); |
|
5928
|
163 |
|
5947
|
164 ## Read the DESCRIPTION file |
|
|
165 filename = [packdir "DESCRIPTION"]; |
|
|
166 desc = get_description(filename); |
|
5928
|
167 |
|
5947
|
168 ## Set default installation directory |
|
|
169 desc.dir = [prefix "/" desc.name "-" desc.version]; |
|
5801
|
170 |
|
5947
|
171 ## Save desc |
|
|
172 descriptions{end+1} = desc; |
|
5801
|
173 |
|
5947
|
174 ## Are any of the new packages already installed? |
|
|
175 ## If so we'll remove the old version. |
|
|
176 for j = 1:length(packages) |
|
|
177 if (strcmp(packages{j}.name, desc.name)) |
|
|
178 packages_to_uninstall(end+1) = j; |
|
|
179 endif |
|
|
180 endfor |
|
|
181 endfor |
|
5801
|
182 endfor |
|
|
183 catch |
|
|
184 ## Something went wrong, delete tmpdirs |
|
|
185 for i = 1:length(tmpdirs) |
|
|
186 tmpdirs{i} |
|
5928
|
187 rm_rf(tmpdirs{i}); |
|
5801
|
188 endfor |
|
|
189 error(lasterr()(8:end)); |
|
|
190 end_try_catch |
|
|
191 |
|
|
192 ## Check dependencies |
|
|
193 if (handle_deps) |
|
|
194 ok = true; |
|
|
195 error_text = ""; |
|
|
196 for i = 1:length(descriptions) |
|
|
197 desc = descriptions{i}; |
|
|
198 idx1 = complement(packages_to_uninstall, 1:length(installed_packages)); |
|
|
199 idx2 = complement(i, 1:length(descriptions)); |
|
|
200 pseudo_installed_packages = {installed_packages{idx1} descriptions{idx2}}; |
|
|
201 bad_deps = get_unsatisfied_deps(desc, pseudo_installed_packages); |
|
|
202 ## Are there any unsatisfied dependencies? |
|
|
203 if (!isempty(bad_deps)) |
|
|
204 ok = false; |
|
|
205 for i = 1:length(bad_deps) |
|
|
206 dep = bad_deps{i}; |
|
|
207 error_text = [error_text " " desc.name " needs " ... |
|
|
208 dep.package " " dep.operator " " ... |
|
|
209 dep.version "\n"]; |
|
|
210 endfor |
|
|
211 endif |
|
|
212 endfor |
|
|
213 |
|
|
214 ## Did we find any unsatisfied dependencies? |
|
|
215 if (!ok) |
|
|
216 error("The following dependencies where unsatisfied:\n %s", error_text); |
|
|
217 endif |
|
|
218 endif |
|
|
219 |
|
|
220 ## Prepare each package for installation |
|
|
221 try |
|
|
222 for i = 1:length(descriptions) |
|
|
223 desc = descriptions{i}; |
|
|
224 pdir = packdirs{i}; |
|
|
225 prepare_installation (desc, pdir); |
|
|
226 configure_make (desc, pdir); |
|
|
227 endfor |
|
|
228 catch |
|
|
229 ## Something went wrong, delete tmpdirs |
|
|
230 for i = 1:length(tmpdirs) |
|
5928
|
231 rm_rf(tmpdirs{i}); |
|
5801
|
232 endfor |
|
|
233 error(lasterr()(8:end)); |
|
|
234 end_try_catch |
|
|
235 |
|
|
236 ## Uninstall the packages that will be replaced |
|
|
237 try |
|
|
238 for i = packages_to_uninstall |
|
|
239 uninstall({installed_packages{i}.name}, false); |
|
|
240 endfor |
|
|
241 catch |
|
|
242 ## Something went wrong, delete tmpdirs |
|
|
243 for i = 1:length(tmpdirs) |
|
5928
|
244 rm_rf(tmpdirs{i}); |
|
5801
|
245 endfor |
|
|
246 error(lasterr()(8:end)); |
|
|
247 end_try_catch |
|
|
248 |
|
|
249 ## Install each package |
|
|
250 try |
|
|
251 for i = 1:length(descriptions) |
|
|
252 desc = descriptions{i}; |
|
|
253 pdir = packdirs{i}; |
|
|
254 copy_files(desc, pdir); |
|
5955
|
255 create_pkgadd(desc, pdir); |
|
5801
|
256 finish_installation (desc, pdir) |
|
|
257 endfor |
|
|
258 catch |
|
|
259 ## Something went wrong, delete tmpdirs |
|
|
260 for i = 1:length(tmpdirs) |
|
5928
|
261 rm_rf(tmpdirs{i}); |
|
5801
|
262 endfor |
|
|
263 error(lasterr()(8:end)); |
|
|
264 end_try_catch |
|
|
265 |
|
|
266 ## Add the packages to the package list |
|
|
267 try |
|
|
268 if (global_install) |
|
|
269 idx = complement(packages_to_uninstall, 1:length(global_packages)); |
|
|
270 global_packages = {global_packages{idx} descriptions{:}}; |
|
|
271 save(global_list, "global_packages"); |
|
|
272 else |
|
|
273 idx = complement(packages_to_uninstall, 1:length(local_packages)); |
|
|
274 local_packages = {local_packages{idx} descriptions{:}}; |
|
|
275 save(local_list, "local_packages"); |
|
|
276 endif |
|
|
277 catch |
|
|
278 ## Something went wrong, delete tmpdirs |
|
|
279 for i = 1:length(tmpdirs) |
|
5928
|
280 rm_rf(tmpdirs{i}); |
|
5801
|
281 endfor |
|
|
282 for i = 1:length(descriptions) |
|
5928
|
283 rm_rf(descriptions{i}.dir); |
|
5801
|
284 endfor |
|
|
285 if (global_install) |
|
|
286 error("Couldn't append to %s: %s\n", global_list, lasterr()(8:end)); |
|
|
287 else |
|
|
288 error("Couldn't append to %s: %s\n", local_list, lasterr()(8:end)); |
|
|
289 endif |
|
|
290 end_try_catch |
|
|
291 |
|
|
292 ## All is well, let's clean up |
|
|
293 for i = 1:length(tmpdirs) |
|
5928
|
294 [status, msg] = rm_rf(tmpdirs{i}); |
|
5801
|
295 if (status != 1) |
|
|
296 warning("Couldn't clean up after my self: %s\n", msg); |
|
|
297 endif |
|
|
298 endfor |
|
|
299 |
|
|
300 ## Add the newly installed packages to the path, so the user |
|
|
301 ## can begin the using. |
|
|
302 dirs = cell(1, length(descriptions)); |
|
|
303 for i = 1:length(descriptions) |
|
|
304 dirs{i} = descriptions{i}.dir; |
|
|
305 endfor |
|
5928
|
306 addpath(dirs{:}); |
|
5801
|
307 endfunction |
|
|
308 |
|
|
309 function uninstall(pkgnames, handle_deps) |
|
|
310 local_list = tilde_expand("~/.octave_packages"); |
|
|
311 global_list = [OCTAVE_HOME "share/octave/octave_packages"]; |
|
|
312 ## Get the list of installed packages |
|
|
313 [local_packages, global_packages] = installed_packages(); |
|
|
314 if (issuperuser()) |
|
|
315 installed_packages = global_packages; |
|
|
316 else |
|
|
317 installed_packages = local_packages; |
|
|
318 endif |
|
|
319 |
|
|
320 num_packages = length(installed_packages); |
|
|
321 delete_idx = []; |
|
|
322 for i = 1:num_packages |
|
|
323 cur_name = installed_packages{i}.name; |
|
|
324 if (any(strcmp(cur_name, pkgnames))) |
|
|
325 delete_idx(end+1) = i; |
|
|
326 endif |
|
|
327 endfor |
|
|
328 |
|
|
329 ## Are all the packages that should be uninstalled already installed? |
|
|
330 if (length(delete_idx) != length(pkgnames)) |
|
|
331 # XXX: We should have a better error message |
|
|
332 error("Some of the packages you want to uninstall are not installed.\n"); |
|
|
333 endif |
|
|
334 |
|
|
335 ## Compute the packages that will remain installed |
|
|
336 idx = complement(delete_idx, 1:num_packages); |
|
|
337 remaining_packages = {installed_packages{idx}}; |
|
|
338 |
|
|
339 ## Check dependencies |
|
|
340 if (handle_deps) |
|
|
341 ok = true; |
|
|
342 error_text = ""; |
|
|
343 for i = 1:length(remaining_packages) |
|
|
344 desc = remaining_packages{i}; |
|
|
345 bad_deps = get_unsatisfied_deps(desc, remaining_packages); |
|
|
346 |
|
|
347 ## Will the uninstallation break any dependencies? |
|
|
348 if (!isempty(bad_deps)) |
|
|
349 ok = false; |
|
|
350 for i = 1:length(bad_deps) |
|
|
351 dep = bad_deps{i}; |
|
|
352 error_text = [error_text " " desc.name " needs " ... |
|
|
353 dep.package " " dep.operator " " ... |
|
|
354 dep.version "\n"]; |
|
|
355 endfor |
|
|
356 endif |
|
|
357 endfor |
|
|
358 |
|
|
359 if (!ok) |
|
|
360 error("The following dependencies where unsatisfied:\n %s", error_text); |
|
|
361 endif |
|
|
362 endif |
|
|
363 |
|
|
364 ## Delete the directories containing the packages |
|
|
365 for i = delete_idx |
|
|
366 desc = installed_packages{i}; |
|
|
367 ## If an 'on_uninstall.m' exist, call it! |
|
|
368 if (exist([desc.dir "/packinfo/on_uninstall.m"], "file")) |
|
|
369 try |
|
|
370 wd = pwd(); |
|
|
371 cd([desc.dir "/packinfo"]); |
|
|
372 on_uninstall(desc); |
|
|
373 cd(wd); |
|
|
374 catch |
|
|
375 # XXX: Should this rather be an error? |
|
|
376 warning("The 'on_uninstall' script returned the following error: %s", lasterr); |
|
|
377 cd(wd); |
|
|
378 end_try_catch |
|
|
379 endif |
|
|
380 ## Do the actual deletion |
|
5928
|
381 rmpath(desc.dir); |
|
|
382 [status, msg] = rm_rf(desc.dir); |
|
5801
|
383 if (status != 1) |
|
|
384 error("Couldn't delete directory %s: %s\n", desc.dir, msg); |
|
|
385 endif |
|
|
386 endfor |
|
|
387 |
|
|
388 ## Write a new ~/.octave_packages |
|
|
389 if (issuperuser()) |
|
|
390 if (length(remaining_packages) == 0) |
|
|
391 unlink(global_list); |
|
|
392 else |
|
|
393 global_packages = remaining_packages; |
|
|
394 save(global_list, "global_packages"); |
|
|
395 endif |
|
|
396 else |
|
|
397 if (length(remaining_packages) == 0) |
|
|
398 unlink(local_list); |
|
|
399 else |
|
|
400 local_packages = remaining_packages; |
|
|
401 save(local_list, "local_packages"); |
|
|
402 endif |
|
|
403 endif |
|
|
404 |
|
|
405 endfunction |
|
|
406 |
|
|
407 ########################################################## |
|
|
408 ## A U X I L A R Y F U N C T I O N S ## |
|
|
409 ########################################################## |
|
|
410 |
|
|
411 function prepare_installation(desc, packdir) |
|
|
412 ## Is there a pre_install to call? |
|
|
413 if (exist([packdir "pre_install.m"], "file")) |
|
|
414 wd = pwd(); |
|
|
415 try |
|
|
416 cd(packdir); |
|
|
417 pre_install(desc); |
|
|
418 cd(wd); |
|
|
419 catch |
|
|
420 cd(wd); |
|
|
421 error("The pre-install function returned the following error: %s\n", lasterr); |
|
|
422 end_try_catch |
|
|
423 endif |
|
|
424 |
|
|
425 ## Create the installation directory |
|
|
426 [status, msg] = mkdir(desc.dir); |
|
|
427 if (status != 1) |
|
|
428 error("Couldn't create installation directory: %s\n", msg); |
|
|
429 endif |
|
|
430 |
|
|
431 ## If the directory "inst" doesn't exist, we create it |
|
|
432 if (!exist([packdir "inst"], "dir")) |
|
|
433 [status, msg] = mkdir([packdir "inst"]); |
|
|
434 if (status != 1) |
|
5928
|
435 rm_rf(desc.dir); |
|
5801
|
436 error("The 'inst' directory did not exist and could not be created: %s\n", msg); |
|
|
437 endif |
|
|
438 endif |
|
|
439 endfunction |
|
|
440 |
|
|
441 function configure_make (desc, packdir) |
|
|
442 ## Perform ./configure, make, make install in "src" |
|
|
443 if (exist([packdir "src"], "dir")) |
|
|
444 src = [packdir "src/"]; |
|
|
445 ## configure |
|
|
446 if (exist([src "configure"], "file")) |
|
5928
|
447 [status, output] = system(["cd " src " ;./configure --prefix=" desc.dir]); |
|
5801
|
448 if (status != 0) |
|
5928
|
449 rm_rf(desc.dir); |
|
5801
|
450 error("The configure script returned the following error: %s\n", output); |
|
|
451 endif |
|
|
452 endif |
|
|
453 |
|
|
454 ## make |
|
|
455 if (exist([src "Makefile"], "file")) |
|
5928
|
456 [status, output] = system(["export INSTALLDIR=" desc.dir "; make -C " src]); |
|
5801
|
457 if (status != 0) |
|
5928
|
458 rm_rf(desc.dir); |
|
5801
|
459 error("'make' returned the following error: %s\n", output); |
|
|
460 endif |
|
|
461 %# make install |
|
5928
|
462 %[status, output] = system(["export INSTALLDIR=" desc.dir "; make install -C " src]); |
|
5801
|
463 %if (status != 0) |
|
5928
|
464 % rm_rf(desc.dir); |
|
5801
|
465 % error("'make install' returned the following error: %s\n", output); |
|
|
466 %endif |
|
|
467 endif |
|
|
468 |
|
|
469 ## Copy files to "inst" (this is instead of 'make install') |
|
|
470 files = [src "FILES"]; |
|
|
471 if (exist(files, "file")) |
|
|
472 [fid, msg] = fopen(files, "r"); |
|
|
473 if (fid < 0) |
|
|
474 error("Couldn't open %s: %s\n", files, msg); |
|
|
475 endif |
|
5928
|
476 filenames = char(fread(fid))'; |
|
5801
|
477 filenames = strrep(filenames, "\n", " "); |
|
5928
|
478 [status, output] = system(["cd " src "; cp " filenames " " packdir "inst/"]); |
|
5801
|
479 fclose(fid); |
|
|
480 else |
|
|
481 m = dir([src "*.m"]); |
|
|
482 oct = dir([src "*.oct"]); |
|
|
483 f = ""; |
|
|
484 if (length(m) > 0) |
|
5928
|
485 f = sprintf([src "%s "], m.name); |
|
5801
|
486 endif |
|
|
487 if (length(oct) > 0) |
|
5928
|
488 f = [f " " sprintf([src "%s "], oct.name)]; |
|
5801
|
489 endif |
|
5928
|
490 |
|
|
491 if (!all(isspace(f))) |
|
|
492 [status, output] = system(["cp -R " f " " packdir "inst/"]); |
|
|
493 endif |
|
5801
|
494 endif |
|
|
495 if (status != 0) |
|
5928
|
496 rm_rf(desc.dir); |
|
5801
|
497 error("Couldn't copy files from 'src' to 'inst': %s\n", output); |
|
|
498 endif |
|
|
499 endif |
|
|
500 endfunction |
|
|
501 |
|
5955
|
502 function pkgadd = extract_pkgadd (nm, pat) |
|
|
503 fid = fopen (nm, "rt"); |
|
|
504 pkgadd = ""; |
|
|
505 if (fid >= 0) |
|
|
506 while (! feof(fid)) |
|
|
507 ln = fgetl (fid); |
|
|
508 if (ln > 0) |
|
|
509 t = regexp(ln, pat, "tokens","dotexceptnewline"); |
|
|
510 if (!isempty(t)) |
|
|
511 pkgadd = [pkgadd, "\n", t{1}{1}]; |
|
|
512 endif |
|
|
513 endif |
|
|
514 endwhile |
|
|
515 if (!isempty(pkgadd)) |
|
|
516 pkgadd = [pkgadd, "\n"]; |
|
|
517 endif |
|
|
518 fclose (fid); |
|
|
519 endif |
|
|
520 endfunction |
|
|
521 |
|
|
522 function create_pkgadd (desc, packdir) |
|
|
523 pkgadd = [desc.dir "/PKG_ADD"]; |
|
|
524 fid = fopen(pkgadd, "wt"); |
|
|
525 if (fid >= 0) |
|
|
526 ## Search all dot-m files for PKG_ADD commands |
|
|
527 lst = dir ([packdir "inst/*.m"]); |
|
|
528 for i=1:length(lst) |
|
|
529 nm = lst(i).name; |
|
|
530 fwrite (fid, extract_pkgadd (nm, '^[#%][#%]* *PKG_ADD: *(.*)$')); |
|
|
531 endfor |
|
|
532 |
|
|
533 ## Search all C++ source files for PKG_ADD commands |
|
|
534 lst = dir ([packdir "src/*.cc"]); |
|
|
535 for i=1:length(lst) |
|
|
536 nm = lst(i).name; |
|
|
537 fwrite (fid, extract_pkgadd (nm, '^//* *PKG_ADD: *(.*)$')); |
|
|
538 fwrite (fid, extract_pkgadd (nm, '^/\** *PKG_ADD: *(.*) *\*/$')); |
|
|
539 endfor |
|
|
540 |
|
|
541 ## Add developer included PKG_ADD commands |
|
|
542 if (exist([packdir "PKG_ADD"],"file")) |
|
|
543 fid2 = fopen([packdir "PKG_ADD"],"rt"); |
|
|
544 if (fid2 >= 0) |
|
|
545 while (! feof(fid2)) |
|
|
546 ln = fgets (fid2); |
|
|
547 if (ln > 0) |
|
|
548 fwrite(fid, ln); |
|
|
549 endif |
|
|
550 endwhile |
|
|
551 endif |
|
|
552 endif |
|
|
553 fclose(fid); |
|
|
554 endif |
|
|
555 endfunction |
|
|
556 |
|
5928
|
557 function copy_files (desc, packdir) |
|
5801
|
558 ## Copy the files from "inst" to installdir |
|
5928
|
559 [status, output] = system(["cp -R " packdir "inst/* " desc.dir]); |
|
5801
|
560 if (status != 0) |
|
5928
|
561 rm_rf(desc.dir); |
|
5801
|
562 error("Couldn't copy files to the installation directory\n"); |
|
|
563 endif |
|
|
564 |
|
|
565 ## Create the "packinfo" directory |
|
|
566 packinfo = [desc.dir "/packinfo/"]; |
|
|
567 [status, msg] = mkdir (packinfo); |
|
|
568 if (status != 1) |
|
5928
|
569 rm_rf(desc.dir); |
|
5801
|
570 error("Couldn't create packinfo directory: %s\n", msg); |
|
|
571 endif |
|
|
572 |
|
|
573 ## Copy DESCRIPTION |
|
5928
|
574 [status, output] = system(["cp " packdir "DESCRIPTION " packinfo]); |
|
5801
|
575 if (status != 0) |
|
5928
|
576 rm_rf(desc.dir); |
|
5801
|
577 error("Couldn't copy DESCRIPTION: %s\n", output); |
|
|
578 endif |
|
|
579 |
|
|
580 ## Is there an INDEX file to copy or should we generate one? |
|
|
581 if (exist([packdir "INDEX"], "file")) |
|
5928
|
582 [status, output] = system(["cp " packdir "INDEX " packinfo]); |
|
5801
|
583 if (status != 0) |
|
5928
|
584 rm_rf(desc.dir); |
|
5801
|
585 error("Couldn't copy INDEX file: %s\n", output); |
|
|
586 endif |
|
|
587 else |
|
|
588 try |
|
|
589 write_INDEX(desc, [packdir "inst"], [packinfo "INDEX"]); |
|
|
590 catch |
|
5928
|
591 rm_rf(desc.dir); |
|
5801
|
592 error(lasterr); |
|
|
593 end_try_catch |
|
|
594 endif |
|
|
595 |
|
|
596 ## Is there an 'on_uninstall.m' to install? |
|
|
597 if (exist([packdir "on_uninstall.m"], "file")) |
|
5928
|
598 [status, output] = system(["cp " packdir "on_uninstall.m " packinfo]); |
|
5801
|
599 if (status != 0) |
|
5928
|
600 rm_rf(desc.dir); |
|
5801
|
601 error("Couldn't copy on_uninstall.m: %s\n", output); |
|
|
602 endif |
|
|
603 endif |
|
|
604 endfunction |
|
|
605 |
|
|
606 function finish_installation (desc, packdir) |
|
|
607 ## Is there a post-install to call? |
|
|
608 if (exist([packdir "post_install.m"], "file")) |
|
|
609 wd = pwd(); |
|
|
610 try |
|
|
611 cd(packdir); |
|
|
612 post_install(desc); |
|
|
613 cd(wd); |
|
|
614 catch |
|
|
615 cd(wd); |
|
5928
|
616 rm_rf(desc.dir); |
|
5801
|
617 error("The post_install function returned the following error: %s\n", lasterr); |
|
|
618 end_try_catch |
|
|
619 endif |
|
|
620 endfunction |
|
|
621 |
|
|
622 function out = issuperuser() |
|
|
623 out = strcmp(getenv("USER"), "root"); |
|
|
624 endfunction |
|
|
625 |
|
|
626 ## This function makes sure the package contains the |
|
|
627 ## essential files. |
|
|
628 function verify_directory(dir) |
|
|
629 needed_files = {"COPYING", "DESCRIPTION"}; |
|
|
630 for f = needed_files |
|
|
631 if (!exist([dir "/" f{1}], "file")) |
|
|
632 error("Package is missing file: %s", f{1}); |
|
|
633 endif |
|
|
634 endfor |
|
|
635 endfunction |
|
|
636 |
|
|
637 ## This function parses the DESCRIPTION file |
|
|
638 function desc = get_description(filename) |
|
|
639 fid = fopen(filename, "r"); |
|
|
640 if (fid == -1) |
|
|
641 error("The DESCRIPTION file %s could not be read\n", filename); |
|
|
642 endif |
|
|
643 |
|
|
644 desc = struct(); |
|
|
645 |
|
|
646 line = fgetl(fid); |
|
|
647 while (line != -1) |
|
|
648 ## Comments |
|
|
649 if (line(1) == "#") |
|
|
650 # Do nothing |
|
|
651 ## Continuation lines |
|
|
652 elseif (isspace(line(1))) |
|
|
653 if (exist("keyword", "var") && isfield(desc, keyword)) |
|
|
654 desc.(keyword) = [desc.(keyword) " " rstrip(line)]; |
|
|
655 endif |
|
|
656 ## Keyword/value pair |
|
|
657 else |
|
|
658 colon = find(line == ":"); |
|
|
659 if (length(colon) == 0) |
|
|
660 disp("Skipping line."); |
|
|
661 else |
|
|
662 colon = colon(1); |
|
|
663 keyword = tolower(strip(line(1:colon-1))); |
|
|
664 value = strip(line(colon+1:end)); |
|
|
665 if (length(value) == 0) |
|
|
666 fclose(fid); |
|
|
667 error("The keyword %s have empty value\n", desc.keywords{end}); |
|
|
668 endif |
|
|
669 desc.(keyword) = value; |
|
|
670 endif |
|
|
671 endif |
|
|
672 line = fgetl(fid); |
|
|
673 endwhile |
|
|
674 fclose(fid); |
|
|
675 |
|
|
676 ## Make sure all is okay |
|
|
677 needed_fields = {"name", "version", "date", "title", ... |
|
|
678 "author", "maintainer", "description"}; |
|
|
679 for f = needed_fields |
|
|
680 if (!isfield(desc, f{1})) |
|
|
681 error("Description is missing needed field %s\n", f{1}); |
|
|
682 endif |
|
|
683 endfor |
|
|
684 desc.version = fix_version(desc.version); |
|
|
685 if (isfield(desc, "depends")) |
|
|
686 desc.depends = fix_depends(desc.depends); |
|
|
687 else |
|
|
688 desc.depends = ""; |
|
|
689 endif |
|
|
690 desc.name = tolower(desc.name); |
|
|
691 endfunction |
|
|
692 |
|
|
693 ## Makes sure the version string v is a valid x.y.z version string |
|
|
694 ## Examples: "0.1" => "0.1.0", "monkey" => error(...) |
|
|
695 function out = fix_version(v) |
|
|
696 dots = find(v == "."); |
|
|
697 if (length(dots) == 1) |
|
|
698 major = str2num(v(1:dots-1)); |
|
|
699 minor = str2num(v(dots+1:end)); |
|
|
700 if (length(major) != 0 && length(minor) != 0) |
|
|
701 out = sprintf("%d.%d.0", major, minor); |
|
|
702 return |
|
|
703 endif |
|
|
704 elseif (length(dots) == 2) |
|
|
705 major = str2num(v(1:dots(1)-1)); |
|
|
706 minor = str2num(v(dots(1)+1:dots(2)-1)); |
|
|
707 rev = str2num(v(dots(2)+1:end)); |
|
|
708 if (length(major) != 0 && length(minor) != 0 && length(rev) != 0) |
|
|
709 out = sprintf("%d.%d.%d", major, minor, rev); |
|
|
710 return |
|
|
711 endif |
|
|
712 endif |
|
|
713 error("Bad version string: %s\n", v); |
|
|
714 endfunction |
|
|
715 |
|
|
716 ## Makes sure the depends field is of the right format. |
|
|
717 ## This function returns a cell of structures with the following fields: |
|
|
718 ## package, version, operator |
|
|
719 function deps_cell = fix_depends(depends) |
|
|
720 deps = split_by(tolower(depends), ","); |
|
|
721 deps_cell = cell(1, length(deps)); |
|
|
722 |
|
|
723 ## For each dependency |
|
|
724 for i = 1:length(deps) |
|
|
725 dep = deps{i}; |
|
|
726 lpar = find(dep == "("); |
|
|
727 rpar = find(dep == ")"); |
|
|
728 ## Does the dependency specify a version |
|
|
729 ## Example: package(>= version) |
|
|
730 if (length(lpar) == 1 && length(rpar) == 1) |
|
|
731 package = tolower(strip(dep(1:lpar-1))); |
|
|
732 sub = dep( lpar(1)+1:rpar(1)-1 ); |
|
|
733 parts = split_by(sub, " "); |
|
|
734 idx = []; |
|
|
735 for r = 1:size(parts,1) |
|
|
736 if (length(parts{r}) > 0) |
|
|
737 idx(end+1) = r; |
|
|
738 endif |
|
|
739 endfor |
|
|
740 |
|
|
741 if (length(idx) != 2) |
|
|
742 error(["There's something wrong with the DESCRIPTION file. " ... |
|
|
743 "The dependency %s has the wrong syntax.\n"], dep); |
|
|
744 endif |
|
|
745 operator = parts{idx(1)}; |
|
|
746 if (!any(strcmp(operator, {">=", "<=", "=="}))) ## XXX: I belive we also support ">" and "<" |
|
|
747 error("Unsupported operator: %s\n", operator); |
|
|
748 endif |
|
|
749 version = fix_version(parts{idx(2)}); |
|
|
750 |
|
|
751 ## If no version is specified for the dependency |
|
|
752 ## we say that the version should be greater than |
|
|
753 ## or equal to 0.0.0 |
|
|
754 else |
|
|
755 package = tolower(strip(dep)); |
|
|
756 operator = ">="; |
|
|
757 version = "0.0.0"; |
|
|
758 endif |
|
|
759 deps_cell{i} = struct("package", package, "operator", operator, "version", version); |
|
|
760 endfor |
|
|
761 endfunction |
|
|
762 |
|
|
763 ## Strips the text of spaces from the right |
|
|
764 ## Example: " hello world " => " hello world" (XXX: is this the same as deblank?) |
|
|
765 function text = rstrip(text) |
|
|
766 chars = find(!isspace(text)); |
|
|
767 if (length(chars) > 0) |
|
|
768 text = text(chars(1):end); # XXX: shouldn't it be text = text(1:chars(end)); |
|
|
769 else |
|
|
770 text = ""; |
|
|
771 endif |
|
|
772 endfunction |
|
|
773 |
|
|
774 ## Strips the text of spaces from the left and the right |
|
|
775 ## Example: " hello world " => "hello world" |
|
|
776 function text = strip(text) |
|
|
777 chars = find(!isspace(text)); |
|
|
778 if (length(chars) > 0) |
|
|
779 text = text(chars(1):chars(end)); |
|
|
780 else |
|
|
781 text = ""; |
|
|
782 endif |
|
|
783 endfunction |
|
|
784 |
|
|
785 ## Splits the text into a cell array of strings by sep |
|
|
786 ## Example: "A, B" => {"A", "B"} (with sep = ",") |
|
|
787 function out = split_by(text, sep) |
|
|
788 text_matrix = split(text, sep); |
|
|
789 num_words = size(text_matrix,1); |
|
|
790 out = cell(num_words, 1); |
|
|
791 for i = 1:num_words |
|
|
792 out{i} = strip(text_matrix(i, :)); |
|
|
793 endfor |
|
|
794 endfunction |
|
|
795 |
|
|
796 ## Creates an INDEX file for a package that doesn't provide one. |
|
|
797 ## 'desc' describes the package. |
|
|
798 ## 'dir' is the 'inst' direcotyr in temporary directory. |
|
|
799 ## 'INDEX' is the name (including path) of resulting INDEX file. |
|
|
800 function write_INDEX(desc, dir, INDEX) |
|
|
801 ## Get names of functions in dir |
|
|
802 [files, err, msg] = readdir(dir); |
|
|
803 if (err) |
|
|
804 error("Couldn't read directory %s: %s\n", dir, msg); |
|
|
805 endif |
|
|
806 |
|
|
807 functions = {}; |
|
|
808 for i = 1:length(files) |
|
|
809 file = files{i}; |
|
|
810 lf = length(file); |
|
|
811 if (lf > 2 && strcmp( file(end-1:end), ".m" )) |
|
|
812 functions{end+1} = file(1:end-2); |
|
|
813 elseif (lf > 4 && strcmp( file(end-3:end), ".oct" )) |
|
|
814 functions{end+1} = file(1:end-4); |
|
|
815 endif |
|
|
816 endfor |
|
|
817 |
|
|
818 ## Does desc have a categories field? |
|
|
819 if (!isfield(desc, "categories")) |
|
|
820 error("The DESCRIPTION file must have a Categories field, when no INDEX file is given.\n"); |
|
|
821 endif |
|
|
822 categories = split_by(desc.categories, ","); |
|
|
823 if (length(categories) < 1) |
|
|
824 error("The Category field is empty.\n"); |
|
|
825 endif |
|
|
826 |
|
|
827 ## Write INDEX |
|
|
828 fid = fopen(INDEX, "w"); |
|
|
829 if (fid == -1) |
|
|
830 error("Couldn't open %s for writing.\n", INDEX); |
|
|
831 endif |
|
|
832 fprintf(fid, "%s >> %s\n", desc.name, desc.title); |
|
|
833 fprintf(fid, "%s\n", categories{1}); |
|
|
834 fprintf(fid, " %s\n", functions{:}); |
|
|
835 fclose(fid); |
|
|
836 endfunction |
|
|
837 |
|
|
838 function bad_deps = get_unsatisfied_deps(desc, installed_packages) |
|
|
839 bad_deps = {}; |
|
|
840 |
|
|
841 ## For each dependency |
|
|
842 for i = 1:length(desc.depends) |
|
|
843 dep = desc.depends{i}; |
|
|
844 |
|
|
845 ## Is the current dependency Octave? |
|
|
846 if (strcmp(dep.package, "octave")) |
|
|
847 if (!compare_versions(OCTAVE_VERSION, dep.version, dep.operator)) |
|
|
848 bad_deps{end+1} = dep; |
|
|
849 endif |
|
|
850 ## Is the current dependency not Octave? |
|
|
851 else |
|
|
852 ok = false; |
|
|
853 for i = 1:length(installed_packages) |
|
|
854 cur_name = installed_packages{i}.name; |
|
|
855 cur_version = installed_packages{i}.version; |
|
|
856 if (strcmp(dep.package, cur_name) && compare_versions(cur_version, dep.version, dep.operator)) |
|
|
857 ok = true; |
|
|
858 break; |
|
|
859 endif |
|
|
860 endfor |
|
|
861 if (!ok) |
|
|
862 bad_deps{end+1} = dep; |
|
|
863 endif |
|
|
864 endif |
|
|
865 endfor |
|
|
866 endfunction |
|
|
867 |
|
|
868 ## Compares to version string using the given operator |
|
|
869 ## Example: v1="0.1.0", v2="0.0.9", operator=">=" => true |
|
|
870 ## TODO: This function is very long and complex! Can't it be simplified? |
|
|
871 function out = compare_versions(v1, v2, operator) |
|
|
872 dot1 = find(v1 == "."); |
|
|
873 dot2 = find(v2 == "."); |
|
|
874 if (length(dot1) != 2 || length(dot2) != 2) |
|
|
875 error("Given version strings are not valid: %s %s", v1, v2); |
|
|
876 endif |
|
|
877 |
|
|
878 major1 = str2num( v1( 1:dot1(1)-1 ) ); |
|
|
879 minor1 = str2num( v1( dot1(1)+1:dot1(2)-1 ) ); |
|
|
880 rev1 = str2num( v1( dot1(2)+1:end ) ); |
|
|
881 major2 = str2num( v2( 1:dot2(1)-1 ) ); |
|
|
882 minor2 = str2num( v2( dot2(1)+1:dot2(2)-1 ) ); |
|
|
883 rev2 = str2num( v2( dot2(2)+1:end) ); |
|
|
884 mmr = [sign(major1-major2), sign(minor1-minor2), sign(rev1-rev2)]; |
|
|
885 |
|
|
886 if (length(operator) > 1 && operator(2) == "=" && !any(mmr)) |
|
|
887 out = 1; |
|
|
888 return; |
|
|
889 elseif (operator(1) == "<") |
|
|
890 mmr = -mmr; |
|
|
891 endif |
|
|
892 |
|
|
893 ## Now we ony need to decide if v1 > v2 |
|
|
894 if (mmr(1) == 1) |
|
|
895 out = 1; |
|
|
896 elseif (mmr(1) == -1) |
|
|
897 out = 0; |
|
|
898 elseif (mmr(2) == 1) |
|
|
899 out = 1; |
|
|
900 elseif (mmr(2) == -1) |
|
|
901 out = 0; |
|
|
902 elseif (mmr(3) == 1) |
|
|
903 out = 1; |
|
|
904 else |
|
|
905 out = 0; |
|
|
906 endif |
|
|
907 endfunction |
|
|
908 |
|
|
909 function [out1, out2] = installed_packages() |
|
|
910 local_list = tilde_expand("~/.octave_packages"); |
|
|
911 global_list = [OCTAVE_HOME "share/octave/octave_packages"]; |
|
|
912 ## Get the list of installed packages |
|
|
913 try |
|
|
914 local_packages = load(local_list).local_packages; |
|
|
915 catch |
|
|
916 local_packages = {}; |
|
|
917 end_try_catch |
|
|
918 try |
|
|
919 global_packages = load(global_list).global_packages; |
|
|
920 catch |
|
|
921 global_packages = {}; |
|
|
922 end_try_catch |
|
|
923 installed_packages = {local_packages{:} global_packages{:}}; |
|
|
924 |
|
|
925 ## Should we return something? |
|
|
926 if (nargout == 2) |
|
|
927 out1 = local_packages; |
|
|
928 out2 = global_packages; |
|
|
929 return; |
|
|
930 elseif (nargout == 1) |
|
|
931 out1 = installed_packages; |
|
|
932 return; |
|
|
933 endif |
|
|
934 |
|
|
935 ## We shouldn't return something, so we'll print something |
|
|
936 num_packages = length(installed_packages); |
|
|
937 if (num_packages == 0) |
|
|
938 printf("No packages installed.\n"); |
|
|
939 return; |
|
|
940 endif |
|
|
941 |
|
|
942 ## Print a header |
|
|
943 h1 = "Package Name"; |
|
|
944 h2 = "Version"; |
|
|
945 h3 = "Installation directory"; |
|
|
946 header = sprintf("%s | %s | %s\n", h1, h2, h3); |
|
|
947 printf(header); |
|
|
948 tmp = sprintf(repmat("-", 1, length(header)-1)); |
|
|
949 tmp(length(h1)+2) = "+"; tmp(length(h1)+length(h2)+5) = "+"; |
|
|
950 printf("%s\n", tmp); |
|
|
951 |
|
|
952 ## Compute the maximal lengths of name, version, and dir |
|
|
953 max_name_length = length(h1); |
|
|
954 max_version_length = length(h2); |
|
|
955 for i = 1:num_packages |
|
|
956 max_name_length = max(max_name_length, |
|
|
957 length(installed_packages{i}.name)); |
|
|
958 max_version_length = max(max_version_length, |
|
|
959 length(installed_packages{i}.version)); |
|
|
960 endfor |
|
|
961 |
|
|
962 ## Print the packages |
|
|
963 format = sprintf("%%%ds | %%%ds | %%s\n", max_name_length, max_version_length); |
|
|
964 for i = 1:num_packages |
|
|
965 cur_name = installed_packages{i}.name; |
|
|
966 cur_version = installed_packages{i}.version; |
|
|
967 cur_dir = installed_packages{i}.dir; |
|
|
968 printf(format, cur_name, cur_version, cur_dir); |
|
|
969 endfor |
|
|
970 endfunction |
|
|
971 |
|
|
972 function load_packages(files, handle_deps) |
|
|
973 installed_packages = installed_packages(); |
|
|
974 num_packages = length(installed_packages); |
|
|
975 |
|
|
976 if (length(files) == 1 && strcmp(files{1}, "all")) |
|
|
977 dirs = cell(1, num_packages); |
|
|
978 for i = 1:num_packages |
|
|
979 dirs{i} = installed_packages{i}.dir; |
|
|
980 endfor |
|
|
981 elseif (handle_deps) |
|
|
982 # XXX: implement this |
|
|
983 error("Currently you need to call load_packages with 'all' or '-nodeps'. This is a bug!\n"); |
|
|
984 else |
|
|
985 dirs = cell(1, length(files)); |
|
|
986 for j = 1:length(files) |
|
|
987 for i = 1:num_packages |
|
|
988 if (strcmp(installed_packages{i}.name, files{j})) |
|
|
989 dirs{j} = installed_packages{i}.dir; |
|
|
990 endif |
|
|
991 endfor |
|
|
992 error("Package %s is not installed\n", files{j}); |
|
|
993 endfor |
|
|
994 endif |
|
5928
|
995 addpath(dirs{:}); |
|
5801
|
996 endfunction |
|
5928
|
997 |
|
|
998 function [status_out, msg_out] = rm_rf (dir) |
|
|
999 crr = confirm_recursive_rmdir (); |
|
|
1000 unwind_protect |
|
|
1001 confirm_recursive_rmdir (false); |
|
|
1002 [status, msg] = rmdir (dir, "s"); |
|
|
1003 unwind_protect_cleanup |
|
|
1004 confirm_recursive_rmdir (crr); |
|
|
1005 end_unwind_protect |
|
|
1006 if (nargout > 0) |
|
|
1007 status_out = status; |
|
|
1008 endif |
|
|
1009 if (nargout > 1) |
|
|
1010 msg_out = msg; |
|
|
1011 endif |
|
|
1012 endfunction |
