~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/sphinx-pre-install

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /scripts/sphinx-pre-install (Version linux-6.12-rc7) and /scripts/sphinx-pre-install (Version linux-6.4.16)


  1 #!/usr/bin/env perl                                 1 #!/usr/bin/env perl
  2 # SPDX-License-Identifier: GPL-2.0-or-later         2 # SPDX-License-Identifier: GPL-2.0-or-later
  3 use strict;                                         3 use strict;
  4                                                     4 
  5 # Copyright (c) 2017-2020 Mauro Carvalho Cheha<      5 # Copyright (c) 2017-2020 Mauro Carvalho Chehab <mchehab@kernel.org>
  6 #                                                   6 #
  7                                                     7 
  8 my $prefix = "./";                                  8 my $prefix = "./";
  9 $prefix = "$ENV{'srctree'}/" if ($ENV{'srctree      9 $prefix = "$ENV{'srctree'}/" if ($ENV{'srctree'});
 10                                                    10 
 11 my $conf = $prefix . "Documentation/conf.py";      11 my $conf = $prefix . "Documentation/conf.py";
 12 my $requirement_file = $prefix . "Documentatio     12 my $requirement_file = $prefix . "Documentation/sphinx/requirements.txt";
 13 my $virtenv_prefix = "sphinx_";                    13 my $virtenv_prefix = "sphinx_";
 14                                                    14 
 15 #                                                  15 #
 16 # Static vars                                      16 # Static vars
 17 #                                                  17 #
 18                                                    18 
 19 my %missing;                                       19 my %missing;
 20 my $system_release;                                20 my $system_release;
 21 my $need = 0;                                      21 my $need = 0;
 22 my $optional = 0;                                  22 my $optional = 0;
 23 my $need_symlink = 0;                              23 my $need_symlink = 0;
 24 my $need_sphinx = 0;                               24 my $need_sphinx = 0;
 25 my $need_pip = 0;                                  25 my $need_pip = 0;
 26 my $need_virtualenv = 0;                           26 my $need_virtualenv = 0;
 27 my $rec_sphinx_upgrade = 0;                        27 my $rec_sphinx_upgrade = 0;
 28 my $verbose_warn_install = 1;                      28 my $verbose_warn_install = 1;
 29 my $install = "";                                  29 my $install = "";
 30 my $virtenv_dir = "";                              30 my $virtenv_dir = "";
 31 my $python_cmd = "";                               31 my $python_cmd = "";
 32 my $activate_cmd;                                  32 my $activate_cmd;
 33 my $min_version;                                   33 my $min_version;
 34 my $cur_version;                                   34 my $cur_version;
 35 my $rec_version = "3.4.3";                     !!  35 my $rec_version = "1.7.9";      # PDF won't build here
                                                   >>  36 my $min_pdf_version = "2.4.4";  # Min version where pdf builds
 36 my $latest_avail_ver;                              37 my $latest_avail_ver;
 37                                                    38 
 38 #                                                  39 #
 39 # Command line arguments                           40 # Command line arguments
 40 #                                                  41 #
 41                                                    42 
 42 my $pdf = 1;                                       43 my $pdf = 1;
 43 my $virtualenv = 1;                                44 my $virtualenv = 1;
 44 my $version_check = 0;                             45 my $version_check = 0;
 45                                                    46 
 46 #                                                  47 #
 47 # List of required texlive packages on Fedora      48 # List of required texlive packages on Fedora and OpenSuse
 48 #                                                  49 #
 49                                                    50 
 50 my %texlive = (                                    51 my %texlive = (
 51         'amsfonts.sty'       => 'texlive-amsfo     52         'amsfonts.sty'       => 'texlive-amsfonts',
 52         'amsmath.sty'        => 'texlive-amsma     53         'amsmath.sty'        => 'texlive-amsmath',
 53         'amssymb.sty'        => 'texlive-amsfo     54         'amssymb.sty'        => 'texlive-amsfonts',
 54         'amsthm.sty'         => 'texlive-amscl     55         'amsthm.sty'         => 'texlive-amscls',
 55         'anyfontsize.sty'    => 'texlive-anyfo     56         'anyfontsize.sty'    => 'texlive-anyfontsize',
 56         'atbegshi.sty'       => 'texlive-oberd     57         'atbegshi.sty'       => 'texlive-oberdiek',
 57         'bm.sty'             => 'texlive-tools     58         'bm.sty'             => 'texlive-tools',
 58         'capt-of.sty'        => 'texlive-capt-     59         'capt-of.sty'        => 'texlive-capt-of',
 59         'cmap.sty'           => 'texlive-cmap'     60         'cmap.sty'           => 'texlive-cmap',
 60         'ecrm1000.tfm'       => 'texlive-ec',      61         'ecrm1000.tfm'       => 'texlive-ec',
 61         'eqparbox.sty'       => 'texlive-eqpar     62         'eqparbox.sty'       => 'texlive-eqparbox',
 62         'eu1enc.def'         => 'texlive-euenc     63         'eu1enc.def'         => 'texlive-euenc',
 63         'fancybox.sty'       => 'texlive-fancy     64         'fancybox.sty'       => 'texlive-fancybox',
 64         'fancyvrb.sty'       => 'texlive-fancy     65         'fancyvrb.sty'       => 'texlive-fancyvrb',
 65         'float.sty'          => 'texlive-float     66         'float.sty'          => 'texlive-float',
 66         'fncychap.sty'       => 'texlive-fncyc     67         'fncychap.sty'       => 'texlive-fncychap',
 67         'footnote.sty'       => 'texlive-mdwto     68         'footnote.sty'       => 'texlive-mdwtools',
 68         'framed.sty'         => 'texlive-frame     69         'framed.sty'         => 'texlive-framed',
 69         'luatex85.sty'       => 'texlive-luate     70         'luatex85.sty'       => 'texlive-luatex85',
 70         'multirow.sty'       => 'texlive-multi     71         'multirow.sty'       => 'texlive-multirow',
 71         'needspace.sty'      => 'texlive-needs     72         'needspace.sty'      => 'texlive-needspace',
 72         'palatino.sty'       => 'texlive-psnfs     73         'palatino.sty'       => 'texlive-psnfss',
 73         'parskip.sty'        => 'texlive-parsk     74         'parskip.sty'        => 'texlive-parskip',
 74         'polyglossia.sty'    => 'texlive-polyg     75         'polyglossia.sty'    => 'texlive-polyglossia',
 75         'tabulary.sty'       => 'texlive-tabul     76         'tabulary.sty'       => 'texlive-tabulary',
 76         'threeparttable.sty' => 'texlive-three     77         'threeparttable.sty' => 'texlive-threeparttable',
 77         'titlesec.sty'       => 'texlive-title     78         'titlesec.sty'       => 'texlive-titlesec',
 78         'ucs.sty'            => 'texlive-ucs',     79         'ucs.sty'            => 'texlive-ucs',
 79         'upquote.sty'        => 'texlive-upquo     80         'upquote.sty'        => 'texlive-upquote',
 80         'wrapfig.sty'        => 'texlive-wrapf     81         'wrapfig.sty'        => 'texlive-wrapfig',
 81         'ctexhook.sty'       => 'texlive-ctex'     82         'ctexhook.sty'       => 'texlive-ctex',
 82 );                                                 83 );
 83                                                    84 
 84 #                                                  85 #
 85 # Subroutines that checks if a feature exists      86 # Subroutines that checks if a feature exists
 86 #                                                  87 #
 87                                                    88 
 88 sub check_missing(%)                               89 sub check_missing(%)
 89 {                                                  90 {
 90         my %map = %{$_[0]};                        91         my %map = %{$_[0]};
 91                                                    92 
 92         foreach my $prog (sort keys %missing)      93         foreach my $prog (sort keys %missing) {
 93                 my $is_optional = $missing{$pr     94                 my $is_optional = $missing{$prog};
 94                                                    95 
 95                 # At least on some LTS distros     96                 # At least on some LTS distros like CentOS 7, texlive doesn't
 96                 # provide all packages we need     97                 # provide all packages we need. When such distros are
 97                 # detected, we have to disable     98                 # detected, we have to disable PDF output.
 98                 #                                  99                 #
 99                 # So, we need to ignore the pa    100                 # So, we need to ignore the packages that distros would
100                 # need for LaTeX to work          101                 # need for LaTeX to work
101                 if ($is_optional == 2 && !$pdf    102                 if ($is_optional == 2 && !$pdf) {
102                         $optional--;              103                         $optional--;
103                         next;                     104                         next;
104                 }                                 105                 }
105                                                   106 
106                 if ($verbose_warn_install) {      107                 if ($verbose_warn_install) {
107                         if ($is_optional) {       108                         if ($is_optional) {
108                                 print "Warning    109                                 print "Warning: better to also install \"$prog\".\n";
109                         } else {                  110                         } else {
110                                 print "ERROR:     111                                 print "ERROR: please install \"$prog\", otherwise, build won't work.\n";
111                         }                         112                         }
112                 }                                 113                 }
113                 if (defined($map{$prog})) {       114                 if (defined($map{$prog})) {
114                         $install .= " " . $map    115                         $install .= " " . $map{$prog};
115                 } else {                          116                 } else {
116                         $install .= " " . $pro    117                         $install .= " " . $prog;
117                 }                                 118                 }
118         }                                         119         }
119                                                   120 
120         $install =~ s/^\s//;                      121         $install =~ s/^\s//;
121 }                                                 122 }
122                                                   123 
123 sub add_package($$)                               124 sub add_package($$)
124 {                                                 125 {
125         my $package = shift;                      126         my $package = shift;
126         my $is_optional = shift;                  127         my $is_optional = shift;
127                                                   128 
128         $missing{$package} = $is_optional;        129         $missing{$package} = $is_optional;
129         if ($is_optional) {                       130         if ($is_optional) {
130                 $optional++;                      131                 $optional++;
131         } else {                                  132         } else {
132                 $need++;                          133                 $need++;
133         }                                         134         }
134 }                                                 135 }
135                                                   136 
136 sub check_missing_file($$$)                       137 sub check_missing_file($$$)
137 {                                                 138 {
138         my $files = shift;                        139         my $files = shift;
139         my $package = shift;                      140         my $package = shift;
140         my $is_optional = shift;                  141         my $is_optional = shift;
141                                                   142 
142         for (@$files) {                           143         for (@$files) {
143                 return if(-e $_);                 144                 return if(-e $_);
144         }                                         145         }
145                                                   146 
146         add_package($package, $is_optional);      147         add_package($package, $is_optional);
147 }                                                 148 }
148                                                   149 
149 sub findprog($)                                   150 sub findprog($)
150 {                                                 151 {
151         foreach(split(/:/, $ENV{PATH})) {         152         foreach(split(/:/, $ENV{PATH})) {
152                 return "$_/$_[0]" if(-x "$_/$_    153                 return "$_/$_[0]" if(-x "$_/$_[0]");
153         }                                         154         }
154 }                                                 155 }
155                                                   156 
156 sub find_python_no_venv()                         157 sub find_python_no_venv()
157 {                                                 158 {
158         my $prog = shift;                         159         my $prog = shift;
159                                                   160 
160         my $cur_dir = qx(pwd);                    161         my $cur_dir = qx(pwd);
161         $cur_dir =~ s/\s+$//;                     162         $cur_dir =~ s/\s+$//;
162                                                   163 
163         foreach my $dir (split(/:/, $ENV{PATH}    164         foreach my $dir (split(/:/, $ENV{PATH})) {
164                 next if ($dir =~ m,($cur_dir)/    165                 next if ($dir =~ m,($cur_dir)/sphinx,);
165                 return "$dir/python3" if(-x "$    166                 return "$dir/python3" if(-x "$dir/python3");
166         }                                         167         }
167         foreach my $dir (split(/:/, $ENV{PATH}    168         foreach my $dir (split(/:/, $ENV{PATH})) {
168                 next if ($dir =~ m,($cur_dir)/    169                 next if ($dir =~ m,($cur_dir)/sphinx,);
169                 return "$dir/python" if(-x "$d    170                 return "$dir/python" if(-x "$dir/python");
170         }                                         171         }
171         return "python";                          172         return "python";
172 }                                                 173 }
173                                                   174 
174 sub check_program($$)                             175 sub check_program($$)
175 {                                                 176 {
176         my $prog = shift;                         177         my $prog = shift;
177         my $is_optional = shift;                  178         my $is_optional = shift;
178                                                   179 
179         return $prog if findprog($prog);          180         return $prog if findprog($prog);
180                                                   181 
181         add_package($prog, $is_optional);         182         add_package($prog, $is_optional);
182 }                                                 183 }
183                                                   184 
184 sub check_perl_module($$)                         185 sub check_perl_module($$)
185 {                                                 186 {
186         my $prog = shift;                         187         my $prog = shift;
187         my $is_optional = shift;                  188         my $is_optional = shift;
188                                                   189 
189         my $err = system("perl -M$prog -e 1 2>    190         my $err = system("perl -M$prog -e 1 2>/dev/null /dev/null");
190         return if ($err == 0);                    191         return if ($err == 0);
191                                                   192 
192         add_package($prog, $is_optional);         193         add_package($prog, $is_optional);
193 }                                                 194 }
194                                                   195 
195 sub check_python_module($$)                       196 sub check_python_module($$)
196 {                                                 197 {
197         my $prog = shift;                         198         my $prog = shift;
198         my $is_optional = shift;                  199         my $is_optional = shift;
199                                                   200 
200         return if (!$python_cmd);                 201         return if (!$python_cmd);
201                                                   202 
202         my $err = system("$python_cmd -c 'impo    203         my $err = system("$python_cmd -c 'import $prog' 2>/dev/null /dev/null");
203         return if ($err == 0);                    204         return if ($err == 0);
204                                                   205 
205         add_package($prog, $is_optional);         206         add_package($prog, $is_optional);
206 }                                                 207 }
207                                                   208 
208 sub check_rpm_missing($$)                         209 sub check_rpm_missing($$)
209 {                                                 210 {
210         my @pkgs = @{$_[0]};                      211         my @pkgs = @{$_[0]};
211         my $is_optional = $_[1];                  212         my $is_optional = $_[1];
212                                                   213 
213         foreach my $prog(@pkgs) {                 214         foreach my $prog(@pkgs) {
214                 my $err = system("rpm -q '$pro    215                 my $err = system("rpm -q '$prog' 2>/dev/null >/dev/null");
215                 add_package($prog, $is_optiona    216                 add_package($prog, $is_optional) if ($err);
216         }                                         217         }
217 }                                                 218 }
218                                                   219 
219 sub check_pacman_missing($$)                      220 sub check_pacman_missing($$)
220 {                                                 221 {
221         my @pkgs = @{$_[0]};                      222         my @pkgs = @{$_[0]};
222         my $is_optional = $_[1];                  223         my $is_optional = $_[1];
223                                                   224 
224         foreach my $prog(@pkgs) {                 225         foreach my $prog(@pkgs) {
225                 my $err = system("pacman -Q '$    226                 my $err = system("pacman -Q '$prog' 2>/dev/null >/dev/null");
226                 add_package($prog, $is_optiona    227                 add_package($prog, $is_optional) if ($err);
227         }                                         228         }
228 }                                                 229 }
229                                                   230 
230 sub check_missing_tex($)                          231 sub check_missing_tex($)
231 {                                                 232 {
232         my $is_optional = shift;                  233         my $is_optional = shift;
233         my $kpsewhich = findprog("kpsewhich");    234         my $kpsewhich = findprog("kpsewhich");
234                                                   235 
235         foreach my $prog(keys %texlive) {         236         foreach my $prog(keys %texlive) {
236                 my $package = $texlive{$prog};    237                 my $package = $texlive{$prog};
237                 if (!$kpsewhich) {                238                 if (!$kpsewhich) {
238                         add_package($package,     239                         add_package($package, $is_optional);
239                         next;                     240                         next;
240                 }                                 241                 }
241                 my $file = qx($kpsewhich $prog    242                 my $file = qx($kpsewhich $prog);
242                 add_package($package, $is_opti    243                 add_package($package, $is_optional) if ($file =~ /^\s*$/);
243         }                                         244         }
244 }                                                 245 }
245                                                   246 
246 sub get_sphinx_fname()                            247 sub get_sphinx_fname()
247 {                                                 248 {
248         my $fname = "sphinx-build";               249         my $fname = "sphinx-build";
249         return $fname if findprog($fname);        250         return $fname if findprog($fname);
250                                                   251 
251         $fname = "sphinx-build-3";                252         $fname = "sphinx-build-3";
252         if (findprog($fname)) {                   253         if (findprog($fname)) {
253                 $need_symlink = 1;                254                 $need_symlink = 1;
254                 return $fname;                    255                 return $fname;
255         }                                         256         }
256                                                   257 
257         return "";                                258         return "";
258 }                                                 259 }
259                                                   260 
260 sub get_sphinx_version($)                         261 sub get_sphinx_version($)
261 {                                                 262 {
262         my $cmd = shift;                          263         my $cmd = shift;
263         my $ver;                                  264         my $ver;
264                                                   265 
265         open IN, "$cmd --version 2>&1 |";         266         open IN, "$cmd --version 2>&1 |";
266         while (<IN>) {                            267         while (<IN>) {
267                 if (m/^\s*sphinx-build\s+([\d\    268                 if (m/^\s*sphinx-build\s+([\d\.]+)((\+\/[\da-f]+)|(b\d+))?$/) {
268                         $ver=$1;                  269                         $ver=$1;
269                         last;                     270                         last;
270                 }                                 271                 }
271                 # Sphinx 1.2.x uses a differen    272                 # Sphinx 1.2.x uses a different format
272                 if (m/^\s*Sphinx.*\s+([\d\.]+)    273                 if (m/^\s*Sphinx.*\s+([\d\.]+)$/) {
273                         $ver=$1;                  274                         $ver=$1;
274                         last;                     275                         last;
275                 }                                 276                 }
276         }                                         277         }
277         close IN;                                 278         close IN;
278         return $ver;                              279         return $ver;
279 }                                                 280 }
280                                                   281 
281 sub check_sphinx()                                282 sub check_sphinx()
282 {                                                 283 {
                                                   >> 284         my $default_version;
                                                   >> 285 
283         open IN, $conf or die "Can't open $con    286         open IN, $conf or die "Can't open $conf";
284         while (<IN>) {                            287         while (<IN>) {
285                 if (m/^\s*needs_sphinx\s*=\s*[    288                 if (m/^\s*needs_sphinx\s*=\s*[\'\"]([\d\.]+)[\'\"]/) {
286                         $min_version=$1;          289                         $min_version=$1;
287                         last;                     290                         last;
288                 }                                 291                 }
289         }                                         292         }
290         close IN;                                 293         close IN;
291                                                   294 
292         die "Can't get needs_sphinx version fr    295         die "Can't get needs_sphinx version from $conf" if (!$min_version);
293                                                   296 
294         $virtenv_dir = $virtenv_prefix . "late !! 297         open IN, $requirement_file or die "Can't open $requirement_file";
                                                   >> 298         while (<IN>) {
                                                   >> 299                 if (m/^\s*Sphinx\s*==\s*([\d\.]+)$/) {
                                                   >> 300                         $default_version=$1;
                                                   >> 301                         last;
                                                   >> 302                 }
                                                   >> 303         }
                                                   >> 304         close IN;
                                                   >> 305 
                                                   >> 306         die "Can't get default sphinx version from $requirement_file" if (!$default_version);
                                                   >> 307 
                                                   >> 308         $virtenv_dir = $virtenv_prefix . $default_version;
295                                                   309 
296         my $sphinx = get_sphinx_fname();          310         my $sphinx = get_sphinx_fname();
297         if ($sphinx eq "") {                      311         if ($sphinx eq "") {
298                 $need_sphinx = 1;                 312                 $need_sphinx = 1;
299                 return;                           313                 return;
300         }                                         314         }
301                                                   315 
302         $cur_version = get_sphinx_version($sph    316         $cur_version = get_sphinx_version($sphinx);
                                                   >> 317         die ("$sphinx returned an error") if (!$cur_version);
                                                   >> 318 
303         die "$sphinx didn't return its version    319         die "$sphinx didn't return its version" if (!$cur_version);
304                                                   320 
305         if ($cur_version lt $min_version) {       321         if ($cur_version lt $min_version) {
306                 printf "ERROR: Sphinx version  !! 322                 printf "ERROR: Sphinx version is %s. It should be >= %s (recommended >= %s)\n",
307                        $cur_version, $min_vers !! 323                        $cur_version, $min_version, $default_version;
308                 $need_sphinx = 1;                 324                 $need_sphinx = 1;
309                 return;                           325                 return;
310         }                                         326         }
311                                                   327 
312         return if ($cur_version lt $rec_versio    328         return if ($cur_version lt $rec_version);
313                                                   329 
314         # On version check mode, just assume S    330         # On version check mode, just assume Sphinx has all mandatory deps
315         exit (0) if ($version_check);             331         exit (0) if ($version_check);
316 }                                                 332 }
317                                                   333 
318 #                                                 334 #
319 # Ancillary subroutines                           335 # Ancillary subroutines
320 #                                                 336 #
321                                                   337 
322 sub catcheck($)                                   338 sub catcheck($)
323 {                                                 339 {
324   my $res = "";                                   340   my $res = "";
325   $res = qx(cat $_[0]) if (-r $_[0]);             341   $res = qx(cat $_[0]) if (-r $_[0]);
326   return $res;                                    342   return $res;
327 }                                                 343 }
328                                                   344 
329 sub which($)                                      345 sub which($)
330 {                                                 346 {
331         my $file = shift;                         347         my $file = shift;
332         my @path = split ":", $ENV{PATH};         348         my @path = split ":", $ENV{PATH};
333                                                   349 
334         foreach my $dir(@path) {                  350         foreach my $dir(@path) {
335                 my $name = $dir.'/'.$file;        351                 my $name = $dir.'/'.$file;
336                 return $name if (-x $name );      352                 return $name if (-x $name );
337         }                                         353         }
338         return undef;                             354         return undef;
339 }                                                 355 }
340                                                   356 
341 #                                                 357 #
342 # Subroutines that check distro-specific hints    358 # Subroutines that check distro-specific hints
343 #                                                 359 #
344                                                   360 
345 sub give_debian_hints()                           361 sub give_debian_hints()
346 {                                                 362 {
347         my %map = (                               363         my %map = (
348                 "python-sphinx"         => "py    364                 "python-sphinx"         => "python3-sphinx",
349                 "yaml"                  => "py << 
350                 "ensurepip"             => "py    365                 "ensurepip"             => "python3-venv",
351                 "virtualenv"            => "vi    366                 "virtualenv"            => "virtualenv",
352                 "dot"                   => "gr    367                 "dot"                   => "graphviz",
353                 "convert"               => "im    368                 "convert"               => "imagemagick",
354                 "Pod::Usage"            => "pe    369                 "Pod::Usage"            => "perl-modules",
355                 "xelatex"               => "te    370                 "xelatex"               => "texlive-xetex",
356                 "rsvg-convert"          => "li    371                 "rsvg-convert"          => "librsvg2-bin",
357         );                                        372         );
358                                                   373 
359         if ($pdf) {                               374         if ($pdf) {
360                 check_missing_file(["/usr/shar    375                 check_missing_file(["/usr/share/texlive/texmf-dist/tex/latex/ctex/ctexhook.sty"],
361                                    "texlive-la    376                                    "texlive-lang-chinese", 2);
362                                                   377 
363                 check_missing_file(["/usr/shar    378                 check_missing_file(["/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"],
364                                    "fonts-deja    379                                    "fonts-dejavu", 2);
365                                                   380 
366                 check_missing_file(["/usr/shar    381                 check_missing_file(["/usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc",
367                                     "/usr/shar    382                                     "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
368                                     "/usr/shar    383                                     "/usr/share/fonts/opentype/noto/NotoSerifCJK-Regular.ttc"],
369                                    "fonts-noto    384                                    "fonts-noto-cjk", 2);
370         }                                         385         }
371                                                   386 
372         check_program("dvipng", 2) if ($pdf);     387         check_program("dvipng", 2) if ($pdf);
373         check_missing(\%map);                     388         check_missing(\%map);
374                                                   389 
375         return if (!$need && !$optional);         390         return if (!$need && !$optional);
376         printf("You should run:\n") if ($verbo    391         printf("You should run:\n") if ($verbose_warn_install);
377         printf("\n\tsudo apt-get install $inst    392         printf("\n\tsudo apt-get install $install\n");
378 }                                                 393 }
379                                                   394 
380 sub give_redhat_hints()                           395 sub give_redhat_hints()
381 {                                                 396 {
382         my %map = (                               397         my %map = (
383                 "python-sphinx"         => "py    398                 "python-sphinx"         => "python3-sphinx",
384                 "yaml"                  => "py << 
385                 "virtualenv"            => "py    399                 "virtualenv"            => "python3-virtualenv",
386                 "dot"                   => "gr    400                 "dot"                   => "graphviz",
387                 "convert"               => "Im    401                 "convert"               => "ImageMagick",
388                 "Pod::Usage"            => "pe    402                 "Pod::Usage"            => "perl-Pod-Usage",
389                 "xelatex"               => "te    403                 "xelatex"               => "texlive-xetex-bin",
390                 "rsvg-convert"          => "li    404                 "rsvg-convert"          => "librsvg2-tools",
391         );                                        405         );
392                                                   406 
393         my @fedora26_opt_pkgs = (                 407         my @fedora26_opt_pkgs = (
394                 "graphviz-gd",          # Fedo    408                 "graphviz-gd",          # Fedora 26: needed for PDF support
395         );                                        409         );
396                                                   410 
397         my @fedora_tex_pkgs = (                   411         my @fedora_tex_pkgs = (
398                 "texlive-collection-fontsrecom    412                 "texlive-collection-fontsrecommended",
399                 "texlive-collection-latex",       413                 "texlive-collection-latex",
400                 "texlive-xecjk",                  414                 "texlive-xecjk",
401                 "dejavu-sans-fonts",              415                 "dejavu-sans-fonts",
402                 "dejavu-serif-fonts",             416                 "dejavu-serif-fonts",
403                 "dejavu-sans-mono-fonts",         417                 "dejavu-sans-mono-fonts",
404         );                                        418         );
405                                                   419 
406         #                                         420         #
407         # Checks valid for RHEL/CentOS version    421         # Checks valid for RHEL/CentOS version 7.x.
408         #                                         422         #
409         my $old = 0;                              423         my $old = 0;
410         my $rel;                                  424         my $rel;
411         my $noto_sans_redhat = "google-noto-sa << 
412         $rel = $1 if ($system_release =~ /rele    425         $rel = $1 if ($system_release =~ /release\s+(\d+)/);
413                                                   426 
414         if (!($system_release =~ /Fedora/)) {     427         if (!($system_release =~ /Fedora/)) {
415                 $map{"virtualenv"} = "python-v    428                 $map{"virtualenv"} = "python-virtualenv";
416                                                   429 
417                 if ($rel && $rel < 8) {           430                 if ($rel && $rel < 8) {
418                         $old = 1;                 431                         $old = 1;
419                         $pdf = 0;                 432                         $pdf = 0;
420                                                   433 
421                         printf("Note: texlive     434                         printf("Note: texlive packages on RHEL/CENTOS <= 7 are incomplete. Can't support PDF output\n");
422                         printf("If you want to    435                         printf("If you want to build PDF, please read:\n");
423                         printf("\thttps://www.    436                         printf("\thttps://www.systutorials.com/241660/how-to-install-tex-live-on-centos-7-linux/\n");
424                 }                                 437                 }
425         } else {                                  438         } else {
426                 if ($rel && $rel < 26) {          439                 if ($rel && $rel < 26) {
427                         $old = 1;                 440                         $old = 1;
428                 }                                 441                 }
429                 if ($rel && $rel >= 38) {      << 
430                         $noto_sans_redhat = "g << 
431                 }                              << 
432         }                                         442         }
433         if (!$rel) {                              443         if (!$rel) {
434                 printf("Couldn't identify rele    444                 printf("Couldn't identify release number\n");
435                 $old = 1;                         445                 $old = 1;
436                 $pdf = 0;                         446                 $pdf = 0;
437         }                                         447         }
438                                                   448 
439         if ($pdf) {                               449         if ($pdf) {
440                 check_missing_file(["/usr/shar !! 450                 check_missing_file(["/usr/share/fonts/google-noto-cjk/NotoSansCJK-Regular.ttc"],
441                                     "/usr/shar !! 451                                    "google-noto-sans-cjk-ttc-fonts", 2);
442                                    $noto_sans_ << 
443         }                                         452         }
444                                                   453 
445         check_rpm_missing(\@fedora26_opt_pkgs,    454         check_rpm_missing(\@fedora26_opt_pkgs, 2) if ($pdf && !$old);
446         check_rpm_missing(\@fedora_tex_pkgs, 2    455         check_rpm_missing(\@fedora_tex_pkgs, 2) if ($pdf);
447         check_missing_tex(2) if ($pdf);           456         check_missing_tex(2) if ($pdf);
448         check_missing(\%map);                     457         check_missing(\%map);
449                                                   458 
450         return if (!$need && !$optional);         459         return if (!$need && !$optional);
451                                                   460 
452         if (!$old) {                              461         if (!$old) {
453                 # dnf, for Fedora 18+             462                 # dnf, for Fedora 18+
454                 printf("You should run:\n") if    463                 printf("You should run:\n") if ($verbose_warn_install);
455                 printf("\n\tsudo dnf install -    464                 printf("\n\tsudo dnf install -y $install\n");
456         } else {                                  465         } else {
457                 # yum, for RHEL (and clones) o    466                 # yum, for RHEL (and clones) or Fedora version < 18
458                 printf("You should run:\n") if    467                 printf("You should run:\n") if ($verbose_warn_install);
459                 printf("\n\tsudo yum install -    468                 printf("\n\tsudo yum install -y $install\n");
460         }                                         469         }
461 }                                                 470 }
462                                                   471 
463 sub give_opensuse_hints()                         472 sub give_opensuse_hints()
464 {                                                 473 {
465         my %map = (                               474         my %map = (
466                 "python-sphinx"         => "py    475                 "python-sphinx"         => "python3-sphinx",
467                 "yaml"                  => "py << 
468                 "virtualenv"            => "py    476                 "virtualenv"            => "python3-virtualenv",
469                 "dot"                   => "gr    477                 "dot"                   => "graphviz",
470                 "convert"               => "Im    478                 "convert"               => "ImageMagick",
471                 "Pod::Usage"            => "pe    479                 "Pod::Usage"            => "perl-Pod-Usage",
472                 "xelatex"               => "te    480                 "xelatex"               => "texlive-xetex-bin",
473         );                                        481         );
474                                                   482 
475         # On Tumbleweed, this package is also     483         # On Tumbleweed, this package is also named rsvg-convert
476         $map{"rsvg-convert"} = "rsvg-view" if     484         $map{"rsvg-convert"} = "rsvg-view" if (!($system_release =~ /Tumbleweed/));
477                                                   485 
478         my @suse_tex_pkgs = (                     486         my @suse_tex_pkgs = (
479                 "texlive-babel-english",          487                 "texlive-babel-english",
480                 "texlive-caption",                488                 "texlive-caption",
481                 "texlive-colortbl",               489                 "texlive-colortbl",
482                 "texlive-courier",                490                 "texlive-courier",
483                 "texlive-dvips",                  491                 "texlive-dvips",
484                 "texlive-helvetic",               492                 "texlive-helvetic",
485                 "texlive-makeindex",              493                 "texlive-makeindex",
486                 "texlive-metafont",               494                 "texlive-metafont",
487                 "texlive-metapost",               495                 "texlive-metapost",
488                 "texlive-palatino",               496                 "texlive-palatino",
489                 "texlive-preview",                497                 "texlive-preview",
490                 "texlive-times",                  498                 "texlive-times",
491                 "texlive-zapfchan",               499                 "texlive-zapfchan",
492                 "texlive-zapfding",               500                 "texlive-zapfding",
493         );                                        501         );
494                                                   502 
495         $map{"latexmk"} = "texlive-latexmk-bin    503         $map{"latexmk"} = "texlive-latexmk-bin";
496                                                   504 
497         # FIXME: add support for installing CJ    505         # FIXME: add support for installing CJK fonts
498         #                                         506         #
499         # I tried hard, but was unable to find    507         # I tried hard, but was unable to find a way to install
500         # "Noto Sans CJK SC" on openSUSE          508         # "Noto Sans CJK SC" on openSUSE
501                                                   509 
502         check_rpm_missing(\@suse_tex_pkgs, 2)     510         check_rpm_missing(\@suse_tex_pkgs, 2) if ($pdf);
503         check_missing_tex(2) if ($pdf);           511         check_missing_tex(2) if ($pdf);
504         check_missing(\%map);                     512         check_missing(\%map);
505                                                   513 
506         return if (!$need && !$optional);         514         return if (!$need && !$optional);
507         printf("You should run:\n") if ($verbo    515         printf("You should run:\n") if ($verbose_warn_install);
508         printf("\n\tsudo zypper install --no-r    516         printf("\n\tsudo zypper install --no-recommends $install\n");
509 }                                                 517 }
510                                                   518 
511 sub give_mageia_hints()                           519 sub give_mageia_hints()
512 {                                                 520 {
513         my %map = (                               521         my %map = (
514                 "python-sphinx"         => "py    522                 "python-sphinx"         => "python3-sphinx",
515                 "yaml"                  => "py << 
516                 "virtualenv"            => "py    523                 "virtualenv"            => "python3-virtualenv",
517                 "dot"                   => "gr    524                 "dot"                   => "graphviz",
518                 "convert"               => "Im    525                 "convert"               => "ImageMagick",
519                 "Pod::Usage"            => "pe    526                 "Pod::Usage"            => "perl-Pod-Usage",
520                 "xelatex"               => "te    527                 "xelatex"               => "texlive",
521                 "rsvg-convert"          => "li    528                 "rsvg-convert"          => "librsvg2",
522         );                                        529         );
523                                                   530 
524         my @tex_pkgs = (                          531         my @tex_pkgs = (
525                 "texlive-fontsextra",             532                 "texlive-fontsextra",
526         );                                        533         );
527                                                   534 
528         $map{"latexmk"} = "texlive-collection-    535         $map{"latexmk"} = "texlive-collection-basic";
529                                                   536 
530         my $packager_cmd;                         537         my $packager_cmd;
531         my $noto_sans;                            538         my $noto_sans;
532         if ($system_release =~ /OpenMandriva/)    539         if ($system_release =~ /OpenMandriva/) {
533                 $packager_cmd = "dnf install";    540                 $packager_cmd = "dnf install";
534                 $noto_sans = "noto-sans-cjk-fo    541                 $noto_sans = "noto-sans-cjk-fonts";
535                 @tex_pkgs = ( "texlive-collect    542                 @tex_pkgs = ( "texlive-collection-fontsextra" );
536         } else {                                  543         } else {
537                 $packager_cmd = "urpmi";          544                 $packager_cmd = "urpmi";
538                 $noto_sans = "google-noto-sans    545                 $noto_sans = "google-noto-sans-cjk-ttc-fonts";
539         }                                         546         }
540                                                   547 
541                                                   548 
542         if ($pdf) {                               549         if ($pdf) {
543                 check_missing_file(["/usr/shar    550                 check_missing_file(["/usr/share/fonts/google-noto-cjk/NotoSansCJK-Regular.ttc",
544                                     "/usr/shar    551                                     "/usr/share/fonts/TTF/NotoSans-Regular.ttf"],
545                                    $noto_sans,    552                                    $noto_sans, 2);
546         }                                         553         }
547                                                   554 
548         check_rpm_missing(\@tex_pkgs, 2) if ($    555         check_rpm_missing(\@tex_pkgs, 2) if ($pdf);
549         check_missing(\%map);                     556         check_missing(\%map);
550                                                   557 
551         return if (!$need && !$optional);         558         return if (!$need && !$optional);
552         printf("You should run:\n") if ($verbo    559         printf("You should run:\n") if ($verbose_warn_install);
553         printf("\n\tsudo $packager_cmd $instal    560         printf("\n\tsudo $packager_cmd $install\n");
554 }                                                 561 }
555                                                   562 
556 sub give_arch_linux_hints()                       563 sub give_arch_linux_hints()
557 {                                                 564 {
558         my %map = (                               565         my %map = (
559                 "yaml"                  => "py << 
560                 "virtualenv"            => "py    566                 "virtualenv"            => "python-virtualenv",
561                 "dot"                   => "gr    567                 "dot"                   => "graphviz",
562                 "convert"               => "im    568                 "convert"               => "imagemagick",
563                 "xelatex"               => "te !! 569                 "xelatex"               => "texlive-bin",
564                 "latexmk"               => "te    570                 "latexmk"               => "texlive-core",
565                 "rsvg-convert"          => "ex    571                 "rsvg-convert"          => "extra/librsvg",
566         );                                        572         );
567                                                   573 
568         my @archlinux_tex_pkgs = (                574         my @archlinux_tex_pkgs = (
569                 "texlive-core",                   575                 "texlive-core",
570                 "texlive-latexextra",             576                 "texlive-latexextra",
571                 "ttf-dejavu",                     577                 "ttf-dejavu",
572         );                                        578         );
573         check_pacman_missing(\@archlinux_tex_p    579         check_pacman_missing(\@archlinux_tex_pkgs, 2) if ($pdf);
574                                                   580 
575         if ($pdf) {                               581         if ($pdf) {
576                 check_missing_file(["/usr/shar    582                 check_missing_file(["/usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc"],
577                                    "noto-fonts    583                                    "noto-fonts-cjk", 2);
578         }                                         584         }
579                                                   585 
580         check_missing(\%map);                     586         check_missing(\%map);
581                                                   587 
582         return if (!$need && !$optional);         588         return if (!$need && !$optional);
583         printf("You should run:\n") if ($verbo    589         printf("You should run:\n") if ($verbose_warn_install);
584         printf("\n\tsudo pacman -S $install\n"    590         printf("\n\tsudo pacman -S $install\n");
585 }                                                 591 }
586                                                   592 
587 sub give_gentoo_hints()                           593 sub give_gentoo_hints()
588 {                                                 594 {
589         my %map = (                               595         my %map = (
590                 "yaml"                  => "de << 
591                 "virtualenv"            => "de    596                 "virtualenv"            => "dev-python/virtualenv",
592                 "dot"                   => "me    597                 "dot"                   => "media-gfx/graphviz",
593                 "convert"               => "me    598                 "convert"               => "media-gfx/imagemagick",
594                 "xelatex"               => "de    599                 "xelatex"               => "dev-texlive/texlive-xetex media-fonts/dejavu",
595                 "rsvg-convert"          => "gn    600                 "rsvg-convert"          => "gnome-base/librsvg",
596         );                                        601         );
597                                                   602 
598         check_missing_file(["/usr/share/fonts/    603         check_missing_file(["/usr/share/fonts/dejavu/DejaVuSans.ttf"],
599                            "media-fonts/dejavu    604                            "media-fonts/dejavu", 2) if ($pdf);
600                                                   605 
601         if ($pdf) {                               606         if ($pdf) {
602                 check_missing_file(["/usr/shar    607                 check_missing_file(["/usr/share/fonts/noto-cjk/NotoSansCJKsc-Regular.otf",
603                                     "/usr/shar    608                                     "/usr/share/fonts/noto-cjk/NotoSerifCJK-Regular.ttc"],
604                                    "media-font    609                                    "media-fonts/noto-cjk", 2);
605         }                                         610         }
606                                                   611 
607         check_missing(\%map);                     612         check_missing(\%map);
608                                                   613 
609         return if (!$need && !$optional);         614         return if (!$need && !$optional);
610                                                   615 
611         printf("You should run:\n") if ($verbo    616         printf("You should run:\n") if ($verbose_warn_install);
612         printf("\n");                             617         printf("\n");
613                                                   618 
614         my $imagemagick = "media-gfx/imagemagi    619         my $imagemagick = "media-gfx/imagemagick svg png";
615         my $cairo = "media-gfx/graphviz cairo     620         my $cairo = "media-gfx/graphviz cairo pdf";
616         my $portage_imagemagick = "/etc/portag    621         my $portage_imagemagick = "/etc/portage/package.use/imagemagick";
617         my $portage_cairo = "/etc/portage/pack    622         my $portage_cairo = "/etc/portage/package.use/graphviz";
618                                                   623 
619         if (qx(grep imagemagick $portage_image    624         if (qx(grep imagemagick $portage_imagemagick 2>/dev/null) eq "") {
620                 printf("\tsudo su -c 'echo \"$    625                 printf("\tsudo su -c 'echo \"$imagemagick\" > $portage_imagemagick'\n")
621         }                                         626         }
622         if (qx(grep graphviz $portage_cairo 2>    627         if (qx(grep graphviz $portage_cairo 2>/dev/null) eq  "") {
623                 printf("\tsudo su -c 'echo \"$    628                 printf("\tsudo su -c 'echo \"$cairo\" > $portage_cairo'\n");
624         }                                         629         }
625                                                   630 
626         printf("\tsudo emerge --ask $install\n    631         printf("\tsudo emerge --ask $install\n");
627                                                   632 
628 }                                                 633 }
629                                                   634 
630 sub check_distros()                               635 sub check_distros()
631 {                                                 636 {
632         # Distro-specific hints                   637         # Distro-specific hints
633         if ($system_release =~ /Red Hat Enterp    638         if ($system_release =~ /Red Hat Enterprise Linux/) {
634                 give_redhat_hints;                639                 give_redhat_hints;
635                 return;                           640                 return;
636         }                                         641         }
637         if ($system_release =~ /CentOS/) {        642         if ($system_release =~ /CentOS/) {
638                 give_redhat_hints;                643                 give_redhat_hints;
639                 return;                           644                 return;
640         }                                         645         }
641         if ($system_release =~ /Scientific Lin    646         if ($system_release =~ /Scientific Linux/) {
642                 give_redhat_hints;                647                 give_redhat_hints;
643                 return;                           648                 return;
644         }                                         649         }
645         if ($system_release =~ /Oracle Linux S    650         if ($system_release =~ /Oracle Linux Server/) {
646                 give_redhat_hints;                651                 give_redhat_hints;
647                 return;                           652                 return;
648         }                                         653         }
649         if ($system_release =~ /Fedora/) {        654         if ($system_release =~ /Fedora/) {
650                 give_redhat_hints;                655                 give_redhat_hints;
651                 return;                           656                 return;
652         }                                         657         }
653         if ($system_release =~ /Ubuntu/) {        658         if ($system_release =~ /Ubuntu/) {
654                 give_debian_hints;                659                 give_debian_hints;
655                 return;                           660                 return;
656         }                                         661         }
657         if ($system_release =~ /Debian/) {        662         if ($system_release =~ /Debian/) {
658                 give_debian_hints;                663                 give_debian_hints;
659                 return;                           664                 return;
660         }                                         665         }
661         if ($system_release =~ /openSUSE/) {      666         if ($system_release =~ /openSUSE/) {
662                 give_opensuse_hints;              667                 give_opensuse_hints;
663                 return;                           668                 return;
664         }                                         669         }
665         if ($system_release =~ /Mageia/) {        670         if ($system_release =~ /Mageia/) {
666                 give_mageia_hints;                671                 give_mageia_hints;
667                 return;                           672                 return;
668         }                                         673         }
669         if ($system_release =~ /OpenMandriva/)    674         if ($system_release =~ /OpenMandriva/) {
670                 give_mageia_hints;                675                 give_mageia_hints;
671                 return;                           676                 return;
672         }                                         677         }
673         if ($system_release =~ /Arch Linux/) {    678         if ($system_release =~ /Arch Linux/) {
674                 give_arch_linux_hints;            679                 give_arch_linux_hints;
675                 return;                           680                 return;
676         }                                         681         }
677         if ($system_release =~ /Gentoo/) {        682         if ($system_release =~ /Gentoo/) {
678                 give_gentoo_hints;                683                 give_gentoo_hints;
679                 return;                           684                 return;
680         }                                         685         }
681                                                   686 
682         #                                         687         #
683         # Fall-back to generic hint code for o    688         # Fall-back to generic hint code for other distros
684         # That's far from ideal, specially for    689         # That's far from ideal, specially for LaTeX dependencies.
685         #                                         690         #
686         my %map = (                               691         my %map = (
687                 "sphinx-build" => "sphinx"        692                 "sphinx-build" => "sphinx"
688         );                                        693         );
689         check_missing_tex(2) if ($pdf);           694         check_missing_tex(2) if ($pdf);
690         check_missing(\%map);                     695         check_missing(\%map);
691         print "I don't know distro $system_rel    696         print "I don't know distro $system_release.\n";
692         print "So, I can't provide you a hint     697         print "So, I can't provide you a hint with the install procedure.\n";
693         print "There are likely missing depend    698         print "There are likely missing dependencies.\n";
694 }                                                 699 }
695                                                   700 
696 #                                                 701 #
697 # Common dependencies                             702 # Common dependencies
698 #                                                 703 #
699                                                   704 
700 sub deactivate_help()                             705 sub deactivate_help()
701 {                                                 706 {
702         printf "\n    If you want to exit the     707         printf "\n    If you want to exit the virtualenv, you can use:\n";
703         printf "\tdeactivate\n";                  708         printf "\tdeactivate\n";
704 }                                                 709 }
705                                                   710 
706 sub get_virtenv()                                 711 sub get_virtenv()
707 {                                                 712 {
708         my $ver;                                  713         my $ver;
709         my $min_activate = "$ENV{'PWD'}/${virt    714         my $min_activate = "$ENV{'PWD'}/${virtenv_prefix}${min_version}/bin/activate";
710         my @activates = glob "$ENV{'PWD'}/${vi    715         my @activates = glob "$ENV{'PWD'}/${virtenv_prefix}*/bin/activate";
711                                                   716 
712         @activates = sort {$b cmp $a} @activat    717         @activates = sort {$b cmp $a} @activates;
713                                                   718 
714         foreach my $f (@activates) {              719         foreach my $f (@activates) {
715                 next if ($f lt $min_activate);    720                 next if ($f lt $min_activate);
716                                                   721 
717                 my $sphinx_cmd = $f;              722                 my $sphinx_cmd = $f;
718                 $sphinx_cmd =~ s/activate/sphi    723                 $sphinx_cmd =~ s/activate/sphinx-build/;
719                 next if (! -f $sphinx_cmd);       724                 next if (! -f $sphinx_cmd);
720                                                   725 
721                 my $ver = get_sphinx_version($    726                 my $ver = get_sphinx_version($sphinx_cmd);
722                                                   727 
723                 if (!$ver) {                      728                 if (!$ver) {
724                         $f =~ s#/bin/activate#    729                         $f =~ s#/bin/activate##;
725                         print("Warning: virtua    730                         print("Warning: virtual environment $f is not working.\nPython version upgrade? Remove it with:\n\n\trm -rf $f\n\n");
726                 }                                 731                 }
727                                                   732 
728                 if ($need_sphinx && ($ver ge $    733                 if ($need_sphinx && ($ver ge $min_version)) {
729                         return ($f, $ver);        734                         return ($f, $ver);
730                 } elsif ($ver gt $cur_version)    735                 } elsif ($ver gt $cur_version) {
731                         return ($f, $ver);        736                         return ($f, $ver);
732                 }                                 737                 }
733         }                                         738         }
734         return ("", "");                          739         return ("", "");
735 }                                                 740 }
736                                                   741 
737 sub recommend_sphinx_upgrade()                    742 sub recommend_sphinx_upgrade()
738 {                                                 743 {
739         my $venv_ver;                             744         my $venv_ver;
740                                                   745 
741         # Avoid running sphinx-builds from ven    746         # Avoid running sphinx-builds from venv if $cur_version is good
742         if ($cur_version && ($cur_version ge $    747         if ($cur_version && ($cur_version ge $rec_version)) {
743                 $latest_avail_ver = $cur_versi    748                 $latest_avail_ver = $cur_version;
744                 return;                           749                 return;
745         }                                         750         }
746                                                   751 
747         # Get the highest version from sphinx_    752         # Get the highest version from sphinx_*/bin/sphinx-build and the
748         # corresponding command to activate th    753         # corresponding command to activate the venv/virtenv
749         ($activate_cmd, $venv_ver) = get_virte    754         ($activate_cmd, $venv_ver) = get_virtenv();
750                                                   755 
751         # Store the highest version from Sphin    756         # Store the highest version from Sphinx existing virtualenvs
752         if (($activate_cmd ne "") && ($venv_ve    757         if (($activate_cmd ne "") && ($venv_ver gt $cur_version)) {
753                 $latest_avail_ver = $venv_ver;    758                 $latest_avail_ver = $venv_ver;
754         } else {                                  759         } else {
755                 $latest_avail_ver = $cur_versi    760                 $latest_avail_ver = $cur_version if ($cur_version);
756         }                                         761         }
757                                                   762 
758         # As we don't know package version of     763         # As we don't know package version of Sphinx, and there's no
759         # virtual environments, don't check if    764         # virtual environments, don't check if upgrades are needed
760         if (!$virtualenv) {                       765         if (!$virtualenv) {
761                 return if (!$latest_avail_ver)    766                 return if (!$latest_avail_ver);
762         }                                         767         }
763                                                   768 
764         # Either there are already a virtual e    769         # Either there are already a virtual env or a new one should be created
765         $need_pip = 1;                            770         $need_pip = 1;
766                                                   771 
767         return if (!$latest_avail_ver);           772         return if (!$latest_avail_ver);
768                                                   773 
769         # Return if the reason is due to an up    774         # Return if the reason is due to an upgrade or not
770         if ($latest_avail_ver lt $rec_version)    775         if ($latest_avail_ver lt $rec_version) {
771                 $rec_sphinx_upgrade = 1;          776                 $rec_sphinx_upgrade = 1;
772         }                                         777         }
773                                                   778 
774         return $latest_avail_ver;                 779         return $latest_avail_ver;
775 }                                                 780 }
776                                                   781 
777 #                                                 782 #
778 # The logic here is complex, as it have to dea    783 # The logic here is complex, as it have to deal with different versions:
779 #       - minimal supported version;              784 #       - minimal supported version;
780 #       - minimal PDF version;                    785 #       - minimal PDF version;
781 #       - recommended version.                    786 #       - recommended version.
782 # It also needs to work fine with both distro'    787 # It also needs to work fine with both distro's package and venv/virtualenv
783 sub recommend_sphinx_version($)                   788 sub recommend_sphinx_version($)
784 {                                                 789 {
785         my $virtualenv_cmd = shift;               790         my $virtualenv_cmd = shift;
786                                                   791 
787         # Version is OK. Nothing to do.           792         # Version is OK. Nothing to do.
788         if ($cur_version && ($cur_version ge $    793         if ($cur_version && ($cur_version ge $rec_version)) {
                                                   >> 794                 if ($cur_version lt $min_pdf_version) {
                                                   >> 795                         print "note: If you want pdf, you need at least Sphinx $min_pdf_version.\n";
                                                   >> 796                 }
789                 return;                           797                 return;
790         };                                        798         };
791                                                   799 
792         if (!$need_sphinx) {                      800         if (!$need_sphinx) {
793                 # sphinx-build is present and     801                 # sphinx-build is present and its version is >= $min_version
794                                                   802 
795                 #only recommend enabling a new    803                 #only recommend enabling a newer virtenv version if makes sense.
796                 if ($latest_avail_ver gt $cur_    804                 if ($latest_avail_ver gt $cur_version) {
797                         printf "\nYou may also    805                         printf "\nYou may also use the newer Sphinx version $latest_avail_ver with:\n";
798                         printf "\tdeactivate\n    806                         printf "\tdeactivate\n"  if ($ENV{'PWD'} =~ /${virtenv_prefix}/);
799                         printf "\t. $activate_    807                         printf "\t. $activate_cmd\n";
800                         deactivate_help();        808                         deactivate_help();
801                                                   809 
802                         return;                   810                         return;
803                 }                                 811                 }
804                 return if ($latest_avail_ver g    812                 return if ($latest_avail_ver ge $rec_version);
805         }                                         813         }
806                                                   814 
807         if (!$virtualenv) {                       815         if (!$virtualenv) {
808                 # No sphinx either via package    816                 # No sphinx either via package or via virtenv. As we can't
809                 # Compare the versions here, j    817                 # Compare the versions here, just return, recommending the
810                 # user to install it from the     818                 # user to install it from the package distro.
811                 return if (!$latest_avail_ver)    819                 return if (!$latest_avail_ver);
812                                                   820 
813                 # User doesn't want a virtenv     821                 # User doesn't want a virtenv recommendation, but he already
814                 # installed one via virtenv wi    822                 # installed one via virtenv with a newer version.
815                 # So, print commands to enable    823                 # So, print commands to enable it
816                 if ($latest_avail_ver gt $cur_    824                 if ($latest_avail_ver gt $cur_version) {
817                         printf "\nYou may also    825                         printf "\nYou may also use the Sphinx virtualenv version $latest_avail_ver with:\n";
818                         printf "\tdeactivate\n    826                         printf "\tdeactivate\n"  if ($ENV{'PWD'} =~ /${virtenv_prefix}/);
819                         printf "\t. $activate_    827                         printf "\t. $activate_cmd\n";
820                         deactivate_help();        828                         deactivate_help();
821                                                   829 
822                         return;                   830                         return;
823                 }                                 831                 }
824                 print "\n";                       832                 print "\n";
825         } else {                                  833         } else {
826                 $need++ if ($need_sphinx);        834                 $need++ if ($need_sphinx);
827         }                                         835         }
828                                                   836 
829         # Suggest newer versions if current on    837         # Suggest newer versions if current ones are too old
830         if ($latest_avail_ver && $latest_avail    838         if ($latest_avail_ver && $latest_avail_ver ge $min_version) {
831                 # If there's a good enough ver    839                 # If there's a good enough version, ask the user to enable it
832                 if ($latest_avail_ver ge $rec_    840                 if ($latest_avail_ver ge $rec_version) {
833                         printf "\nNeed to acti    841                         printf "\nNeed to activate Sphinx (version $latest_avail_ver) on virtualenv with:\n";
834                         printf "\t. $activate_    842                         printf "\t. $activate_cmd\n";
835                         deactivate_help();        843                         deactivate_help();
836                                                   844 
                                                   >> 845                         if ($latest_avail_ver lt $min_pdf_version) {
                                                   >> 846                                 print "note: If you want pdf, you need at least Sphinx $min_pdf_version.\n";
                                                   >> 847                         }
                                                   >> 848 
837                         return;                   849                         return;
838                 }                                 850                 }
839                                                   851 
840                 # Version is above the minimal    852                 # Version is above the minimal required one, but may be
841                 # below the recommended one. S    853                 # below the recommended one. So, print warnings/notes
842                                                   854 
843                 if ($latest_avail_ver lt $rec_    855                 if ($latest_avail_ver lt $rec_version) {
844                         print "Warning: It is     856                         print "Warning: It is recommended at least Sphinx version $rec_version.\n";
845                 }                                 857                 }
846         }                                         858         }
847                                                   859 
848         # At this point, either it needs Sphin    860         # At this point, either it needs Sphinx or upgrade is recommended,
849         # both via pip                            861         # both via pip
850                                                   862 
851         if ($rec_sphinx_upgrade) {                863         if ($rec_sphinx_upgrade) {
852                 if (!$virtualenv) {               864                 if (!$virtualenv) {
853                         print "Instead of inst    865                         print "Instead of install/upgrade Python Sphinx pkg, you could use pip/pypi with:\n\n";
854                 } else {                          866                 } else {
855                         print "To upgrade Sphi    867                         print "To upgrade Sphinx, use:\n\n";
856                 }                                 868                 }
857         } else {                                  869         } else {
858                 print "\nSphinx needs to be in    870                 print "\nSphinx needs to be installed either:\n1) via pip/pypi with:\n\n";
859         }                                         871         }
860                                                   872 
861         $python_cmd = find_python_no_venv();      873         $python_cmd = find_python_no_venv();
862                                                   874 
863         printf "\t$virtualenv_cmd $virtenv_dir    875         printf "\t$virtualenv_cmd $virtenv_dir\n";
864                                                   876 
865         printf "\t. $virtenv_dir/bin/activate\    877         printf "\t. $virtenv_dir/bin/activate\n";
866         printf "\tpip install -r $requirement_    878         printf "\tpip install -r $requirement_file\n";
867         deactivate_help();                        879         deactivate_help();
868                                                   880 
869         printf "\n2) As a package with:\n";       881         printf "\n2) As a package with:\n";
870                                                   882 
871         my $old_need = $need;                     883         my $old_need = $need;
872         my $old_optional = $optional;             884         my $old_optional = $optional;
873         %missing = ();                            885         %missing = ();
874         $pdf = 0;                                 886         $pdf = 0;
875         $optional = 0;                            887         $optional = 0;
876         $install = "";                            888         $install = "";
877         $verbose_warn_install = 0;                889         $verbose_warn_install = 0;
878                                                   890 
879         add_package("python-sphinx", 0);          891         add_package("python-sphinx", 0);
880                                                   892 
881         check_distros();                          893         check_distros();
882                                                   894 
883         $need = $old_need;                        895         $need = $old_need;
884         $optional = $old_optional;                896         $optional = $old_optional;
885                                                   897 
886         printf "\n    Please note that Sphinx     898         printf "\n    Please note that Sphinx >= 3.0 will currently produce false-positive\n";
887         printf "   warning when the same name     899         printf "   warning when the same name is used for more than one type (functions,\n";
888         printf "   structs, enums,...). This i    900         printf "   structs, enums,...). This is known Sphinx bug. For more details, see:\n";
889         printf "\thttps://github.com/sphinx-do    901         printf "\thttps://github.com/sphinx-doc/sphinx/pull/8313\n";
890 }                                                 902 }
891                                                   903 
892 sub check_needs()                                 904 sub check_needs()
893 {                                                 905 {
894         # Check if Sphinx is already accessibl    906         # Check if Sphinx is already accessible from current environment
895         check_sphinx();                           907         check_sphinx();
896                                                   908 
897         if ($system_release) {                    909         if ($system_release) {
898                 print "Detected OS: $system_re    910                 print "Detected OS: $system_release.\n";
899         } else {                                  911         } else {
900                 print "Unknown OS\n";             912                 print "Unknown OS\n";
901         }                                         913         }
902         printf "Sphinx version: %s\n\n", $cur_    914         printf "Sphinx version: %s\n\n", $cur_version if ($cur_version);
903                                                   915 
904         # Check python command line, trying fi    916         # Check python command line, trying first python3
905         $python_cmd = findprog("python3");        917         $python_cmd = findprog("python3");
906         $python_cmd = check_program("python",     918         $python_cmd = check_program("python", 0) if (!$python_cmd);
907                                                   919 
908         # Check the type of virtual env, depen    920         # Check the type of virtual env, depending on Python version
909         if ($python_cmd) {                        921         if ($python_cmd) {
910                 if ($virtualenv) {                922                 if ($virtualenv) {
911                         my $tmp = qx($python_c    923                         my $tmp = qx($python_cmd --version 2>&1);
912                         if ($tmp =~ m/(\d+\.)(    924                         if ($tmp =~ m/(\d+\.)(\d+\.)/) {
913                                 if ($1 < 3) {     925                                 if ($1 < 3) {
914                                         # Fail    926                                         # Fail if it finds python2 (or worse)
915                                         die "P    927                                         die "Python 3 is required to build the kernel docs\n";
916                                 }                 928                                 }
917                                 if ($1 == 3 &&    929                                 if ($1 == 3 && $2 < 3) {
918                                         # Need    930                                         # Need Python 3.3 or upper for venv
919                                         $need_    931                                         $need_virtualenv = 1;
920                                 }                 932                                 }
921                         } else {                  933                         } else {
922                                 die "Warning:     934                                 die "Warning: couldn't identify $python_cmd version!";
923                         }                         935                         }
924                 } else {                          936                 } else {
925                         add_package("python-sp    937                         add_package("python-sphinx", 0);
926                 }                                 938                 }
927         }                                         939         }
928                                                   940 
929         my $venv_ver = recommend_sphinx_upgrad    941         my $venv_ver = recommend_sphinx_upgrade();
930                                                   942 
931         my $virtualenv_cmd;                       943         my $virtualenv_cmd;
932                                                   944 
933         if ($need_pip) {                          945         if ($need_pip) {
934                 # Set virtualenv command line,    946                 # Set virtualenv command line, if python < 3.3
935                 if ($need_virtualenv) {           947                 if ($need_virtualenv) {
936                         $virtualenv_cmd = find    948                         $virtualenv_cmd = findprog("virtualenv-3");
937                         $virtualenv_cmd = find    949                         $virtualenv_cmd = findprog("virtualenv-3.5") if (!$virtualenv_cmd);
938                         if (!$virtualenv_cmd)     950                         if (!$virtualenv_cmd) {
939                                 check_program(    951                                 check_program("virtualenv", 0);
940                                 $virtualenv_cm    952                                 $virtualenv_cmd = "virtualenv";
941                         }                         953                         }
942                 } else {                          954                 } else {
943                         $virtualenv_cmd = "$py    955                         $virtualenv_cmd = "$python_cmd -m venv";
944                         check_python_module("e    956                         check_python_module("ensurepip", 0);
945                 }                                 957                 }
946         }                                         958         }
947                                                   959 
948         # Check for needed programs/tools         960         # Check for needed programs/tools
949         check_perl_module("Pod::Usage", 0);       961         check_perl_module("Pod::Usage", 0);
950         check_python_module("yaml", 0);        << 
951         check_program("make", 0);                 962         check_program("make", 0);
952         check_program("gcc", 0);                  963         check_program("gcc", 0);
953         check_program("dot", 1);                  964         check_program("dot", 1);
954         check_program("convert", 1);              965         check_program("convert", 1);
955                                                   966 
956         # Extra PDF files - should use 2 for i    967         # Extra PDF files - should use 2 for is_optional
957         check_program("xelatex", 2) if ($pdf);    968         check_program("xelatex", 2) if ($pdf);
958         check_program("rsvg-convert", 2) if ($    969         check_program("rsvg-convert", 2) if ($pdf);
959         check_program("latexmk", 2) if ($pdf);    970         check_program("latexmk", 2) if ($pdf);
960                                                   971 
961         # Do distro-specific checks and output    972         # Do distro-specific checks and output distro-install commands
962         check_distros();                          973         check_distros();
963                                                   974 
964         if (!$python_cmd) {                       975         if (!$python_cmd) {
965                 if ($need == 1) {                 976                 if ($need == 1) {
966                         die "Can't build as $n    977                         die "Can't build as $need mandatory dependency is missing";
967                 } elsif ($need) {                 978                 } elsif ($need) {
968                         die "Can't build as $n    979                         die "Can't build as $need mandatory dependencies are missing";
969                 }                                 980                 }
970         }                                         981         }
971                                                   982 
972         # Check if sphinx-build is called sphi    983         # Check if sphinx-build is called sphinx-build-3
973         if ($need_symlink) {                      984         if ($need_symlink) {
974                 printf "\tsudo ln -sf %s /usr/    985                 printf "\tsudo ln -sf %s /usr/bin/sphinx-build\n\n",
975                        which("sphinx-build-3")    986                        which("sphinx-build-3");
976         }                                         987         }
977                                                   988 
978         recommend_sphinx_version($virtualenv_c    989         recommend_sphinx_version($virtualenv_cmd);
979         printf "\n";                              990         printf "\n";
980                                                   991 
981         print "All optional dependencies are m    992         print "All optional dependencies are met.\n" if (!$optional);
982                                                   993 
983         if ($need == 1) {                         994         if ($need == 1) {
984                 die "Can't build as $need mand    995                 die "Can't build as $need mandatory dependency is missing";
985         } elsif ($need) {                         996         } elsif ($need) {
986                 die "Can't build as $need mand    997                 die "Can't build as $need mandatory dependencies are missing";
987         }                                         998         }
988                                                   999 
989         print "Needed package dependencies are    1000         print "Needed package dependencies are met.\n";
990 }                                                 1001 }
991                                                   1002 
992 #                                                 1003 #
993 # Main                                            1004 # Main
994 #                                                 1005 #
995                                                   1006 
996 while (@ARGV) {                                   1007 while (@ARGV) {
997         my $arg = shift(@ARGV);                   1008         my $arg = shift(@ARGV);
998                                                   1009 
999         if ($arg eq "--no-virtualenv") {          1010         if ($arg eq "--no-virtualenv") {
1000                 $virtualenv = 0;                 1011                 $virtualenv = 0;
1001         } elsif ($arg eq "--no-pdf"){            1012         } elsif ($arg eq "--no-pdf"){
1002                 $pdf = 0;                        1013                 $pdf = 0;
1003         } elsif ($arg eq "--version-check"){     1014         } elsif ($arg eq "--version-check"){
1004                 $version_check = 1;              1015                 $version_check = 1;
1005         } else {                                 1016         } else {
1006                 print "Usage:\n\t$0 <--no-vir    1017                 print "Usage:\n\t$0 <--no-virtualenv> <--no-pdf> <--version-check>\n\n";
1007                 print "Where:\n";                1018                 print "Where:\n";
1008                 print "\t--no-virtualenv\t- R    1019                 print "\t--no-virtualenv\t- Recommend installing Sphinx instead of using a virtualenv\n";
1009                 print "\t--version-check\t- i    1020                 print "\t--version-check\t- if version is compatible, don't check for missing dependencies\n";
1010                 print "\t--no-pdf\t- don't ch    1021                 print "\t--no-pdf\t- don't check for dependencies required to build PDF docs\n\n";
1011                 exit -1;                         1022                 exit -1;
1012         }                                        1023         }
1013 }                                                1024 }
1014                                                  1025 
1015 #                                                1026 #
1016 # Determine the system type. There's no stand    1027 # Determine the system type. There's no standard unique way that would
1017 # work with all distros with a minimal packag    1028 # work with all distros with a minimal package install. So, several
1018 # methods are used here.                         1029 # methods are used here.
1019 #                                                1030 #
1020 # By default, it will use lsb_release functio    1031 # By default, it will use lsb_release function. If not available, it will
1021 # fail back to reading the known different pl    1032 # fail back to reading the known different places where the distro name
1022 # is stored                                      1033 # is stored
1023 #                                                1034 #
1024                                                  1035 
1025 $system_release = qx(lsb_release -d) if which    1036 $system_release = qx(lsb_release -d) if which("lsb_release");
1026 $system_release =~ s/Description:\s*// if ($s    1037 $system_release =~ s/Description:\s*// if ($system_release);
1027 $system_release = catcheck("/etc/system-relea    1038 $system_release = catcheck("/etc/system-release") if !$system_release;
1028 $system_release = catcheck("/etc/redhat-relea    1039 $system_release = catcheck("/etc/redhat-release") if !$system_release;
1029 $system_release = catcheck("/etc/lsb-release"    1040 $system_release = catcheck("/etc/lsb-release") if !$system_release;
1030 $system_release = catcheck("/etc/gentoo-relea    1041 $system_release = catcheck("/etc/gentoo-release") if !$system_release;
1031                                                  1042 
1032 # This seems more common than LSB these days     1043 # This seems more common than LSB these days
1033 if (!$system_release) {                          1044 if (!$system_release) {
1034         my %os_var;                              1045         my %os_var;
1035         if (open IN, "cat /etc/os-release|")     1046         if (open IN, "cat /etc/os-release|") {
1036                 while (<IN>) {                   1047                 while (<IN>) {
1037                         if (m/^([\w\d\_]+)=\"    1048                         if (m/^([\w\d\_]+)=\"?([^\"]*)\"?\n/) {
1038                                 $os_var{$1}=$    1049                                 $os_var{$1}=$2;
1039                         }                        1050                         }
1040                 }                                1051                 }
1041                 $system_release = $os_var{"NA    1052                 $system_release = $os_var{"NAME"};
1042                 if (defined($os_var{"VERSION_    1053                 if (defined($os_var{"VERSION_ID"})) {
1043                         $system_release .= "     1054                         $system_release .= " " . $os_var{"VERSION_ID"} if (defined($os_var{"VERSION_ID"}));
1044                 } else {                         1055                 } else {
1045                         $system_release .= "     1056                         $system_release .= " " . $os_var{"VERSION"};
1046                 }                                1057                 }
1047         }                                        1058         }
1048 }                                                1059 }
1049 $system_release = catcheck("/etc/issue") if !    1060 $system_release = catcheck("/etc/issue") if !$system_release;
1050 $system_release =~ s/\s+$//;                     1061 $system_release =~ s/\s+$//;
1051                                                  1062 
1052 check_needs;                                     1063 check_needs;
                                                      

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php