debian/control

   1 Source: rustc
   2 Section: devel
   3 Priority: optional
   4 Maintainer: Debian Rust Maintainers <pkg-rust-maintainers@alioth-lists.debian.net>
   5 Uploaders:
   6  Ximin Luo <infinity0@debian.org>,
   7  Sylvestre Ledru <sylvestre@debian.org>
   8 Rules-Requires-Root: no
   9 # :native annotations are to support cross-compiling, see README.Debian
  10 Build-Depends:
  11  debhelper (>= 9),
  12  debhelper-compat (= 12),
  13  dpkg-dev (>= 1.17.14),
  14  python3:native,
  15  cargo:native (>= 0.40.0)      <!pkg.rustc.dlstage0>,
  16  rustc:native (>= 1.51.0+dfsg) <!pkg.rustc.dlstage0>,
  17  rustc:native (<= 1.52.1++)    <!pkg.rustc.dlstage0>,
  18  llvm-12-dev:native,
  19  llvm-12-tools:native,
  20  gcc-mingw-w64-x86-64-posix:native [amd64] <!nowindows>,
  21  gcc-mingw-w64-i686-posix:native [i386] <!nowindows>,
  22  libllvm12,
  23  cmake (>= 3.0) | cmake3,
  24 # needed by some vendor crates
  25  pkg-config,
  26 # this is sometimes needed by rustc_llvm
  27  zlib1g-dev:native,
  28  zlib1g-dev,
  29 # used by rust-installer
  30  liblzma-dev:native,
  31 # test dependencies:
  32  binutils (>= 2.26) <!nocheck> | binutils-2.26 <!nocheck>,
  33  git <!nocheck>,
  34  procps <!nocheck>,
  35 # below are optional tools even for 'make check'
  36  gdb (>= 7.12) <!nocheck>,
  37 # Extra build-deps needed for x.py to download stuff in pkg.rustc.dlstage0.
  38  curl <pkg.rustc.dlstage0>,
  39  ca-certificates <pkg.rustc.dlstage0>,
  40 Build-Depends-Indep:
  41  wasi-libc (>= 0.0~git20201130.5879558~~) <!nowasm>,
  42  wasi-libc (<= 0.0~git20201130.5879558++) <!nowasm>,
  43  clang-12:native,
  44 Build-Conflicts: gdb-minimal <!nocheck>
  45 Standards-Version: 4.2.1
  46 Homepage: http://www.rust-lang.org/
  47 Vcs-Git: https://salsa.debian.org/rust-team/rust.git
  48 Vcs-Browser: https://salsa.debian.org/rust-team/rust
  49
  50 Package: rustc
  51 Architecture: any
  52 Multi-Arch: allowed
  53 Pre-Depends: ${misc:Pre-Depends}
  54 Depends: ${shlibs:Depends}, ${misc:Depends},
  55  libstd-rust-dev (= ${binary:Version}),
  56  gcc, libc-dev, binutils (>= 2.26)
  57 Recommends:
  58  cargo (>= 0.53.0~~), cargo (<< 0.54.0~~),
  59 # llvm is needed for llvm-dwp for -C split-debuginfo=packed
  60  llvm-12,
  61 Suggests:
  62 # lld and clang are needed for wasm compilation
  63  lld-12, clang-12,
  64 Replaces: libstd-rust-dev (<< 1.25.0+dfsg1-2~~)
  65 Breaks: libstd-rust-dev (<< 1.25.0+dfsg1-2~~)
  66 Description: Rust systems programming language
  67  Rust is a curly-brace, block-structured expression language.  It
  68  visually resembles the C language family, but differs significantly
  69  in syntactic and semantic details.  Its design is oriented toward
  70  concerns of "programming in the large", that is, of creating and
  71  maintaining boundaries - both abstract and operational - that
  72  preserve large-system integrity, availability and concurrency.
  73  .
  74  It supports a mixture of imperative procedural, concurrent actor,
  75  object-oriented and pure functional styles.  Rust also supports
  76  generic programming and meta-programming, in both static and dynamic
  77  styles.
  78
  79 Package: libstd-rust-1.52
  80 Section: libs
  81 Architecture: any
  82 Multi-Arch: same
  83 Pre-Depends: ${misc:Pre-Depends}
  84 Depends: ${shlibs:Depends}, ${misc:Depends}
  85 Description: Rust standard libraries
  86  Rust is a curly-brace, block-structured expression language.  It
  87  visually resembles the C language family, but differs significantly
  88  in syntactic and semantic details.  Its design is oriented toward
  89  concerns of "programming in the large", that is, of creating and
  90  maintaining boundaries - both abstract and operational - that
  91  preserve large-system integrity, availability and concurrency.
  92  .
  93  It supports a mixture of imperative procedural, concurrent actor,
  94  object-oriented and pure functional styles.  Rust also supports
  95  generic programming and meta-programming, in both static and dynamic
  96  styles.
  97  .
  98  This package contains the standard Rust libraries, built as dylibs,
  99  needed to run dynamically-linked Rust programs (-C prefer-dynamic).
 100
 101 Package: libstd-rust-dev
 102 Section: libdevel
 103 Architecture: any
 104 Multi-Arch: same
 105 Depends: ${shlibs:Depends}, ${misc:Depends},
 106  libstd-rust-1.52 (= ${binary:Version}),
 107 Description: Rust standard libraries - development files
 108  Rust is a curly-brace, block-structured expression language.  It
 109  visually resembles the C language family, but differs significantly
 110  in syntactic and semantic details.  Its design is oriented toward
 111  concerns of "programming in the large", that is, of creating and
 112  maintaining boundaries - both abstract and operational - that
 113  preserve large-system integrity, availability and concurrency.
 114  .
 115  It supports a mixture of imperative procedural, concurrent actor,
 116  object-oriented and pure functional styles.  Rust also supports
 117  generic programming and meta-programming, in both static and dynamic
 118  styles.
 119  .
 120  This package contains development files for the standard Rust libraries,
 121  needed to compile Rust programs. It may also be installed on a system
 122  of another host architecture, for cross-compiling to this architecture.
 123
 124 Package: libstd-rust-dev-windows
 125 Section: libdevel
 126 Architecture: amd64 i386
 127 Multi-Arch: same
 128 Depends: ${shlibs:Depends}, ${misc:Depends}
 129 Recommends:
 130  gcc-mingw-w64-x86-64-posix [amd64],
 131  gcc-mingw-w64-i686-posix [i386],
 132 Build-Profiles: <!nowindows>
 133 Description: Rust standard libraries - development files
 134  Rust is a curly-brace, block-structured expression language.  It
 135  visually resembles the C language family, but differs significantly
 136  in syntactic and semantic details.  Its design is oriented toward
 137  concerns of "programming in the large", that is, of creating and
 138  maintaining boundaries - both abstract and operational - that
 139  preserve large-system integrity, availability and concurrency.
 140  .
 141  It supports a mixture of imperative procedural, concurrent actor,
 142  object-oriented and pure functional styles.  Rust also supports
 143  generic programming and meta-programming, in both static and dynamic
 144  styles.
 145  .
 146  This package contains the standard Rust libraries including development files,
 147  needed to cross-compile Rust programs to the *-pc-windows-gnu target
 148  corresponding to the architecture of this package.
 149
 150 Package: libstd-rust-dev-wasm32
 151 Section: libdevel
 152 Architecture: all
 153 Multi-Arch: foreign
 154 Depends: ${shlibs:Depends}, ${misc:Depends}
 155 # Embeds wasi-libc so doesn't need to depend on it
 156 # None of its licenses require source redistrib, so no need for Built-Using
 157 Recommends:
 158  lld-12, clang-12,
 159 Suggests:
 160 # nodejs contains wasi-node for running the program
 161  nodejs (>= 12.16),
 162 Build-Profiles: <!nowasm>
 163 Description: Rust standard libraries - development files
 164  Rust is a curly-brace, block-structured expression language.  It
 165  visually resembles the C language family, but differs significantly
 166  in syntactic and semantic details.  Its design is oriented toward
 167  concerns of "programming in the large", that is, of creating and
 168  maintaining boundaries - both abstract and operational - that
 169  preserve large-system integrity, availability and concurrency.
 170  .
 171  It supports a mixture of imperative procedural, concurrent actor,
 172  object-oriented and pure functional styles.  Rust also supports
 173  generic programming and meta-programming, in both static and dynamic
 174  styles.
 175  .
 176  This package contains the standard Rust libraries including development files,
 177  needed to cross-compile Rust programs to the wasm32-unknown-unknown and
 178  wasm32-wasi targets.
 179
 180 Package: rust-gdb
 181 Architecture: all
 182 Depends: gdb, ${misc:Depends}
 183 Suggests: gdb-doc
 184 Replaces: rustc (<< 1.1.0+dfsg1-1)
 185 Description: Rust debugger (gdb)
 186  Rust is a curly-brace, block-structured expression language.  It
 187  visually resembles the C language family, but differs significantly
 188  in syntactic and semantic details.  Its design is oriented toward
 189  concerns of "programming in the large", that is, of creating and
 190  maintaining boundaries - both abstract and operational - that
 191  preserve large-system integrity, availability and concurrency.
 192  .
 193  It supports a mixture of imperative procedural, concurrent actor,
 194  object-oriented and pure functional styles.  Rust also supports
 195  generic programming and meta-programming, in both static and dynamic
 196  styles.
 197  .
 198  This package contains pretty printers and a wrapper script for
 199  invoking gdb on rust binaries.
 200
 201 Package: rust-lldb
 202 Architecture: all
 203 # When updating, also update rust-lldb.links
 204 Depends: lldb-12, ${misc:Depends}, python3-lldb-12
 205 Replaces: rustc (<< 1.1.0+dfsg1-1)
 206 Description: Rust debugger (lldb)
 207  Rust is a curly-brace, block-structured expression language.  It
 208  visually resembles the C language family, but differs significantly
 209  in syntactic and semantic details.  Its design is oriented toward
 210  concerns of "programming in the large", that is, of creating and
 211  maintaining boundaries - both abstract and operational - that
 212  preserve large-system integrity, availability and concurrency.
 213  .
 214  It supports a mixture of imperative procedural, concurrent actor,
 215  object-oriented and pure functional styles.  Rust also supports
 216  generic programming and meta-programming, in both static and dynamic
 217  styles.
 218  .
 219  This package contains pretty printers and a wrapper script for
 220  invoking lldb on rust binaries.
 221
 222 Package: rust-doc
 223 Section: doc
 224 Architecture: all
 225 Build-Profiles: <!nodoc>
 226 Depends: ${misc:Depends},
 227  libjs-jquery, libjs-highlight.js, libjs-mathjax,
 228  fonts-open-sans, fonts-font-awesome
 229 Recommends: cargo-doc
 230 Description: Rust systems programming language - Documentation
 231  Rust is a curly-brace, block-structured expression language.  It
 232  visually resembles the C language family, but differs significantly
 233  in syntactic and semantic details.  Its design is oriented toward
 234  concerns of "programming in the large", that is, of creating and
 235  maintaining boundaries - both abstract and operational - that
 236  preserve large-system integrity, availability and concurrency.
 237  .
 238  It supports a mixture of imperative procedural, concurrent actor,
 239  object-oriented and pure functional styles.  Rust also supports
 240  generic programming and meta-programming, in both static and dynamic
 241  styles.
 242  .
 243  This package contains the Rust tutorial, language reference and
 244  standard library documentation.
 245
 246 Package: rust-src
 247 Architecture: all
 248 Depends: ${misc:Depends}
 249 Description: Rust systems programming language - source code
 250  Rust is a curly-brace, block-structured expression language.  It
 251  visually resembles the C language family, but differs significantly
 252  in syntactic and semantic details.  Its design is oriented toward
 253  concerns of "programming in the large", that is, of creating and
 254  maintaining boundaries - both abstract and operational - that
 255  preserve large-system integrity, availability and concurrency.
 256  .
 257  It supports a mixture of imperative procedural, concurrent actor,
 258  object-oriented and pure functional styles.  Rust also supports
 259  generic programming and meta-programming, in both static and dynamic
 260  styles.
 261  .
 262  This package contains sources of the Rust compiler and standard
 263  libraries, useful for IDEs and code analysis tools such as Racer.
 264
 265 Package: rust-clippy
 266 Architecture: any
 267 Multi-Arch: allowed
 268 Depends: ${misc:Depends}, ${shlibs:Depends},
 269  libstd-rust-1.52 (= ${binary:Version})
 270 Recommends: cargo
 271 Description: Rust linter
 272  Rust is a curly-brace, block-structured expression language.  It
 273  visually resembles the C language family, but differs significantly
 274  in syntactic and semantic details.  Its design is oriented toward
 275  concerns of "programming in the large", that is, of creating and
 276  maintaining boundaries - both abstract and operational - that
 277  preserve large-system integrity, availability and concurrency.
 278  .
 279  It supports a mixture of imperative procedural, concurrent actor,
 280  object-oriented and pure functional styles.  Rust also supports
 281  generic programming and meta-programming, in both static and dynamic
 282  styles.
 283  .
 284  This package contains 'clippy', a linter to catch common mistakes and improve
 285  your Rust code as well a collection of over 400 compatible lints.
 286  .
 287  Lints are divided into categories, each with a default lint level. You can
 288  choose how much Clippy is supposed to annoy help you by changing the lint
 289  level by category.
 290  .
 291  Clippy is integrated into the 'cargo' build tool, available via 'cargo clippy'.
 292
 293 Package: rustfmt
 294 Architecture: any
 295 Multi-Arch: allowed
 296 Depends: ${misc:Depends}, ${shlibs:Depends},
 297 Recommends: cargo
 298 Description: Rust formatting helper
 299  Rust is a curly-brace, block-structured expression language.  It
 300  visually resembles the C language family, but differs significantly
 301  in syntactic and semantic details.  Its design is oriented toward
 302  concerns of "programming in the large", that is, of creating and
 303  maintaining boundaries - both abstract and operational - that
 304  preserve large-system integrity, availability and concurrency.
 305  .
 306  It supports a mixture of imperative procedural, concurrent actor,
 307  object-oriented and pure functional styles.  Rust also supports
 308  generic programming and meta-programming, in both static and dynamic
 309  styles.
 310  .
 311  This package contains 'rustfmt', a tool for formatting Rust code according to
 312  style guidelines, as well as 'cargo-fmt', a helper enabling running rustfmt
 313  directly with 'cargo fmt'.
 314
 315 Package: rust-all
 316 Architecture: all
 317 Depends: ${misc:Depends}, ${shlibs:Depends},
 318  rustc (>= ${binary:Version}),
 319  rustfmt (>= ${binary:Version}),
 320  rust-clippy (>= ${binary:Version}),
 321  rust-gdb (>= ${binary:Version}) | rust-lldb (>= ${binary:Version}),
 322  cargo,
 323 Recommends:
 324  cargo (>= 0.53.0~~), cargo (<< 0.54.0~~)
 325 Suggests:
 326  rust-doc (>= ${binary:Version}),
 327  rust-src (>= ${binary:Version}),
 328  libstd-rust-dev-wasm32 (>= ${binary:Version}),
 329  libstd-rust-dev-windows (>= ${binary:Version}),
 330 Description: Rust systems programming language - all developer tools
 331  Rust is a curly-brace, block-structured expression language.  It
 332  visually resembles the C language family, but differs significantly
 333  in syntactic and semantic details.  Its design is oriented toward
 334  concerns of "programming in the large", that is, of creating and
 335  maintaining boundaries - both abstract and operational - that
 336  preserve large-system integrity, availability and concurrency.
 337  .
 338  It supports a mixture of imperative procedural, concurrent actor,
 339  object-oriented and pure functional styles.  Rust also supports
 340  generic programming and meta-programming, in both static and dynamic
 341  styles.
 342  .
 343  This package is an empty metapackage that depends on all developer tools
 344  in the standard rustc distribution that have been packaged for Debian.