{"id":15225211,"url":"https://github.com/mmottl/ocaml-makefile","last_synced_at":"2025-04-07T06:10:35.122Z","repository":{"id":18350836,"uuid":"21530707","full_name":"mmottl/ocaml-makefile","owner":"mmottl","description":"Easy to use Makefile for small to medium-sized OCaml-projects","archived":false,"fork":false,"pushed_at":"2025-01-19T02:20:25.000Z","size":189,"stargazers_count":77,"open_issues_count":0,"forks_count":19,"subscribers_count":5,"default_branch":"master","last_synced_at":"2025-03-31T05:04:33.669Z","etag":null,"topics":["makefile","ocaml"],"latest_commit_sha":null,"homepage":null,"language":"OCaml","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/mmottl.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE.md","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2014-07-06T00:30:13.000Z","updated_at":"2025-01-30T05:33:03.000Z","dependencies_parsed_at":"2024-12-24T15:11:30.694Z","dependency_job_id":"b6a671fb-24a0-4436-a991-1df33d71d861","html_url":"https://github.com/mmottl/ocaml-makefile","commit_stats":{"total_commits":95,"total_committers":3,"mean_commits":"31.666666666666668","dds":"0.021052631578947323","last_synced_commit":"8f5929173ed6e1a29d8aa5e885ff491656ff1108"},"previous_names":[],"tags_count":16,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mmottl%2Focaml-makefile","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mmottl%2Focaml-makefile/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mmottl%2Focaml-makefile/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mmottl%2Focaml-makefile/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/mmottl","download_url":"https://codeload.github.com/mmottl/ocaml-makefile/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247601448,"owners_count":20964864,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["makefile","ocaml"],"created_at":"2024-09-28T18:05:09.696Z","updated_at":"2025-04-07T06:10:35.099Z","avatar_url":"https://github.com/mmottl.png","language":"OCaml","funding_links":[],"categories":["Package Management"],"sub_categories":[],"readme":"# OCamlMakefile - A Simple Generic Makefile for [OCaml](http://www.ocaml.org)-Projects\n\n## Prerequisites\n\n- GNU-Make version 3.80 or higher\n\n## Pros\n\n- It is well-tested across multiple platforms and has been used in many\n  projects.\n\n- It generates dependencies correctly by ensuring that all automatically\n  generated OCaml-files exist before dependency calculation. This is the\n  only way to guarantee that `ocamldep` can do its job.\n\n- Convenience. Even fairly complex compilation processes (see example\n  `calc.ml`) need only little information to work correctly, sometimes\n  just about the minimum (filenames of sources).\n\n## Cons\n\n- It may not be a good choice in projects where many compilation units\n  require different flags.\n\n- Though it can scale to medium-sized projects, large projects with,\n  for example, dependencies across multiple libraries in different\n  directories are not well-supported.\n\n  This is a general shortcoming of the already somewhat dated `make`.\n  You may want to investigate the following tools to approach larger\n  projects:\n\n  - [dune](https://github.com/ocaml/dune)\n  - [OMake](http://omake.metaprl.org/index.html)\n  - [Ocamlbuild](https://ocaml.org/learn/tutorials/ocamlbuild)\n  - [Oasis](http://oasis.forge.ocamlcore.org)\n\n## Usage\n\nIt is recommended that first-time users take a look at the examples in the\ndistribution for a quick introduction. `OCamlMakefile`-projects are often so\nsimple that they are self-explanatory.\n\nTo create your own project, first edit a project-specific `Makefile` in the\nappropriate directory. There are two ways of making use of `OCamlMakefile`:\n\n1. Have a look at the default settings in `OCamlMakefile` and set\n   them to the values that are valid on your system. For example, check\n   whether the path to the standard libraries is ok, what executables shall\n   be used, etc. Copy it into the directory of the project to be compiled.\n   Add the following statement as last line to your `Makefile`:\n\n   ```makefile\n   -include OCamlMakefile\n   ```\n\n2. Put `OCamlMakefile` somewhere else in your system. In this case you\n   will have to set the variable `OCAMLMAKEFILE` in your project-specific\n   `Makefile`. This is the way in which the examples are written. Now you\n   only need one version of `OCamlMakefile` to manage all of your projects!\n   See the examples for details.\n\nYou will usually need to specify two further variables for your project:\n\n- `SOURCES` (default: `foo.ml`)\n- `RESULT` (default: `foo`)\n\nPut all the sources necessary for a target into variable `SOURCES`. Then set\n`RESULT` to the name of the target. If you want to generate libraries,\nyou should _not_ specify the suffix (`.cma`, `.cmxa`, `.a`). It will be\nadded automatically if you specify that you want to build a library.\n\n```text\n**      Don't forget to add the `.mli`-files, too!            **\n**  Don't forget that the order of the source files matters!  **\n```\n\nThe order is important, because it matters during linking due to potential\nside effects caused at program startup. This is why `OCamlMakefile` does not\nattempt to partially order dependencies by itself, which might confuse users\neven more. It just compiles and links OCaml-sources in the order specified\nby the user, even if it could determine automatically that the order cannot\nbe correct.\n\nThe minimum of your `Makefile` looks like this (assuming that `OCamlMakefile`\nis in the search path of `make`):\n\n```makefile\n-include OCamlMakefile\n```\n\nThis will assume that you want to compile a file `foo.ml` to a binary `foo`.\n\nOtherwise, your Makefile will probably contain something like this:\n\n```makefile\nSOURCES = foo.ml\nRESULT  = foo\n\n-include OCamlMakefile\n```\n\nBe careful with the names you put into these variables. If they are wrong,\na `make clean` might erase the wrong files!\n\nA simple `make` will generate a byte-code executable. If you want to change\nthis, you may add an `all`-rule that generates something else. For example:\n\n```makefile\nSOURCES = foo.ml\nRESULT  = foo\n\nall: native-code-library\n\n-include OCamlMakefile\n```\n\nThis will build a native-code library `foo.cmxa` (+ `foo.a`) from file\n`foo.ml`.\n\nYou may even build several targets at once. To produce byte- and native-code\nexecutables with one `make`, add the following rule:\n\n```makefile\nall: byte-code native-code\n```\n\nYou will probably want to use a different suffix for each of these targets\nso that the result will not be overwritten. See the optional variables\nbelow for details.\n\nYou may also tell `make` at the command-line what kind of target to produce\n(e.g. `make nc`). Here all the possibilities with shortcuts between\nparenthesis:\n\n```text\nbyte-code                      (bc)\nbyte-code-nolink               (bcnl) - no linking stage\nbyte-code-library              (bcl)\nnative-code                    (nc)\nnative-code-nolink             (ncnl) - no linking stage\nnative-code-library            (ncl)\ndebug-code                     (dc)\ndebug-code-nolink              (dcnl) - no linking stage\ndebug-code-library             (dcl)\nprofiling-byte-code            (pbc)\nprofiling-byte-code-library    (pbcl)\nprofiling-native-code          (pnc)\nprofiling-native-code-library  (pncl)\nbyte-code-dll                  (bcd)\nnative-code-dll                (ncd)\npack-byte-code                 (pabc)\npack-native-code               (panc)\ntoplevel                       (top)\nsubprojs\n```\n\nHere is a short note concerning building and linking byte code libraries\nwith C-files:\n\n\u003e OCaml links C-object files only when they are used in an executable.\n\u003e After compilation they should be placed in some directory that is in\n\u003e your include path if you link your library against an executable.\n\u003e\n\u003e It is sometimes more convenient to link all C-object files into a\n\u003e single C-library. Then you have to override the automatic link flags\n\u003e of your library using `-noautolink` and add another link flag that\n\u003e links in your C-library explicitly.\n\nConcerning maintenance:\n\n- `make clean` removes all (all!) automatically generated files.\n  So again, make sure your variables are ok!\n\n- `make cleanup` is similar to `make clean` but keeps executables.\n\nAnother way to destroy some important files is by having `OCamlMakefile`\nautomatically generate files with the same name. Read the documentation about\nthe tools in the OCaml-distribution to see what kind of files are generated.\n`OCamlMakefile` additionally generates (`%` is the basename of source file):\n\n- `%_idl.c` - `camlidl` generates a file `%.c` from `%.idl`, but this is\n  not such a good idea, because when generating native-code, both the\n  file `%.c` and `%.ml` would generate files `%.o` which would overwrite\n  each other. Thus, `OCamlMakefile` renames `%.c` to `%_idl.c` to work\n  around this problem.\n\nThe dependencies are stored in three different subdirectories (dot dirs):\n\n- `._d` - contains dependencies for .ml-files\n- `._bcdi` - contains byte code dependencies for .mli-files\n- `._ncdi` - contains native code dependencies for .mli-files\n\nThe endings of the dependency files are: `%.d` for those generated from\n`%.ml`-files and `%.di` for ones derived from `%.mli`-files.\n\n## Debugging\n\nThis is easy: if you discover a bug, just do a `make clean; make dc` to\nrecompile your project with debugging information. Then you can immediately\napply `ocamldebug` to the executable.\n\n## Profiling\n\nTo generate code that can be profiled with `ocamlprof` (byte code) or `gprof`\n(native code), compile your project with one of the profiling targets (see\ntargets above). E.g.:\n\n- `make pbc` will build byte code that can be profiled with `ocamlprof`.\n- `make pnc` will build native code that can be profiled with `gprof`.\n\nPlease note that it is not currently possible to profile byte code with\nthreads. `OCamlMakefile` will force an error if you try to do this.\n\nA short hint for DEC Alpha-users (under Digital Unix): you may also compile\nyour sources to native code without any further profiling options/targets.\nThen call `pixie my_exec`, `my_exec` being your executable. This will produce\n(among other files) an executable `my_exec.pixie`. Call it and it will produce\nprofiling information which can be analyzed using `prof -pixie my_exec`.\nThe resulting information is extremely detailed and allows analysis up to\nthe clock cycle level...\n\n## Using Preprocessors\n\nBecause any kind of program that reads from standard input and prints to\nstandard output can be used as a preprocessor, there cannot be any default\nway to handle all of them correctly without further knowledge.\n\nTherefore, you have to cooperate a bit with `OCamlMakefile` to let\npreprocessing happen automatically. Basically, this only requires that you\nput a comment into the first line of files that should be preprocessed, e.g.:\n\n```ocaml\n(*pp cat *)\n(* ... rest of program ... *)\n```\n\n`OCamlMakefile` looks at the first line of your files, and if it finds a\ncomment that starts with \"`(*pp`\", then it will assume that the rest of\nthe comment tells it how to correctly call the appropriate preprocessor.\nIn this case the program `cat` will be called, which will, of course, just\noutput the source text again without changing it.\n\nIf, for example, you were an advocate of the \"revised syntax\", which is\nsupported by the `camlp4` preprocessor, you could simply write:\n\n```ocaml\n(*pp camlp4r *)\n(* ... rest of program in revised syntax ... *)\n```\n\nIf you want to write your own syntax extensions, just take a look at the\nexample in the directory `camlp4`: it implements the \"`repeat ... until`\"\nextension as described in the `camlp4`-tutorial.\n\n## Library (Un-)Installation Support\n\n`OCamlMakefile` contains two targets using `ocamlfind` for this purpose:\n\n- `libinstall`\n- `libuninstall`\n\nThese two targets require the existence of the variable `LIBINSTALL_FILES`,\nwhich should be set to all the files that you want to install in the\nlibrary directory (usually %.mli, %.cmi, %.cma, %.cmxa, %.a and possibly\nfurther C-libraries). The target `libinstall` has the dependency `all`\nto force compilation of the library so make sure you define target `all`\nin your Makefile appropriately.\n\nThe targets inform the user about the configured install path and ask for\nconfirmation to (un)install there. If you want to use them, it is often a\ngood idea to just alias them in your Makefile to `install` and `uninstall`\nrespectively.\n\nTwo other targets allow installation of files into a particular directory\n(without using `ocamlfind`):\n\n- `rawinstall`\n- `rawuninstall`\n\n## Building toplevels\n\nThere is just one target for this:\n\n- `top`\n\nThe generated file can be used immediately for interactive sessions - even\nwith scanners, parsers, C-files, etc.!\n\n## Generating documentation\n\nThe following targets are supported:\n\n```text\nhtdoc      - generates HTML-documentation\nladoc      - generates Latex-documentation\npsdoc      - generates PostScript-documentation\npdfdoc     - generates PDF-documentation\ndoc        - generates all supported forms of documentation\nclean-doc  - generates all supported forms of documentation\n```\n\nAll of them generate a sub-directory `doc`. More precisely, for HTML it\nis `doc/$(RESULT)/html` and for Latex, PostScript and PDF the directory\n`doc/$(RESULT)/latex`. See the OCamldoc-manual for details and the optional\nvariables below for settings you can control.\n\n## Handling subprojects\n\nYou can have several targets in the same directory and manage them from\nwithin an single `Makefile`.\n\nGive each subproject a name, e.g. `p1`, `p2`, etc. Then you export settings\nspecific to each project by using variables of the form `PROJ_p1`, `PROJ_p2`,\netc. E.g.:\n\n```makefile\ndefine PROJ_p1\n  SOURCES=foo.ml main.ml\n  RESULT=\"p1\"\n  OCAMLFLAGS=\"-unsafe\"\nendef\nexport PROJ_p1\n\ndefine PROJ_p2\n  ...\nendef\nexport PROJ_p2\n```\n\nYou may also export common settings used by all projects directly, e.g.:\n\n```makefile\nexport THREADS = y\n```\n\nNow is a good time to define which projects should be affected by commands\nby default. E.g.:\n\n```makefile\nifndef SUBPROJS\n  export SUBPROJS = p1 p2\nendif\n```\n\nThis will automatically generate a given target for all those subprojects\nif this variable has not been defined in the shell environment or in the\ncommand line of the make-invocation by the user. E.g., `make dc` will\ngenerate debug code for all subprojects.\n\nNow you need to define a default action for your subprojects if `make`\nhas been called without arguments:\n\n```makefile\nall: bc\n```\n\nThis will build byte code by default for all subprojects.\n\nFinally, you'll have to define a catch-all target that uses the target provided\nby the user for all subprojects. Just add (assuming that OCAMLMAKEFILE has\nbeen defined appropriately):\n\n%:\n@make -f $(OCAMLMAKEFILE) subprojs SUBTARGET=$@\n\nSee the `threads`-directory in the distribution for a short example!\n\n## Optional `OCamlMakefile` variables\n\n```text\n* LIB_PACK_NAME - packs all modules of a library into a module whose\n                  name is given in variable LIB_PACK_NAME.\n\n* RES_CLIB_SUF  - when building a library that contains C-stubs, this\n                  variable controls the suffix appended to the name of\n                  the C-library (default: _stubs).\n\n* THREADS       - say THREADS = yes if you need thread support compiled in,\n                  otherwise leave it away.\n\n* VMTHREADS     - say VMTHREADS = yes if you want to force VM-level\n                  scheduling of threads (byte-code only).\n\n* ANNOTATE      - say ANNOTATE = yes to generate type annotation files\n                  (.annot) to support displaying of type information\n                  in editors.\n\n* USE_CAMLP4    - say USE_CAMLP4 = yes in your Makefile if you\n                  want to include the camlp4 directory during the build\n                  process, otherwise leave it away.\n\n* INCDIRS       - directories that should be searched for .cmi- and\n                  .cmo-files.  You need not write -I ... - just the\n                  plain names.\n* LIBDIRS       - directories that should be searched for libraries\n                  Also just put the plain paths into this variable\n* EXTLIBDIRS    - Same as LIBDIRS, but paths in this variable are\n                  also added to the binary via the -R-flag so that\n                  dynamic libraries in non-standard places can be found.\n* RESULTDEPS    - Targets on which results (executables or libraries)\n                  should additionally depend.\n\n* PACKS         - adds packages under control of findlib.\n\n* PREDS         - specifies findlib-predicates.\n\n* LIBS          - OCaml-libraries that should be linked (just plain names).\n                  E.g. if you want to link the Str-library, just write\n                  str (without quotes).  The new OCaml-compiler handles\n                  libraries in such a way that they \"remember\" whether\n                  they have to be linked against a C-library and it gets\n                  linked in automatically.  If there is a slash in the\n                  library name (such as ./str or lib/foo) then make is\n                  told that the generated files depend on the library.\n                  This helps to ensure that changes to your libraries\n                  are taken into account, which is important if you are\n                  regenerating your libraries frequently.\n\n* CLIBS         - C-libraries that should be linked (just plain names).\n\n* PRE_TARGETS   - set this to a list of target files that you want\n                  to have built before dependency calculation actually\n                  takes place.  E.g. use this to automatically compile\n                  modules needed by camlp4, which have to be available\n                  before other modules can be parsed at all.\n\n                  ** WARNING **: the files mentioned in this variable\n                  will be removed when make clean is executed!\n\n* LIBINSTALL_FILES - the files of a library that should be installed\n                    using findlib.  Default:\n\n                      $(RESULT).mli $(RESULT).cmi $(RESULT).cma\n                      $(RESULT).cmxa $(RESULT).a lib$(RESULT).a\n\n* OCAML_LIB_INSTALL - target directory for rawinstall/rawuninstall.\n                      (default: $(OCAMLLIBPATH)/contrib)\n\n* DOC_FILES     - names of files from which documentation is generated.\n                  (default: all .mli-files in your $(SOURCES)).\n\n* DOC_DIR       - name of directory where documentation should be stored.\n\n* OCAMLFLAGS    - flags passed to the compilers\n* OCAMLBCFLAGS  - flags passed to the byte code compiler only\n* OCAMLNCFLAGS  - flags passed to the native code compiler only\n\n* OCAMLLDFLAGS  - flags passed to the OCaml-linker\n* OCAMLBLDFLAGS - flags passed to the OCaml-linker when linking byte code\n* OCAMLNLDFLAGS - flags passed to the OCaml-linker when linking\n                  native code\n\n* OCAMLMKLIB_FLAGS - flags passed to the OCaml library tool\n\n* OCAMLCPFLAGS  - profiling flags passed to ocamlcp (default: a)\n\n* PPFLAGS       - additional flags passed to the preprocessor\n                  (default: none)\n\n* LFLAGS        - flags passed to ocamllex\n* YFLAGS        - flags passed to ocamlyacc\n* IDLFLAGS      - flags passed to camlidl\n\n* OCAMLDOCFLAGS - flags passed to ocamldoc\n\n* OCAMLFIND_INSTFLAGS - flags passed to ocamlfind during installation\n                        (default: none)\n\n* DVIPSFLAGS    - flags passed to dvips\n                  (when generating documentation in PostScript).\n\n* STATIC        - set this variable if you want to force creation\n                  of static libraries\n\n* CC            - the C-compiler to be used\n* CXX           - the C++-compiler to be used\n\n* CFLAGS        - additional flags passed to the C-compiler.\n\n                  The flag -DNATIVE_CODE will be passed automatically if\n                  you choose to build native code.  This allows you to\n                  compile your C-files conditionally.  But please note:\n                  You should do a make clean or remove the object files\n                  manually or touch the %.c-files: otherwise, they may\n                  not be correctly recompiled between different builds.\n\n* CXXFLAGS      - additional flags passed to the C++-compiler.\n\n* CPPFLAGS      - additional flags passed to the C-preprocessor.\n\n* CFRAMEWORKS   - Objective-C framework to pass to linker on MacOS X.\n\n* LDFLAGS       - additional flags passed to the C-linker\n\n* RPATH_FLAG    - flag passed through to the C-linker to set a path for\n                  dynamic libraries.  May need to be set by user on\n                  exotic platforms.  (default: -R).\n\n* ELF_RPATH_FLAG - this flag is used to set the rpath on ELF-platforms.\n                  (default: -R)\n\n* ELF_RPATH     - if this flag is yes, then the RPATH_FLAG will be\n                  passed by -Wl to the linker as normal on ELF-platforms.\n\n* OCAMLLIBPATH  - path to the OCaml-standard-libraries\n                  (first default: $(OCAMLC) -where)\n                  (second default: /usr/local/lib/ocaml)\n\n* OCAML_DEFAULT_DIRS - additional path in which the user can supply\n                      default directories to his own collection\n                      of libraries.  The idea is to pass this as an\n                      environment variable so that the Makefiles do not\n                      have to contain this path all the time.\n\n* OCAMLFIND     - ocamlfind from findlib       (default: ocamlfind)\n* OCAML         - OCaml interpreter            (default: ocaml)\n* OCAMLC        - byte-code compiler           (default: ocamlc)\n* OCAMLOPT      - native-code compiler         (default: ocamlopt)\n* OCAMLMKTOP    - top-level compiler           (default: ocamlmktop)\n* OCAMLCP       - profiling byte-code compiler (default: ocamlcp)\n* OCAMLDEP      - dependency generator         (default: ocamldep)\n\n* OCAMLLEX      - scanner generator            (default: ocamllex)\n                  Applies to .mll files.\n\n* OCAMLYACC     - parser generator             (default: ocamlyacc)\n                  Applies to .mly files.  A good alternative to the default is\n                  \"menhir\" if installed.\n\n* OCAMLMKLIB    - tool to create libraries     (default: ocamlmklib)\n* CAMLIDL       - IDL-code generator           (default: camlidl)\n* CAMLIDLDLL    - IDL-utility                  (default: camlidldll)\n* CAMLP4        - camlp4 preprocessor          (default: camlp4)\n* OCAMLDOC      - OCamldoc-command             (default: ocamldoc)\n\n* LATEX         - Latex-processor              (default: latex)\n* DVIPS         - dvips-command                (default: dvips)\n* PS2PDF        - PostScript-to-PDF converter  (default: ps2pdf)\n\n* CAMELEON_REPORT - report tool of Cameleon    (default: report)\n* CAMELEON_REPORT_FLAGS - flags for the report tool of Cameleon\n\n* CAMELEON_ZOGGY - zoggy tool of Cameleon\n                  (default: camlp4o pa_zog.cma pr_o.cmo)\n* CAMELEON_ZOGGY_FLAGS - flags for the zoggy tool of Cameleon\n\n* OCAML_GLADECC - Glade compiler for OCaml  (default: lablgladecc2)\n* OCAML_GLADECC_FLAGS - flags for the Glade compiler\n\n* OXRIDL        - OXRIDL-generator  (default: oxridl)\n\n* NOIDLHEADER   - set to yes to prohibit OCamlMakefile from using\n                  the default camlidl-flag -header.\n\n* NO_CUSTOM     - Prevent linking in custom mode.\n\n* QUIET         - unsetting this variable (e.g. make QUIET=)\n                  will print all executed commands, including intermediate\n                  ones.  This allows more comfortable debugging when\n                  things go wrong during a build.\n\n* REALLY_QUIET  - when set this flag turns off output from some commands.\n\n* OCAMLMAKEFILE - location of (= path to) this OCamlMakefile.\n                  Because it calls itself recursively, it has to know\n                  where it is. (default: OCamlMakefile = local directory)\n\n* BCSUFFIX      - Suffix for all byte-code files.  E.g.:\n\n                    RESULT   = foo\n                    BCSUFFIX = _bc\n\n                  This will produce byte-code executables/libraries with\n                  basename foo_bc.\n\n* NCSUFFIX      - Similar to BCSUFFIX, but for native-code files.\n* TOPSUFFIX     - Suffix added to toplevel interpreters (default: .top)\n\n* SUBPROJS      - variable containing the names of subprojects to be\n                  compiled.\n\n* SUBTARGET     - target to be built for all projects in variable\n                  SUBPROJS.\n```\n\n## Optional variables for Windows users\n\n```text\n* MINGW         - variable to detect the MINGW-environment\n* MSVC          - variable to detect the MSVC-compiler\n```\n\n## Contact Information and Contributing\n\nPlease submit bugs reports, feature requests, contributions and similar to\nthe [GitHub issue tracker](https://github.com/mmottl/ocaml-makefile/issues).\n\nUp-to-date information is available at: \u003chttps://mmottl.github.io/ocaml-makefile\u003e\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmmottl%2Focaml-makefile","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmmottl%2Focaml-makefile","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmmottl%2Focaml-makefile/lists"}