~ [ 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 (Architecture i386) and /scripts/sphinx-pre-install (Architecture mips)


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