commit ba8b6022112a88cccb993ec304163bec272bd4a5 · pyrox.dev/nixpkgs

+231

doc/languages-frameworks/factor.section.md

···

       1
       1
       +
       # Factor {#sec-language-factor}

     

       2
       2
       +
       

     

       3
       3
       +
       ## Development Environment {#ssec-factor-dev-env}

     

       4
       4
       +
       

     

       5
       5
       +
       All Nix expressions for the Factor compiler and development environment can be found in `pkgs/top-level/factor-packages.nix`.

     

       6
       6
       +
       

     

       7
       7
       +
       The default package `factor-lang` provides support for the built-in graphical user interface and a selected set of C library bindings, e.g., for sound and TLS connections.

     

       8
       8
       +
       It also comes with the Fuel library for Emacs that provides an integrated development environment for developing Factor programs including access to the Factor runtime and online documentation.

     

       9
       9
       +
       

     

       10
       10
       +
       For using less frequently used libraries that need additional bindings, you can override the `factor-lang` package and add more library bindings and/or binaries to its PATH.

     

       11
       11
       +
       The package is defined in `pkgs/development/compilers/factor-lang/wrapper.nix` and provides several attributes for adding those:

     

       12
       12
       +
       

     

       13
       13
       +
       - `extraLibs` adds the packages' `/lib` paths to the wrapper and adds all shared libraries to an ld.so cache such that they can be found dynamically by the Factor runtime.

     

       14
       14
       +
       - `binPackages` does the same as `extraLibs` and additionally adds the packages to Factor's PATH environment variable.

     

       15
       15
       +
       - `extraVocabs` adds Factor vocabularies to the tree that are not part of the standard library.

     

       16
       16
       +
         The packages must adhere to the default vocabulary root structure to be found.

     

       17
       17
       +
       - `guiSupport` draws in all necessary graphical libraries to enable the Factor GUI.

     

       18
       18
       +
         This should be set to `true` when considering building and running graphical applications with this Factor runtime (even if the Factor GUI is not used for programming).

     

       19
       19
       +
         This argument is `true` by default.

     

       20
       20
       +
       - `enableDefaults` can be deactivated to only wrap libraries that are named in `extraLibs` or `binPackages`.

     

       21
       21
       +
         This reduces the runtime dependencies especially when shipping Factor applications.

     

       22
       22
       +
       

     

       23
       23
       +
       The package also passes through several attributes listing the wrapped libraries and binaries, namely, `extraLibs` and `binPackages` as well as `defaultLibs` and `defaultBins`.

     

       24
       24
       +
       Additionally, all `runtimeLibs` is the concatenation of all the above for the purpose of providing all necessary dynamic libraries as "`propagatedBuildInputs`".

     

       25
       25
       +
       

     

       26
       26
       +
       `factorPackages` provides pre-configured Factor packages:

     

       27
       27
       +
       - `factorPackages.factor-lang` is the default package with GUI support and several default library bindings (e.g. openssl, openal etc.).

     

       28
       28
       +
       - `factorPackages.factor-no-gui` turns off GUI support while maintaining default library bindings.

     

       29
       29
       +
       - `factorPackages.factor-minimal` comes with practically no additional library bindings and binaries and no GUI support.

     

       30
       30
       +
       - `factorPackages.factor-minimal-gui` comes with no additional library bindings but includes GUI support.

     

       31
       31
       +
       

     

       32
       32
       +
       ### Scaffolding and the `work` vocabulary root {#ssec-factor-scaffolding}

     

       33
       33
       +
       

     

       34
       34
       +
       Factor uses the concept of "scaffolding" to spin off a new vocabulary in a personal workspace rooted at the `work` vocabulary root.

     

       35
       35
       +
       This concept does not scale very well, because it makes many assumptions which all turn out to be wrong at some point.

     

       36
       36
       +
       In the current implementation, the `work` vocabulary root points to `/var/lib/factor` on the target machine.

     

       37
       37
       +
       This can be suitable for a single-user system.

     

       38
       38
       +
       Create the location and make it writable to your user.

     

       39
       39
       +
       Then, you can use the `scaffold-work` word as instructed by many tutorials.

     

       40
       40
       +
       

     

       41
       41
       +
       If you don't like this approach, you can work around it by creating a `~/.factor-roots` file in your home directory which contains the locations you desire to represent additional Factor vocabulary roots, one directory per line.

     

       42
       42
       +
       Use `scaffold-vocab` to create your vocabularies in one of these additional roots.

     

       43
       43
       +
       The online Factor documentation is extensive on how to use the scaffolding framework.

     

       44
       44
       +
       

     

       45
       45
       +
       ## Packaging Factor Vocabularies {#ssec-factor-packaging}

     

       46
       46
       +
       

     

       47
       47
       +
       All Factor vocabularies that shall be added to a Factor environment via the `extraVocabs` attribute must adhere to the following directory scheme.

     

       48
       48
       +
       Its top-level directory must be one (or multiple) of `basis`, `core` or `extra`.

     

       49
       49
       +
       `work` is routed to `/var/lib/factor` and is not shipped nor referenced in the nix store, see the section on [scaffolding](#ssec-factor-scaffolding).

     

       50
       50
       +
       You should usually use `extra`, but you can use the other roots to overwrite built-in vocabularies.

     

       51
       51
       +
       Be aware that vocabularies in `core` are part of the Factor image which the development environment is run from.

     

       52
       52
       +
       This means the code in those vocabularies is not loaded from the sources, such that you need to call `refresh-all` to re-compile and load the changed definitions.

     

       53
       53
       +
       In these instances, it is advised to override the `factor-unwrapped` package directly, which compiles and packages the core Factor libraries into the default Factor

     

       54
       54
       +
       image.

     

       55
       55
       +
       

     

       56
       56
       +
       As per Factor convention, your vocabulary `foo.factor` must be in a directory of the same name in addition to one of the previously mentioned vocabulary roots, e.g. `extra/foo/foo.factor`.

     

       57
       57
       +
       

     

       58
       58
       +
       All extra Factor vocabularies are registered in `pkgs/top-level/factor-packages.nix` and their package definitions usually live in `development/compilers/factor-lang/vocabs/`.

     

       59
       59
       +
       

     

       60
       60
       +
       Package a vocabulary using the `buildFactorVocab` function.

     

       61
       61
       +
       Its default `installPhase` takes care of installing it under `out/lib/factor`.

     

       62
       62
       +
       It also understands the following special attributes:

     

       63
       63
       +
       - `vocabName` is the path to the vocabulary to be installed.

     

       64
       64
       +
         Defaults to `pname`.

     

       65
       65
       +
       - `vocabRoot` is the vocabulary root to install the vocabulary under.

     

       66
       66
       +
         Defaults to `extra`.

     

       67
       67
       +
         Unless you know what you are doing, do not change it.

     

       68
       68
       +
         Other readily understood vocabulary roots are `core` and `base`, which allow you to modify the default Factor runtime environment with an external package.

     

       69
       69
       +
       - `extraLibs`, `extraVocabs`, `extraPaths` have the same meaning as for [applications](#ssec-factor-applications).

     

       70
       70
       +
         They have no immediate effect and are just passed through.

     

       71
       71
       +
         When building factor-lang packages and Factor applications that use this respective vocabulary, these variables are evaluated and their paths added to the runtime environment.

     

       72
       72
       +
       

     

       73
       73
       +
       The function understands several forms of source directory trees:

     

       74
       74
       +
       1. Simple single-vocab projects with their Factor and supplementary files directly in the project root.

     

       75
       75
       +
          All `.factor` and `.txt` files are copied to `out/lib/factor/<vocabRoot>/<vocabName>`.

     

       76
       76
       +
       2. More complex projects with several vocabularies next to each other, e.g. `./<vocabName>` and `./<otherVocab>`.

     

       77
       77
       +
          All directories except `bin`, `doc` and `lib` are copied to `out/lib/factor/<vocabRoot>`.

     

       78
       78
       +
       3. Even more complex projects that touch multiple vocabulary roots.

     

       79
       79
       +
          Vocabularies must reside under `lib/factor/<root>/<vocab>` with the name-giving vocabulary being in `lib/factor/<vocabRoot>/<vocabName>`.

     

       80
       80
       +
          All directories in `lib/factor` are copied to `out/`.

     

       81
       81
       +
       

     

       82
       82
       +
       For instance, packaging the Bresenham algorithm for line interpolation looks like this, see `pkgs/development/compilers/factor-lang/vocabs/bresenham` for the complete file:

     

       83
       83
       +
       ```nix

     

       84
       84
       +
       {

     

       85
       85
       +
         factorPackages,

     

       86
       86
       +
         fetchFromGitHub,

     

       87
       87
       +
       }:

     

       88
       88
       +
       

     

       89
       89
       +
       factorPackages.buildFactorVocab {

     

       90
       90
       +
         pname = "bresenham";

     

       91
       91
       +
         version = "dev";

     

       92
       92
       +
       

     

       93
       93
       +
         src = fetchFromGitHub {

     

       94
       94
       +
           owner = "Capital-EX";

     

       95
       95
       +
           repo = "bresenham";

     

       96
       96
       +
           rev = "58d76b31a17f547e19597a09d02d46a742bf6808";

     

       97
       97
       +
           hash = "sha256-cfQOlB877sofxo29ahlRHVpN3wYTUc/rFr9CJ89dsME=";

     

       98
       98
       +
         };

     

       99
       99
       +
       }

     

       100
       100
       +
       ```

     

       101
       101
       +
       

     

       102
       102
       +
       The vocabulary goes to `lib/factor/extra`, extra files, like licenses etc. would go to `share/` as usual and could be added to the output via a `postInstall` phase.

     

       103
       103
       +
       In case the vocabulary binds to a shared library or calls a binary that needs to be present in the runtime environment of its users, add `extraPaths` and `extraLibs` attributes respectively.

     

       104
       104
       +
       They are then picked up by the `buildFactorApplication` function and added as runtime dependencies.

     

       105
       105
       +
       

     

       106
       106
       +
       ## Building Applications {#ssec-factor-applications}

     

       107
       107
       +
       

     

       108
       108
       +
       Factor applications are built using Factor's `deploy` facility with the help of the `buildFactorApplication` function.

     

       109
       109
       +
       

     

       110
       110
       +
       ### `buildFactorApplication` function {#ssec-factor-buildFactorApplication-func}

     

       111
       111
       +
       

     

       112
       112
       +
       `factorPackages.buildFactorApplication` *`buildDesc`*

     

       113
       113
       +
       

     

       114
       114
       +
       When packaging a Factor application with [`buildFactorApplication`](#ssec-factor-buildFactorApplication-func), its [`override`](#sec-pkg-override) interface should contain the `factorPackages` argument.

     

       115
       115
       +
       For example:

     

       116
       116
       +
       ```nix

     

       117
       117
       +
       {

     

       118
       118
       +
         lib,

     

       119
       119
       +
         fetchurl,

     

       120
       120
       +
         factorPackages,

     

       121
       121
       +
       }:

     

       122
       122
       +
       

     

       123
       123
       +
       factorPackages.buildFactorApplication (finalAttrs: {

     

       124
       124
       +
         pname = "foo";

     

       125
       125
       +
         version = "1.0";

     

       126
       126
       +
       

     

       127
       127
       +
         src = fetchurl {

     

       128
       128
       +
           url = "https://some-forge.org/foo-${finalAttrs.version}.tar.gz"

     

       129
       129
       +
         };

     

       130
       130
       +
       })

     

       131
       131
       +
       ```

     

       132
       132
       +
       

     

       133
       133
       +
       The `buildFactorApplication` function expects the following source structure for a package `foo-1.0` and produces a `/bin/foo` application:

     

       134
       134
       +
       ```

     

       135
       135
       +
       foo-1.0/

     

       136
       136
       +
         foo/

     

       137
       137
       +
           foo.factor

     

       138
       138
       +
           deploy.factor

     

       139
       139
       +
         <more files and directories>...

     

       140
       140
       +
       ```

     

       141
       141
       +
       

     

       142
       142
       +
       It provides the additional attributes `vocabName` and `binName` to cope with naming deviations.

     

       143
       143
       +
       The `deploy.factor` file controls how the application is deployed and is documented in the Factor online documentation on the `deploy` facility.

     

       144
       144
       +
       

     

       145
       145
       +
       Use the `preInstall` or `postInstall` hooks to copy additional files and directories to `out/`.

     

       146
       146
       +
       The function itself only builds the application in `/lib/factor/` and a wrapper in `/bin/`.

     

       147
       147
       +
       

     

       148
       148
       +
       A more complex example shows how to specify runtime dependencies and additional Factor vocabularies at the example of the `painter` Factor application:

     

       149
       149
       +
       ```nix

     

       150
       150
       +
       {

     

       151
       151
       +
         lib,

     

       152
       152
       +
         fetchFromGitHub,

     

       153
       153
       +
         factorPackages,

     

       154
       154
       +
         curl,

     

       155
       155
       +
       }:

     

       156
       156
       +
       

     

       157
       157
       +
       factorPackages.buildFactorApplication (finalAttrs: {

     

       158
       158
       +
         pname = "painter";

     

       159
       159
       +
         version = "1";

     

       160
       160
       +
       

     

       161
       161
       +
         factor-lang = factorPackages.factor-minimal-gui;

     

       162
       162
       +
       

     

       163
       163
       +
         src = fetchFromGitHub {

     

       164
       164
       +
           name = finalAttrs.vocabName;

     

       165
       165
       +
           owner = "Capital-EX";

     

       166
       166
       +
           repo = "painter";

     

       167
       167
       +
           rev = "365797be8c4f82440bec0ad0a50f5a858a06c1b6";

     

       168
       168
       +
           hash = "sha256-VdvnvKNGcFAtjWVDoxyYgRSyyyy0BEZ2MZGQ71O8nUI=";

     

       169
       169
       +
         };

     

       170
       170
       +
       

     

       171
       171
       +
         sourceRoot = ".";

     

       172
       172
       +
       

     

       173
       173
       +
         enableUI = true;

     

       174
       174
       +
         extraVocabs = [ factorPackages.bresenham ];

     

       175
       175
       +
       

     

       176
       176
       +
         extraPaths = with finalAttrs.factor-lang; binPackages ++ defaultBins ++ [ curl ];

     

       177
       177
       +
       

     

       178
       178
       +
       })

     

       179
       179
       +
       ```

     

       180
       180
       +
       

     

       181
       181
       +
       The use of the `src.name` and`sourceRoot` attributes conveniently establish the necessary `painter` vocabulary directory that is needed for the deployment to work.

     

       182
       182
       +
       

     

       183
       183
       +
       It requires the packager to specify the full set of binaries to be made available at runtime.

     

       184
       184
       +
       This enables the standard pattern for application packages to specify all runtime dependencies explicitly without the Factor runtime interfering.

     

       185
       185
       +
       

     

       186
       186
       +
       `buildFactorApplication` is a wrapper around `stdenv.mkDerivation` and takes all of its attributes.

     

       187
       187
       +
       Additional attributes that are understood by `buildFactorApplication`:

     

       188
       188
       +
       

     

       189
       189
       +
       *`buildDesc`* (Function or attribute set)

     

       190
       190
       +
       

     

       191
       191
       +
       : A build description similar to `stdenv.mkDerivation` with the following attributes:

     

       192
       192
       +
       

     

       193
       193
       +
         `vocabName` (String; _optional_)

     

       194
       194
       +
       

     

       195
       195
       +
         : is the path to the vocabulary to be deployed relative to the source root.

     

       196
       196
       +
           So, directory `foo/` from the example above could be `extra/deep/down/foo`.

     

       197
       197
       +
           This allows you to maintain Factor's vocabulary hierarchy and distribute the same source tree as a stand-alone application and as a library in the Factor development environment via the `extraVocabs` attribute.

     

       198
       198
       +
       

     

       199
       199
       +
         `binName` (String; _optional_)

     

       200
       200
       +
       

     

       201
       201
       +
         : is the name of the resulting binary in `/bin/`.

     

       202
       202
       +
           It defaults to the last directory component in `vocabName`.

     

       203
       203
       +
           It is also added as the `meta.mainProgram` attribute to facilitate `nix run`.

     

       204
       204
       +
       

     

       205
       205
       +
         `enableUI` (Boolean; _optional_)

     

       206
       206
       +
       

     

       207
       207
       +
         : is `false` by default.

     

       208
       208
       +
           Set this to `true` when you ship a graphical application.

     

       209
       209
       +
       

     

       210
       210
       +
         `extraLibs` (List; _optional_)

     

       211
       211
       +
       

     

       212
       212
       +
         : adds additional libraries as runtime dependencies.

     

       213
       213
       +
           Defaults to `[]` and is concatenated with `runtimeLibs` from the used factor-lang package.

     

       214
       214
       +
           Use `factor-minimal` to minimize the closure of runtime libraries.

     

       215
       215
       +
       

     

       216
       216
       +
         `extraPaths` (List; _optional_)

     

       217
       217
       +
       

     

       218
       218
       +
         : adds additional binaries to the runtime PATH environment variable (without adding their libraries, as well).

     

       219
       219
       +
           Defaults to `[]` and is concatenated with `defaultBins` and `binPackages` from the used factor-lang package.

     

       220
       220
       +
           Use `factor-minimal` to minimize the closure of runtime libraries.

     

       221
       221
       +
       

     

       222
       222
       +
         `deployScriptText` (String; _optional_)

     

       223
       223
       +
       

     

       224
       224
       +
         : is the actual deploy Factor file that is executed to deploy the application.

     

       225
       225
       +
           You can change it if you need to perform additional computation during deployment.

     

       226
       226
       +
       

     

       227
       227
       +
         `factor-lang` (Package; _optional_)

     

       228
       228
       +
       

     

       229
       229
       +
         : overrides the Factor package to use to deploy this application, which also affects the default library bindings and programs in the runtime PATH.

     

       230
       230
       +
           It defaults to `factor-lang` when `enableUI` is turned on and `factor-no-gui` when it is turned off.

     

       231
       231
       +
           Applications that use only Factor libraries without external bindings or programs may set this to `factor-minimal` or `factor-minimal-gui`.

doc/languages-frameworks/index.md

···

       67
       67
        
       dlang.section.md

     

       68
       68
        
       dotnet.section.md

     

       69
       69
        
       emscripten.section.md

     

       70
       70
       +
       factor.section.md

     

       70
       71
        
       gnome.section.md

     

       71
       72
        
       go.section.md

     

       72
       73
        
       gradle.section.md

+18

doc/redirects.json

···

       2754
       2754
        
         "declarative-debugging": [

     

       2755
       2755
        
           "index.html#declarative-debugging"

     

       2756
       2756
        
         ],

     

       2757
       2757
       +
         "sec-language-factor": [

     

       2758
       2758
       +
           "index.html#sec-language-factor"

     

       2759
       2759
       +
         ],

     

       2760
       2760
       +
         "ssec-factor-scaffolding": [

     

       2761
       2761
       +
           "index.html#ssec-factor-scaffolding"

     

       2762
       2762
       +
         ],

     

       2763
       2763
       +
         "ssec-factor-packaging": [

     

       2764
       2764
       +
           "index.html#ssec-factor-packaging"

     

       2765
       2765
       +
         ],

     

       2766
       2766
       +
         "ssec-factor-buildFactorApplication-func": [

     

       2767
       2767
       +
           "index.html#ssec-factor-buildFactorApplication-func"

     

       2768
       2768
       +
         ],

     

       2769
       2769
       +
         "ssec-factor-dev-env": [

     

       2770
       2770
       +
           "index.html#ssec-factor-dev-env"

     

       2771
       2771
       +
         ],

     

       2772
       2772
       +
         "ssec-factor-applications": [

     

       2773
       2773
       +
           "index.html#ssec-factor-applications"

     

       2774
       2774
       +
         ],

     

       2757
       2775
        
         "sec-language-gnome": [

     

       2758
       2776
        
           "index.html#sec-language-gnome"

     

       2759
       2777
        
         ],

doc/release-notes/rl-2505.section.md

···

       18
       18
        
       - LLVM has been updated from LLVM 16 (on Darwin) and LLVM 18 (on other platforms) to LLVM 19.

     

       19
       19
        
         This introduces some backwards‐incompatible changes; see the [upstream release notes](https://releases.llvm.org/) for details.

     

       20
       20
        
       

     

       21
       21
       +
       - The Factor programming language packages were reworked. `factor-lang-scope` is now named `factorPackages` and provides a `buildFactorApplication` function to deploy Factor programs as binaries. It has also received proper documentation in the Nixpkgs manual.

     

       22
       22
       +
       

     

       21
       23
        
       - Emacs has been updated to 30.1.

     

       22
       24
        
         This introduces some backwards‐incompatible changes; see the NEWS for details.

     

       23
       25
        
         NEWS can been viewed from Emacs by typing `C-h n`, or by clicking `Help->Emacs News` from the menu bar.

+17 -16

pkgs/development/compilers/factor-lang/adjust-paths-in-unit-tests.patch

···

       1
       1
       -
       From da8a4b9c1094a568f443c525ca1ce11f686be1bc Mon Sep 17 00:00:00 2001

     

       2
       2
       -
       From: timor <timor.dd@googlemail.com>

     

       3
       3
       -
       Date: Thu, 8 Aug 2019 14:13:09 +0200

     

       4
       4
       -
       Subject: [PATCH] adjust unit test for finding executables in path for NixOS

     

       5
       5
       -
       

     

       6
       6
       -
       ---

     

       7
       7
       -
        basis/io/standard-paths/unix/unix-tests.factor | 4 ++--

     

       8
       8
       -
        1 file changed, 2 insertions(+), 2 deletions(-)

     

       9
       9
       -
       

     

       10
       10
       -
       diff --git a/basis/io/standard-paths/unix/unix-tests.factor b/basis/io/standard-paths/unix/unix-tests.factor

     

       11
       11
       -
       index acd5029..870537f 100644

     

       12
       12
       -
       --- a/basis/io/standard-paths/unix/unix-tests.factor

     

       13
       13
       -
       +++ b/basis/io/standard-paths/unix/unix-tests.factor

     

       14
       14
       -
       @@ -5,13 +5,13 @@ sequences tools.test ;

     

       15
       15
       -
       

     

       1
       1
       +
       diff -ur factor.orig/basis/io/standard-paths/unix/unix-tests.factor factor/basis/io/standard-paths/unix/unix-tests.factor

     

       2
       2
       +
       --- factor.orig/basis/io/standard-paths/unix/unix-tests.factor	2024-02-09 14:38:33.932439180 +0100

     

       3
       3
       +
       +++ factor/basis/io/standard-paths/unix/unix-tests.factor	2024-02-09 15:41:18.529141569 +0100

     

       4
       4
       +
       @@ -1,21 +1,21 @@

     

       5
       5
       +
        ! Copyright (C) 2011 Doug Coleman.

     

       6
       6
       +
        ! See https://factorcode.org/license.txt for BSD license.

     

       7
       7
       +
        USING: environment io.standard-paths io.standard-paths.unix

     

       8
       8
       +
       -sequences tools.test ;

     

       9
       9
       +
       +kernel sequences tools.test ;

     

       10
       10
       +
        

     

       16
       11
        
        { f } [ "" find-in-path ] unit-test

     

       17
       12
        
        { t } [

     

       18
       13
        
       -    "ls" find-in-path { "/bin/ls" "/usr/bin/ls" } member?

     

       19
       14
        
       +    "ls" find-in-path not not

     

       20
       15
        
        ] unit-test

     

       21
       21
       -
       

     

       16
       16
       +
        

     

       22
       17
        
        { t } [

     

       23
       18
        
            "/sbin:" "PATH" os-env append "PATH" [

     

       24
       19
        
                "ps" find-in-path

     
···

       26
       21
        
       +        not not

     

       27
       22
        
            ] with-os-env

     

       28
       23
        
        ] unit-test

     

       24
       24
       +
        

     

       25
       25
       +
        { t } [

     

       26
       26
       +
            "ls" find-in-standard-login-path 

     

       27
       27
       +
       -    { "/bin/ls" "/usr/bin/ls" } member?

     

       28
       28
       +
       +    not not

     

       29
       29
       +
        ] unit-test

+27

pkgs/development/compilers/factor-lang/ld.so.cache-from-env.patch

···

       1
       1
       +
       diff -ur factor.orig/basis/alien/libraries/finder/linux/linux.factor factor/basis/alien/libraries/finder/linux/linux.factor

     

       2
       2
       +
       --- factor.orig/basis/alien/libraries/finder/linux/linux.factor	2024-02-09 14:38:33.966439078 +0100

     

       3
       3
       +
       +++ factor/basis/alien/libraries/finder/linux/linux.factor	2024-02-09 14:41:16.775938179 +0100

     

       4
       4
       +
       @@ -2,7 +2,7 @@

     

       5
       5
       +
        ! See https://factorcode.org/license.txt for BSD license

     

       6
       6
       +
        USING: accessors alien.libraries.finder arrays assocs

     

       7
       7
       +
        combinators.short-circuit environment io io.encodings.utf8

     

       8
       8
       +
       -io.launcher kernel make sequences sets splitting system

     

       9
       9
       +
       +io.files io.launcher kernel make sequences sets splitting system

     

       10
       10
       +
        unicode ;

     

       11
       11
       +
        IN: alien.libraries.finder.linux

     

       12
       12
       +
        

     

       13
       13
       +
       @@ -25,8 +25,12 @@

     

       14
       14
       +
            ] map ;

     

       15
       15
       +
        

     

       16
       16
       +
        : load-ldconfig-cache ( -- seq )

     

       17
       17
       +
       -    "/sbin/ldconfig -p" utf8 [ read-lines ] with-process-reader*

     

       18
       18
       +
       -    2drop [ f ] [ rest parse-ldconfig-lines ] if-empty ;

     

       19
       19
       +
       +    "FACTOR_LD_SO_CACHE" os-env [

     

       20
       20
       +
       +        utf8 [ read-lines ] with-file-reader

     

       21
       21
       +
       +    ] [

     

       22
       22
       +
       +        { } clone

     

       23
       23
       +
       +    ] if*

     

       24
       24
       +
       +    [ f ] [ rest parse-ldconfig-lines ] if-empty ;

     

       25
       25
       +
        

     

       26
       26
       +
        : ldconfig-arch ( -- str )

     

       27
       27
       +
            mach-map cpu of { "libc6" } or ;

+141

pkgs/development/compilers/factor-lang/mk-factor-application.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         stdenv,

     

       3
       3
       +
         lib,

     

       4
       4
       +
         writeText,

     

       5
       5
       +
         makeWrapper,

     

       6
       6
       +
         factor-lang,

     

       7
       7
       +
         factor-no-gui,

     

       8
       8
       +
         librsvg,

     

       9
       9
       +
         gdk-pixbuf,

     

       10
       10
       +
       }@initAttrs:

     

       11
       11
       +
       

     

       12
       12
       +
       drvArgs:

     

       13
       13
       +
       

     

       14
       14
       +
       let

     

       15
       15
       +
         flang = factor-lang; # workaround to satisfy nixf-tidy

     

       16
       16
       +
       in

     

       17
       17
       +
       (stdenv.mkDerivation drvArgs).overrideAttrs (

     

       18
       18
       +
         finalAttrs:

     

       19
       19
       +
         {

     

       20
       20
       +
           name ? "${finalAttrs.pname}-${finalAttrs.version}",

     

       21
       21
       +
           factor-lang ? if enableUI then flang else factor-no-gui,

     

       22
       22
       +
           enableUI ? false,

     

       23
       23
       +
           # Allow overriding the path to the deployed vocabulary name.  A

     

       24
       24
       +
           # $vocabName.factor file must exist!

     

       25
       25
       +
           vocabName ? finalAttrs.pname or name,

     

       26
       26
       +
           # Allow overriding the binary name

     

       27
       27
       +
           binName ? lib.last (lib.splitString "/" vocabName),

     

       28
       28
       +
           # Extra libraries needed

     

       29
       29
       +
           extraLibs ? [ ],

     

       30
       30
       +
           # Extra binaries in PATH

     

       31
       31
       +
           extraPaths ? [ ],

     

       32
       32
       +
           # Extra vocabularies needed by this application

     

       33
       33
       +
           extraVocabs ? [ ],

     

       34
       34
       +
           deployScriptText ? ''

     

       35
       35
       +
             USING: command-line io io.backend io.pathnames kernel namespaces sequences

     

       36
       36
       +
             tools.deploy tools.deploy.config tools.deploy.backend vocabs.loader ;

     

       37
       37
       +
       

     

       38
       38
       +
             IN: deploy-me

     

       39
       39
       +
       

     

       40
       40
       +
             : load-and-deploy ( path/vocab -- )

     

       41
       41
       +
                 normalize-path [

     

       42
       42
       +
                     parent-directory add-vocab-root

     

       43
       43
       +
                 ] [

     

       44
       44
       +
                     file-name dup reload deploy

     

       45
       45
       +
                 ] bi ;

     

       46
       46
       +
       

     

       47
       47
       +
             : deploy-vocab ( path/vocab path/target -- )

     

       48
       48
       +
                 normalize-path deploy-directory set

     

       49
       49
       +
                 f open-directory-after-deploy? set

     

       50
       50
       +
                 load-and-deploy ;

     

       51
       51
       +
       

     

       52
       52
       +
             : deploy-me ( -- )

     

       53
       53
       +
                 command-line get dup length 2 = [

     

       54
       54
       +
                     first2 deploy-vocab

     

       55
       55
       +
                 ] [

     

       56
       56
       +
                     drop

     

       57
       57
       +
                     "usage: deploy-me <PATH-TO-VOCAB> <TARGET-DIR>" print

     

       58
       58
       +
                     nl

     

       59
       59
       +
                 ] if ;

     

       60
       60
       +
       

     

       61
       61
       +
             MAIN: deploy-me

     

       62
       62
       +
           '',

     

       63
       63
       +
           ...

     

       64
       64
       +
         }@attrs:

     

       65
       65
       +
         let

     

       66
       66
       +
           deployScript = writeText "deploy-me.factor" finalAttrs.deployScriptText;

     

       67
       67
       +
           wrapped-factor = finalAttrs.factor-lang.override {

     

       68
       68
       +
             inherit (finalAttrs) extraLibs extraVocabs;

     

       69
       69
       +
             doInstallCheck = false;

     

       70
       70
       +
           };

     

       71
       71
       +
           runtimePaths = with finalAttrs.wrapped-factor; defaultBins ++ binPackages ++ finalAttrs.extraPaths;

     

       72
       72
       +
         in

     

       73
       73
       +
         {

     

       74
       74
       +
           inherit

     

       75
       75
       +
             enableUI

     

       76
       76
       +
             vocabName

     

       77
       77
       +
             deployScriptText

     

       78
       78
       +
             extraLibs

     

       79
       79
       +
             extraPaths

     

       80
       80
       +
             extraVocabs

     

       81
       81
       +
             binName

     

       82
       82
       +
             factor-lang

     

       83
       83
       +
             wrapped-factor

     

       84
       84
       +
             ;

     

       85
       85
       +
           nativeBuildInputs = [

     

       86
       86
       +
             makeWrapper

     

       87
       87
       +
             (lib.hiPrio finalAttrs.wrapped-factor)

     

       88
       88
       +
           ] ++ attrs.nativeBuildInputs or [ ];

     

       89
       89
       +
       

     

       90
       90
       +
           buildInputs = (lib.optional enableUI gdk-pixbuf) ++ attrs.buildInputs or [ ];

     

       91
       91
       +
       

     

       92
       92
       +
           buildPhase =

     

       93
       93
       +
             attrs.buildPhase or ''

     

       94
       94
       +
               runHook preBuild

     

       95
       95
       +
               vocabBaseName=$(basename "$vocabName")

     

       96
       96
       +
               mkdir -p "$out/lib/factor" "$TMPDIR/.cache"

     

       97
       97
       +
               export XDG_CACHE_HOME="$TMPDIR/.cache"

     

       98
       98
       +
       

     

       99
       99
       +
               factor "${deployScript}" "./$vocabName" "$out/lib/factor"

     

       100
       100
       +
               cp "$TMPDIR/factor-temp"/*.image "$out/lib/factor/$vocabBaseName"

     

       101
       101
       +
               runHook postBuild

     

       102
       102
       +
             '';

     

       103
       103
       +
       

     

       104
       104
       +
           __structuredAttrs = true;

     

       105
       105
       +
       

     

       106
       106
       +
           installPhase =

     

       107
       107
       +
             attrs.installPhase or (

     

       108
       108
       +
               ''

     

       109
       109
       +
                 runHook preInstall

     

       110
       110
       +
               ''

     

       111
       111
       +
               + (lib.optionalString finalAttrs.enableUI ''

     

       112
       112
       +
                 # Set Gdk pixbuf loaders file to the one from the build dependencies here

     

       113
       113
       +
                 unset GDK_PIXBUF_MODULE_FILE

     

       114
       114
       +
                 # Defined in gdk-pixbuf setup hook

     

       115
       115
       +
                 findGdkPixbufLoaders "${librsvg}"

     

       116
       116
       +
                 appendToVar makeWrapperArgs --set GDK_PIXBUF_MODULE_FILE "$GDK_PIXBUF_MODULE_FILE"

     

       117
       117
       +
                 appendToVar makeWrapperArgs --prefix LD_LIBRARY_PATH : /run/opengl-driver/lib

     

       118
       118
       +
               '')

     

       119
       119
       +
               + (lib.optionalString (wrapped-factor.runtimeLibs != [ ])) ''

     

       120
       120
       +
                 appendToVar makeWrapperArgs --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath wrapped-factor.runtimeLibs}"

     

       121
       121
       +
               ''

     

       122
       122
       +
               + ''

     

       123
       123
       +
                 mkdir -p "$out/bin"

     

       124
       124
       +
                 makeWrapper "$out/lib/factor/$vocabBaseName/$vocabBaseName" \

     

       125
       125
       +
                   "$out/bin/$binName" \

     

       126
       126
       +
                   --prefix PATH : "${lib.makeBinPath runtimePaths}" \

     

       127
       127
       +
                   "''${makeWrapperArgs[@]}"

     

       128
       128
       +
                 runHook postInstall

     

       129
       129
       +
               ''

     

       130
       130
       +
             );

     

       131
       131
       +
       

     

       132
       132
       +
           passthru = {

     

       133
       133
       +
             vocab = finalAttrs.src;

     

       134
       134
       +
           } // attrs.passthru or { };

     

       135
       135
       +
       

     

       136
       136
       +
           meta = {

     

       137
       137
       +
             platforms = wrapped-factor.meta.platforms;

     

       138
       138
       +
             mainProgram = finalAttrs.binName;

     

       139
       139
       +
           } // attrs.meta or { };

     

       140
       140
       +
         }

     

       141
       141
       +
       )

+59

pkgs/development/compilers/factor-lang/mk-vocab.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         stdenv,

     

       3
       3
       +
       }@initAttrs:

     

       4
       4
       +
       

     

       5
       5
       +
       drvArgs:

     

       6
       6
       +
       

     

       7
       7
       +
       (stdenv.mkDerivation drvArgs).overrideAttrs (

     

       8
       8
       +
         finalAttrs:

     

       9
       9
       +
         {

     

       10
       10
       +
           name ? "${finalAttrs.pname}-${finalAttrs.version}",

     

       11
       11
       +
           vocabName ? finalAttrs.pname or name,

     

       12
       12
       +
           vocabRoot ? "extra",

     

       13
       13
       +
           # Runtime libraries needed to run this vocab, handed to runtime wrapper

     

       14
       14
       +
           extraLibs ? [ ],

     

       15
       15
       +
           # Extra vocabularies, handed to runtime wrapper

     

       16
       16
       +
           extraVocabs ? [ ],

     

       17
       17
       +
           # Extra binaries in PATH, handed to runtime wrapper

     

       18
       18
       +
           extraPaths ? [ ],

     

       19
       19
       +
           ...

     

       20
       20
       +
         }@attrs:

     

       21
       21
       +
         {

     

       22
       22
       +
           inherit vocabName vocabRoot;

     

       23
       23
       +
           installPhase =

     

       24
       24
       +
             # Default installer

     

       25
       25
       +
             # 1. If lib/factor/<vocabRoot>/<vocabName> exists, copy all vocab roots

     

       26
       26
       +
             #    under lib/factor/* to out/.

     

       27
       27
       +
             # 2. If <vocabName> exists, copy all directories next to <vocabName> to

     

       28
       28
       +
             #    out/.

     

       29
       29
       +
             # These two carry over package-defined vocabs that the name-giving vocab

     

       30
       30
       +
             # depends on.

     

       31
       31
       +
             # 3. Otherwise, copy all .factor and .txt files to out/.  For simple

     

       32
       32
       +
             #    single-vocab packages.

     

       33
       33
       +
             attrs.installPhase or ''

     

       34
       34
       +
               runHook preInstall

     

       35
       35
       +
               mkdir -p "$out/lib/factor/${finalAttrs.vocabRoot}/${finalAttrs.vocabName}"

     

       36
       36
       +
               if [ -d "lib/factor/${finalAttrs.vocabRoot}/${finalAttrs.vocabName}" ]; then

     

       37
       37
       +
                   find lib/factor -mindepth 1 -maxdepth 1 -type d -exec \

     

       38
       38
       +
                       cp -r -t "$out/lib/factor" {} \+

     

       39
       39
       +
               elif [ -d "${finalAttrs.vocabName}" ]; then

     

       40
       40
       +
                   fname="${finalAttrs.vocabName}"

     

       41
       41
       +
                   base=$(basename "${finalAttrs.vocabName}")

     

       42
       42
       +
                   root=''${fname%$base}

     

       43
       43
       +
                   root=''${root:-.}

     

       44
       44
       +
                   find "$root" -mindepth 1 -maxdepth 1 -type -d \

     

       45
       45
       +
                       -not \( -name bin -or -name doc -or -name lib \) -exec \

     

       46
       46
       +
                       cp -r -t "$out/lib/factor/${finalAttrs.vocabRoot}" {} \+

     

       47
       47
       +
               else

     

       48
       48
       +
                   cp *.factor *.txt "$out/lib/factor/${finalAttrs.vocabRoot}/${finalAttrs.vocabName}"

     

       49
       49
       +
               fi

     

       50
       50
       +
               runHook postInstall

     

       51
       51
       +
             '';

     

       52
       52
       +
       

     

       53
       53
       +
           passthru = {

     

       54
       54
       +
             inherit extraLibs extraVocabs extraPaths;

     

       55
       55
       +
           };

     

       56
       56
       +
       

     

       57
       57
       +
           meta = attrs.meta or { };

     

       58
       58
       +
         }

     

       59
       59
       +
       )

-24

pkgs/development/compilers/factor-lang/scope.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         lib,

     

       3
       3
       -
         pkgs,

     

       4
       4
       -
         overrides ? (self: super: { }),

     

       5
       5
       -
       }:

     

       6
       6
       -
       

     

       7
       7
       -
       let

     

       8
       8
       -
         inside = (

     

       9
       9
       -
           self:

     

       10
       10
       -
           let

     

       11
       11
       -
             callPackage = pkgs.newScope self;

     

       12
       12
       -
           in

     

       13
       13
       -
           {

     

       14
       14
       -
             interpreter = callPackage ./factor99.nix { inherit (pkgs) stdenv; };

     

       15
       15
       -
       

     

       16
       16
       -
             # Convenience access for using the returned attribute the same way as the

     

       17
       17
       -
             # interpreter derivation. Takes a list of runtime libraries as its only

     

       18
       18
       -
             # argument.

     

       19
       19
       -
             inherit (self.interpreter) withLibs;

     

       20
       20
       -
           }

     

       21
       21
       -
         );

     

       22
       22
       -
         extensible-self = lib.makeExtensible (lib.extends overrides inside);

     

       23
       23
       -
       in

     

       24
       24
       -
       extensible-self

+110

pkgs/development/compilers/factor-lang/unwrapped.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         stdenv,

     

       4
       4
       +
         fetchurl,

     

       5
       5
       +
         makeWrapper,

     

       6
       6
       +
         curl,

     

       7
       7
       +
         git,

     

       8
       8
       +
         ncurses,

     

       9
       9
       +
         tzdata,

     

       10
       10
       +
         unzip,

     

       11
       11
       +
       }:

     

       12
       12
       +
       

     

       13
       13
       +
       stdenv.mkDerivation (finalAttrs: {

     

       14
       14
       +
         pname = "factor-lang";

     

       15
       15
       +
         version = "0.99";

     

       16
       16
       +
       

     

       17
       17
       +
         src = fetchurl {

     

       18
       18
       +
           url = "https://downloads.factorcode.org/releases/${finalAttrs.version}/factor-src-${finalAttrs.version}.zip";

     

       19
       19
       +
           sha256 = "f5626bb3119bd77de9ac3392fdbe188bffc26557fab3ea34f7ca21e372a8443e";

     

       20
       20
       +
         };

     

       21
       21
       +
       

     

       22
       22
       +
         patches = [

     

       23
       23
       +
           # Use full path to image while bootstrapping

     

       24
       24
       +
           ./staging-command-line-0.99-pre.patch

     

       25
       25
       +
           # Point work vocabulary root to a writable location

     

       26
       26
       +
           ./workdir-0.99-pre.patch

     

       27
       27
       +
           # Patch hard-coded FHS paths

     

       28
       28
       +
           ./adjust-paths-in-unit-tests.patch

     

       29
       29
       +
           # Avoid using /sbin/ldconfig

     

       30
       30
       +
           ./ld.so.cache-from-env.patch

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         nativeBuildInputs = [

     

       34
       34
       +
           git

     

       35
       35
       +
           makeWrapper

     

       36
       36
       +
           curl

     

       37
       37
       +
           unzip

     

       38
       38
       +
         ];

     

       39
       39
       +
       

     

       40
       40
       +
         postPatch = ''

     

       41
       41
       +
           sed -ie '4i GIT_LABEL = heads/master-'$(< git-id) GNUmakefile

     

       42
       42
       +
           # Some other hard-coded paths to fix:

     

       43
       43
       +
           substituteInPlace extra/tzinfo/tzinfo.factor \

     

       44
       44
       +
             --replace-fail '/usr/share/zoneinfo' '${tzdata}/share/zoneinfo'

     

       45
       45
       +
       

     

       46
       46
       +
           substituteInPlace extra/terminfo/terminfo.factor \

     

       47
       47
       +
             --replace-fail '/usr/share/terminfo' '${ncurses.out}/share/terminfo'

     

       48
       48
       +
       

     

       49
       49
       +
           # update default paths in fuel-listener.el for fuel mode

     

       50
       50
       +
           substituteInPlace misc/fuel/fuel-listener.el \

     

       51
       51
       +
             --replace-fail '(defcustom fuel-factor-root-dir nil' "(defcustom fuel-factor-root-dir \"$out/lib/factor\""

     

       52
       52
       +
         '';

     

       53
       53
       +
       

     

       54
       54
       +
         dontConfigure = true;

     

       55
       55
       +
       

     

       56
       56
       +
         preBuild = ''

     

       57
       57
       +
           patchShebangs ./build.sh

     

       58
       58
       +
           # Factor uses XDG_CACHE_HOME for cache during compilation.

     

       59
       59
       +
           # We can't have that. So, set it to $TMPDIR/.cache

     

       60
       60
       +
           export XDG_CACHE_HOME=$TMPDIR/.cache

     

       61
       61
       +
           mkdir -p $XDG_CACHE_HOME

     

       62
       62
       +
         '';

     

       63
       63
       +
       

     

       64
       64
       +
         makeTarget = "linux-x86-64";

     

       65
       65
       +
       

     

       66
       66
       +
         postBuild = ''

     

       67
       67
       +
           printf "First build from upstream boot image\n" >&2

     

       68
       68
       +
           ./build.sh bootstrap

     

       69
       69
       +
           printf "Rebuild boot image\n" >&2

     

       70
       70
       +
           ./factor -script -e='"unix-x86.64" USING: system bootstrap.image memory ; make-image save 0 exit'

     

       71
       71
       +
           printf "Second build from local boot image\n" >&2

     

       72
       72
       +
           ./build.sh bootstrap

     

       73
       73
       +
         '';

     

       74
       74
       +
       

     

       75
       75
       +
         installPhase = ''

     

       76
       76
       +
           runHook preInstall

     

       77
       77
       +
           mkdir -p $out/lib/factor $out/share/emacs/site-lisp

     

       78
       78
       +
           cp -r factor factor.image libfactor.a libfactor-ffi-test.so \

     

       79
       79
       +
               boot.*.image LICENSE.txt README.md basis core extra misc \

     

       80
       80
       +
               $out/lib/factor

     

       81
       81
       +
       

     

       82
       82
       +
           # install fuel mode for emacs

     

       83
       83
       +
           ln -r -s $out/lib/factor/misc/fuel/*.el $out/share/emacs/site-lisp

     

       84
       84
       +
           runHook postInstall

     

       85
       85
       +
         '';

     

       86
       86
       +
       

     

       87
       87
       +
         meta = with lib; {

     

       88
       88
       +
           homepage = "https://factorcode.org/";

     

       89
       89
       +
           description = "A concatenative, stack-based programming language";

     

       90
       90
       +
           longDescription = ''

     

       91
       91
       +
             The Factor programming language is a concatenative, stack-based

     

       92
       92
       +
             programming language with high-level features including dynamic types,

     

       93
       93
       +
             extensible syntax, macros, and garbage collection. On a practical side,

     

       94
       94
       +
             Factor has a full-featured library, supports many different platforms, and

     

       95
       95
       +
             has been extensively documented.

     

       96
       96
       +
       

     

       97
       97
       +
             The implementation is fully compiled for performance, while still

     

       98
       98
       +
             supporting interactive development. Factor applications are portable

     

       99
       99
       +
             between all common platforms. Factor can deploy stand-alone applications

     

       100
       100
       +
             on all platforms. Full source code for the Factor project is available

     

       101
       101
       +
             under a BSD license.

     

       102
       102
       +
           '';

     

       103
       103
       +
           license = licenses.bsd2;

     

       104
       104
       +
           maintainers = with maintainers; [

     

       105
       105
       +
             vrthra

     

       106
       106
       +
             spacefrogg

     

       107
       107
       +
           ];

     

       108
       108
       +
           platforms = [ "x86_64-linux" ];

     

       109
       109
       +
         };

     

       110
       110
       +
       })

+183

pkgs/development/compilers/factor-lang/wrapper.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         stdenv,

     

       4
       4
       +
         makeWrapper,

     

       5
       5
       +
         buildEnv,

     

       6
       6
       +
         factor-unwrapped,

     

       7
       7
       +
         cairo,

     

       8
       8
       +
         freealut,

     

       9
       9
       +
         gdk-pixbuf,

     

       10
       10
       +
         glib,

     

       11
       11
       +
         gnome2,

     

       12
       12
       +
         gtk2-x11,

     

       13
       13
       +
         libGL,

     

       14
       14
       +
         libGLU,

     

       15
       15
       +
         librsvg,

     

       16
       16
       +
         graphviz,

     

       17
       17
       +
         libogg,

     

       18
       18
       +
         libvorbis,

     

       19
       19
       +
         openal,

     

       20
       20
       +
         openssl,

     

       21
       21
       +
         pango,

     

       22
       22
       +
         pcre,

     

       23
       23
       +
         udis86,

     

       24
       24
       +
         zlib,

     

       25
       25
       +
         # Enable factor GUI support

     

       26
       26
       +
         guiSupport ? true,

     

       27
       27
       +
         # Libraries added to ld.so.cache

     

       28
       28
       +
         extraLibs ? [ ],

     

       29
       29
       +
         # Packages added to path (and ld.so.cache)

     

       30
       30
       +
         binPackages ? [ ],

     

       31
       31
       +
         # Extra vocabularies added to out/lib/factor

     

       32
       32
       +
         extraVocabs ? [ ],

     

       33
       33
       +
         # Enable default libs and bins to run most of the standard library code.

     

       34
       34
       +
         enableDefaults ? true,

     

       35
       35
       +
         doInstallCheck ? true,

     

       36
       36
       +
       }:

     

       37
       37
       +
       let

     

       38
       38
       +
         inherit (lib) optional optionals optionalString;

     

       39
       39
       +
         # missing from lib/strings

     

       40
       40
       +
         escapeNixString = s: lib.escape [ "$" ] (builtins.toJSON s);

     

       41
       41
       +
         toFactorArgs = x: lib.concatStringsSep " " (map escapeNixString x);

     

       42
       42
       +
         defaultLibs = optionals enableDefaults [

     

       43
       43
       +
           libogg

     

       44
       44
       +
           libvorbis

     

       45
       45
       +
           openal

     

       46
       46
       +
           openssl

     

       47
       47
       +
           pcre

     

       48
       48
       +
           udis86

     

       49
       49
       +
           zlib

     

       50
       50
       +
         ];

     

       51
       51
       +
         defaultBins = optionals enableDefaults [ graphviz ];

     

       52
       52
       +
         runtimeLibs =

     

       53
       53
       +
           defaultLibs

     

       54
       54
       +
           ++ extraLibs

     

       55
       55
       +
           ++ binPackages

     

       56
       56
       +
           ++ (lib.flatten (map (v: v.extraLibs or [ ]) extraVocabs))

     

       57
       57
       +
           ++ optionals guiSupport [

     

       58
       58
       +
             cairo

     

       59
       59
       +
             freealut

     

       60
       60
       +
             gdk-pixbuf

     

       61
       61
       +
             glib

     

       62
       62
       +
             gnome2.gtkglext

     

       63
       63
       +
             gtk2-x11

     

       64
       64
       +
             libGL

     

       65
       65
       +
             libGLU

     

       66
       66
       +
             pango

     

       67
       67
       +
           ];

     

       68
       68
       +
         bins = binPackages ++ defaultBins ++ (lib.flatten (map (v: v.extraPaths or [ ]) extraVocabs));

     

       69
       69
       +
         vocabTree = buildEnv {

     

       70
       70
       +
           name = "${factor-unwrapped.pname}-vocabs";

     

       71
       71
       +
           ignoreCollisions = true;

     

       72
       72
       +
           pathsToLink = map (r: "/lib/factor/${r}") [

     

       73
       73
       +
             "basis"

     

       74
       74
       +
             "core"

     

       75
       75
       +
             "extra"

     

       76
       76
       +
           ];

     

       77
       77
       +
           paths = [ factor-unwrapped ] ++ extraVocabs;

     

       78
       78
       +
         };

     

       79
       79
       +
       

     

       80
       80
       +
       in

     

       81
       81
       +
       stdenv.mkDerivation (finalAttrs: {

     

       82
       82
       +
         pname = "${factor-unwrapped.pname}-env";

     

       83
       83
       +
         inherit (factor-unwrapped) version;

     

       84
       84
       +
       

     

       85
       85
       +
         nativeBuildInputs = [ makeWrapper ];

     

       86
       86
       +
         buildInputs = optional guiSupport gdk-pixbuf;

     

       87
       87
       +
       

     

       88
       88
       +
         dontUnpack = true;

     

       89
       89
       +
       

     

       90
       90
       +
         installPhase =

     

       91
       91
       +
           ''

     

       92
       92
       +
             runHook preInstall

     

       93
       93
       +
           ''

     

       94
       94
       +
           + optionalString guiSupport ''

     

       95
       95
       +
             # Set Gdk pixbuf loaders file to the one from the build dependencies here

     

       96
       96
       +
             unset GDK_PIXBUF_MODULE_FILE

     

       97
       97
       +
             # Defined in gdk-pixbuf setup hook

     

       98
       98
       +
             findGdkPixbufLoaders "${librsvg}"

     

       99
       99
       +
             makeWrapperArgs+=(--set GDK_PIXBUF_MODULE_FILE "$GDK_PIXBUF_MODULE_FILE")

     

       100
       100
       +
           ''

     

       101
       101
       +
           + ''

     

       102
       102
       +
             makeWrapperArgs+=(

     

       103
       103
       +
               --prefix LD_LIBRARY_PATH : /run/opengl-driver/lib:${lib.makeLibraryPath runtimeLibs}

     

       104
       104
       +
               --prefix PATH : ${lib.makeBinPath bins})

     

       105
       105
       +
             mkdir -p "$out/bin" "$out/share"

     

       106
       106
       +
             cp -r "${factor-unwrapped}/lib" "$out/"

     

       107
       107
       +
             cp -r "${factor-unwrapped}/share/emacs" "$out/share/"

     

       108
       108
       +
             chmod -R u+w "$out/lib" "$out/share"

     

       109
       109
       +
             (

     

       110
       110
       +
                 cd ${vocabTree}

     

       111
       111
       +
                 for f in "lib/factor/"* ; do

     

       112
       112
       +
                     rm -r "$out/$f"

     

       113
       113
       +
                     ln -s "${vocabTree}/$f" "$out/$f"

     

       114
       114
       +
                 done

     

       115
       115
       +
             )

     

       116
       116
       +
       

     

       117
       117
       +
             # There is no ld.so.cache in NixOS so we construct one

     

       118
       118
       +
             # out of known libraries. The side effect is that find-lib

     

       119
       119
       +
             # will work only on the known libraries. There does not seem

     

       120
       120
       +
             # to be a generic solution here.

     

       121
       121
       +
             find $(echo ${

     

       122
       122
       +
               lib.makeLibraryPath ([ stdenv.cc.libc ] ++ runtimeLibs)

     

       123
       123
       +
             } | sed -e 's#:# #g') -name \*.so.\* > $TMPDIR/so.lst

     

       124
       124
       +
             (echo $(cat $TMPDIR/so.lst | wc -l) "libs found in cache \`/etc/ld.so.cache'";

     

       125
       125
       +
               for l in $(<$TMPDIR/so.lst); do

     

       126
       126
       +
                 echo " $(basename $l) (libc6,x86-64) => $l";

     

       127
       127
       +
               done)> $out/lib/factor/ld.so.cache

     

       128
       128
       +
       

     

       129
       129
       +
             # Create a wrapper in bin/ and lib/factor/

     

       130
       130
       +
             wrapProgram "$out/lib/factor/factor" \

     

       131
       131
       +
               --argv0 factor \

     

       132
       132
       +
               --set FACTOR_LD_SO_CACHE "$out/lib/factor/ld.so.cache" \

     

       133
       133
       +
               "''${makeWrapperArgs[@]}"

     

       134
       134
       +
             mv $out/lib/factor/factor.image $out/lib/factor/.factor-wrapped.image

     

       135
       135
       +
             cp $out/lib/factor/factor $out/bin/

     

       136
       136
       +
       

     

       137
       137
       +
             # Emacs fuel expects the image being named `factor.image` in the factor base dir

     

       138
       138
       +
             ln -rs $out/lib/factor/.factor-wrapped.image $out/lib/factor/factor.image

     

       139
       139
       +
       

     

       140
       140
       +
             # Update default paths in fuel-listener.el to new output

     

       141
       141
       +
             sed -E -i -e 's#(\(defcustom fuel-factor-root-dir ").*(")#'"\1$out/lib/factor\2#" \

     

       142
       142
       +
                 "$out/share/emacs/site-lisp/fuel-listener.el"

     

       143
       143
       +
             runHook postInstall

     

       144
       144
       +
           '';

     

       145
       145
       +
       

     

       146
       146
       +
         inherit doInstallCheck;

     

       147
       147
       +
         disabledTests = toFactorArgs [

     

       148
       148
       +
           "io.files.info.unix"

     

       149
       149
       +
           "io.launcher.unix"

     

       150
       150
       +
           "io.ports"

     

       151
       151
       +
           "io.sockets"

     

       152
       152
       +
           "io.sockets.unix"

     

       153
       153
       +
           "io.sockets.secure.openssl"

     

       154
       154
       +
           "io.sockets.secure.unix"

     

       155
       155
       +
         ];

     

       156
       156
       +
         installCheckPhase = ''

     

       157
       157
       +
           runHook preCheck

     

       158
       158
       +
           export HOME=$TMPDIR

     

       159
       159
       +
           $out/bin/factor -e='USING: tools.test tools.test.private

     

       160
       160
       +
             zealot.factor sequences namespaces formatting ;

     

       161
       161
       +
             zealot-core-vocabs

     

       162
       162
       +
             { ${finalAttrs.disabledTests} } without

     

       163
       163
       +
             "compiler" suffix

     

       164
       164
       +
             [ test-vocab ] each :test-failures

     

       165
       165
       +
             test-failures get length "Number of failed tests: %d\n" printf'

     

       166
       166
       +
           runHook postCheck

     

       167
       167
       +
         '';

     

       168
       168
       +
       

     

       169
       169
       +
         passthru = {

     

       170
       170
       +
           inherit

     

       171
       171
       +
             defaultLibs

     

       172
       172
       +
             defaultBins

     

       173
       173
       +
             extraLibs

     

       174
       174
       +
             runtimeLibs

     

       175
       175
       +
             binPackages

     

       176
       176
       +
             extraVocabs

     

       177
       177
       +
             ;

     

       178
       178
       +
         };

     

       179
       179
       +
       

     

       180
       180
       +
         meta = factor-unwrapped.meta // {

     

       181
       181
       +
           mainProgram = "factor";

     

       182
       182
       +
         };

     

       183
       183
       +
       })

+26

pkgs/development/factor-vocabs/bresenham/default.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         factorPackages,

     

       4
       4
       +
         fetchFromGitHub,

     

       5
       5
       +
         curl,

     

       6
       6
       +
         gnutls,

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       factorPackages.buildFactorVocab {

     

       10
       10
       +
         pname = "bresenham";

     

       11
       11
       +
         version = "dev";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchFromGitHub {

     

       14
       14
       +
           owner = "Capital-EX";

     

       15
       15
       +
           repo = "bresenham";

     

       16
       16
       +
           rev = "58d76b31a17f547e19597a09d02d46a742bf6808";

     

       17
       17
       +
           hash = "sha256-cfQOlB877sofxo29ahlRHVpN3wYTUc/rFr9CJ89dsME=";

     

       18
       18
       +
         };

     

       19
       19
       +
       

     

       20
       20
       +
         meta = {

     

       21
       21
       +
           description = "Bresenham's line interpolation algorithm";

     

       22
       22
       +
           homepage = "https://github.com/Capital-EX/bresenham";

     

       23
       23
       +
           license = lib.licenses.bsd2;

     

       24
       24
       +
           maintainers = with lib.maintainers; [ spacefrogg ];

     

       25
       25
       +
         };

     

       26
       26
       +
       }

pkgs/top-level/aliases.nix

···

       582
       582
        
       

     

       583
       583
        
         ### F ###

     

       584
       584
        
       

     

       585
       585
       +
         factor-lang-scope = throw "'factor-lang-scope' has been renamed to 'factorPackages'"; # added 2024-11-28

     

       585
       586
        
         fahcontrol = throw "fahcontrol has been removed because the download is no longer available"; # added 2024-09-24

     

       586
       587
        
         fahviewer = throw "fahviewer has been removed because the download is no longer available"; # added 2024-09-24

     

       587
       588
        
         fam = throw "'fam' (aliased to 'gamin') has been removed as it is unmaintained upstream"; # Added 2024-04-19

+2 -2

pkgs/top-level/all-packages.nix

···

       9280
       9280
        
           inherit (darwin.apple_sdk.frameworks) Carbon OpenGL;

     

       9281
       9281
        
         };

     

       9282
       9282
        
       

     

       9283
       9283
       -
         factor-lang-scope = callPackage ../development/compilers/factor-lang/scope.nix { };

     

       9284
       9284
       -
         factor-lang = factor-lang-scope.interpreter;

     

       9283
       9283
       +
         factorPackages = callPackage ./factor-packages.nix { };

     

       9284
       9284
       +
         factor-lang = factorPackages.factor-lang;

     

       9285
       9285
        
       

     

       9286
       9286
        
         far2l = callPackage ../applications/misc/far2l {

     

       9287
       9287
        
           inherit (darwin.apple_sdk.frameworks)

+43

pkgs/top-level/factor-packages.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         pkgs,

     

       4
       4
       +
         overrides ? (self: super: { }),

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       let

     

       8
       8
       +
         inside =

     

       9
       9
       +
           self:

     

       10
       10
       +
           let

     

       11
       11
       +
             callPackage = pkgs.newScope self;

     

       12
       12
       +
           in

     

       13
       13
       +
           lib.recurseIntoAttrs {

     

       14
       14
       +
       

     

       15
       15
       +
             buildFactorApplication =

     

       16
       16
       +
               callPackage ../development/compilers/factor-lang/mk-factor-application.nix

     

       17
       17
       +
                 { };

     

       18
       18
       +
             buildFactorVocab = callPackage ../development/compilers/factor-lang/mk-vocab.nix { };

     

       19
       19
       +
       

     

       20
       20
       +
             factor-unwrapped = callPackage ../development/compilers/factor-lang/unwrapped.nix { };

     

       21
       21
       +
       

     

       22
       22
       +
             factor-lang = callPackage ../development/compilers/factor-lang/wrapper.nix { };

     

       23
       23
       +
             factor-no-gui = callPackage ../development/compilers/factor-lang/wrapper.nix {

     

       24
       24
       +
               guiSupport = false;

     

       25
       25
       +
             };

     

       26
       26
       +
             factor-minimal = callPackage ../development/compilers/factor-lang/wrapper.nix {

     

       27
       27
       +
               enableDefaults = false;

     

       28
       28
       +
               guiSupport = false;

     

       29
       29
       +
             };

     

       30
       30
       +
             factor-minimal-gui = callPackage ../development/compilers/factor-lang/wrapper.nix {

     

       31
       31
       +
               enableDefaults = false;

     

       32
       32
       +
             };

     

       33
       33
       +
       

     

       34
       34
       +
             # Vocabularies

     

       35
       35
       +
             bresenham = callPackage ../development/factor-vocabs/bresenham { };

     

       36
       36
       +
       

     

       37
       37
       +
           }

     

       38
       38
       +
           // lib.optionalAttrs pkgs.config.allowAliases {

     

       39
       39
       +
             interpreter = builtins.throw "factorPackages now offers various wrapped factor runtimes (see documentation) and the buildFactorApplication helper.";

     

       40
       40
       +
           };

     

       41
       41
       +
         extensible-self = lib.makeExtensible (lib.extends overrides inside);

     

       42
       42
       +
       in

     

       43
       43
       +
       extensible-self