Introduce new website with docs with docusaurus

website/.gitignore

@@ -0,0 +1,21 @@
+# Dependencies
+/node_modules
+
+# Production
+/build
+
+# Generated
+.docusaurus
+.cache-loader
+package-lock.json
+
+# Misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

website/README.md

@@ -0,0 +1,26 @@
+# Premake website
+
+Premake website is built using [Docusaurus 2](https://v2.docusaurus.io/), a modern static website generator.
+
+## Installation
+
+```
+npm install
+```
+
+## Local Development
+
+```
+npm start
+```
+
+This command starts a local development server and open up a browser window. Most changes are reflected live without having to restart the server.
+
+## Build
+
+```
+npm run-script build
+```
+
+This command generates static content into the `build` directory and can be served using any static contents hosting service.
+

website/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: [require.resolve('@docusaurus/core/lib/babel/preset')],
+};

website/docs/Building-Premake.md

@@ -0,0 +1,85 @@
+---
+title: Building Premake
+---
+
+
+If you downloaded a prebuilt binary package you can skip this page, which discusses how to build the Premake source code. Jump ahead to one of the next sections to learn how to develop with Premake.
+
+## Using a Source Code Package ##
+
+If you have one of the [official source code packages](http://premake.github.io/download.html), you'll find that project files for a variety of toolsets have already been generated for you in the `build/` folder. Find the right set for your platform and toolset and build as you normally would  (i.e. run `make`). The resulting binaries will be placed in the top-level `bin/` folder.
+
+Skip ahead to the next section to learn more about using the source version of Premake.
+
+
+## Using the Git Code Repository ##
+
+If you are planning to make changes or contribute to Premake, working directly against the source code repository is the way to go. Premake 5's source code is housed [right here on GitHub](https://github.com/premake/premake-core). To get the source code, see the "Clone" options in the sidebar to the right and follow the instructions there.
+
+Once the core source code has been cloned, you can bootstrap your first Premake executable:
+
+```bash
+nmake -f Bootstrap.mak windows   # for Windows
+make -f Bootstrap.mak osx        # for Mac OS X
+make -f Bootstrap.mak linux      # Linux and similar Posix systems
+```
+
+If your system or toolset is not fully supported by the bootstrap Makefile, you will need to create new project files using an existing version of Premake, however on Windows you can optionally specify the version of Visual Studio to use for the bootstrap using the MSDEV macro. To successfully compile on Windows with Visual C++ you must run `vcvars32.bat` first. If you don't have Visual C++ as part of your environment variables then you need to use the full path `C:\Program Files (x86)\Microsoft Visual Studio <version>\VC\bin\vcvars32.bat`. It might be easier to create a batch file with the following contents or copy the contents in appveyor.yml.
+
+```bash
+call "%VS140COMNTOOLS%\..\..\VC\vcvarsall.bat" # Sets up the necessary environment variables for nmake to run
+nmake -f Bootstrap.mak MSDEV=vs2015 windows    # For Windows with Visual Studio 2015.
+```
+
+On other platforms, if the bootstrap fails to build, you will need to have a working Premake executable on your system. The easiest way to get one is by [downloading prebuilt binary package](http://premake.github.io/download.html). If a binary is not available for your system, or if you would prefer to build one yourself, grab the latest source code package from that same site and follow the steps in **Using a Source Code Package**, above.
+
+Once you have a working Premake available, you can generate the project files for your toolset by running a command like the following in the top-level Premake directory:
+
+```bash
+premake5 gmake  # for makefiles
+premake5 vs2012 # for a Visual Studio 2012 solution
+premake --help  # to see a list of supported toolsets
+```
+
+If this is the first time you have built Premake, or if you have made changes to the Lua scripts, you should prepare them to be embedded into the Premake executable.
+
+```
+premake5 embed
+```
+
+This creates a C file (at src/host/scripts.c) which contains all of the Lua scripts as static string buffers. These then get compiled into the executable, which is how we get away with shipping a single file instead of a whole bunch of scripts.
+
+You should now have a workspace/solution/makefile in the top-level folder, which you can go ahead and build. The resulting binaries will placed into the **bin/** folder.
+
+
+## Running the Tests ##
+
+Once you have built an executable, you can verify it by running Premake's unit test suites. From the top-level Premake folder, run:
+
+```bash
+bin/debug/premake5 test    # or...
+bin/release/premake5 test
+```
+
+## Runtime Script Loading ##
+
+If you are modifying or extending Premake, you can skip the embedding and compilation steps and run the scripts directly from the disk. This removes the build from the change-build-test cycle and really speeds up development.
+
+If you are running Premake from the top of its own source tree (where its  premake5.lua is located) you will get this behavior automatically. If you are running Premake from some other location, use the --scripts option to provide the path to that top-level folder:
+
+```
+bin/release/premake5 --scripts=../path/to/premake test
+```
+
+If you find yourself doing this repeatedly, or if you want Premake to be able to find other, custom scripts, you can also set a search path with the PREMAKE_PATH environment variable. Set it just like you would set your system PATH variable.
+
+Once your changes are complete and you are ready to distribute them to others, embed them into the executable and rebuild:
+
+```bash
+bin/release/premake5 embed
+make config=release   # or via Visual Studio, etc.
+```
+
+## Stuck? ##
+
+Give us a shout over in [the Developer Forums](https://groups.google.com/forum/#!forum/premake-development) and we'll be glad to help you out.

website/docs/Getting-Help.md

@@ -0,0 +1,13 @@
+---
+title: Getting Help
+---
+
+For questions about **using Premake** and **authoring project scripts,** please [ask on StackOverflow, adding the #premake tag to your question](http://stackoverflow.com/questions/tagged/premake). More people (including the Premake developers) will be able to see and respond to your questions, and you will have the opportunity to reward the best answers.
+
+For discussions about **developing, customizing, or extending Premake and add-on modules**, please use the [Premake Developers Google Groups forum](https://groups.google.com/forum/#!forum/premake-development).
+
+If you found a bug or would like to request a feature, you can open a ticket in [the issue tracker on GitHub](https://github.com/premake/premake-core/issues) (for Premake 5.x; the Premake 4.x issue tracker is [over here](https://github.com/premake/premake-4.x/issues)).
+
+### Frequently Asked Questions ###
+
+* [How do I reuse configuration settings between different projects?](Sharing-Configuration-Settings.md)

website/docs/Getting-Premake.md

@@ -0,0 +1,7 @@
+---
+title: Getting Premake
+---
+
+Visit [the Downloads page](http://premake.github.io/download.html) for the latest pre-built binary and source packages. Or, clone the premake-core Git repository right here on GitHub: find the "Clone" option in the sidebar to the right and follow the instructions there, then see [Building Premake](Building-Premake.md) to learn how to create binaries for your system.
+
+Premake 5.0 is still in very active development, and we haven't yet reached the point of making official releases yet (though we're getting close). There will absolutely be bugs and [missing functionality](Feature-Matrix.md) right now. Please help us by [reporting issues you find](https://github.com/premake/premake-core/issues) so we can get them fixed before the final release.

website/docs/Home.md

@@ -0,0 +1,56 @@
+---
+title: Home
+slug: /
+---
+
+Welcome to the **Premake 5  User Guide** !
+
+## Getting Started ##
+
+* [What Is Premake?](What-Is-Premake.md)
+* [Getting Premake](Getting-Premake.md)
+* [Using Premake](Using-Premake.md)
+* [Building Premake](Building-Premake.md)
+* [Getting Help](Getting-Help.md)
+* [Who Uses Premake?](Who-Uses-Premake.md)
+* [About This Wiki](About-This-Wiki.md)
+
+## Writing Premake Scripts ##
+
+* [Your First Script](Your-First-Script.md)
+* [Workspaces and Projects](Workspaces-and-Projects.md)
+* [Scopes and Inheritance](Scopes-and-Inheritance.md)
+* [Adding Source Files](Adding-Source-Files.md)
+* [Linking](Linking.md)
+* [Configurations and Platforms](Configurations-and-Platforms.md)
+* [Filters](Filters.md)
+* [Build Settings](Build-Settings.md)
+* [Command Line Arguments](Command-Line-Arguments.md)
+* [Using Modules](Using-Modules.md)
+* [Tutorials](Tutorials.md)
+* [More Topics…](Topics.md)
+
+## Extending Premake ##
+
+* [Introduction](Extending-Premake.md)
+* [Code Overview](Code-Overview.md)
+* [Coding Conventions](Coding-Conventions.md)
+* [Overrides and Call Arrays](Overrides-and-Call-Arrays.md)
+* [Developing Modules](Developing-Modules.md)
+* [Adding a New Action](Adding-a-new-Action.md)
+* Adding a New Toolset
+
+## Premake Reference ##
+
+* [Project API](Project-API.md)
+* [Lua Library Additions](Lua-Library-Additions.md)
+* [Available Modules](Modules.md)
+* [Supported Feature Matrix](Feature-Matrix.md)
+* [What's New in 5.0](What's-New-in-5.0.md)
+* [Migrating From 4.x](Migrating-From-4.x.md)
+
+## Contributing to Premake ##
+
+* [How You Can Help](How-To-Help.md)
+* [Development Roadmap](Development-Roadmap.md)
+* [How To Submit Changes](Contribution-Guidelines.md)

website/docs/Sharing-Configuration-Settings.md

@@ -0,0 +1,40 @@
+---
+title: Sharing Configuration Settings
+---
+
+> I'm very interested in having a project A be able to specify information that project B can use to compile and link against project A, without having to repeat that information all over the place.
+
+There have been discussions on forums new and old about this in the past; search for "usages". It would be great to pull those together here for reference if anyone gets a chance. In the meantime, feel free to add your approaches below.
+
+---
+
+**@starkos:** We use functions here. For specifying how to compile and link against a library:
+
+```lua
+-- How to declare it
+function someLibrary(options)
+   defines { ... }
+   links { ... }
+   options = options or {}
+   if options.someFlag then
+      defines { ... }
+   end
+end
+
+-- How to use it
+project "someOtherProject"
+   kind "ConsoleApp"
+   someLibrary { someFlag="true" }
+```
+
+And for defining "classes" of projects:
+
+```lua
+function someComponent_test(name)
+   project(name)
+   kind "ConsoleApp"
+   defines { ... }
+   links { ... }
+   filter {}
+end
+```

website/docs/Style-Guide.md

@@ -0,0 +1,206 @@
+---
+title: Style Guide
+sidebar_label: Style Guide
+---
+<!-- This page should not be visible to public -->
+
+You can write content using [GitHub-flavored Markdown syntax](https://github.github.com/gfm/).
+
+## Markdown Syntax
+
+To serve as an example page when styling markdown based Docusaurus sites.
+
+## Headers
+
+# H1 - Create the best documentation
+
+## H2 - Create the best documentation
+
+### H3 - Create the best documentation
+
+#### H4 - Create the best documentation
+
+##### H5 - Create the best documentation
+
+###### H6 - Create the best documentation
+
+---
+
+## Emphasis
+
+Emphasis, aka italics, with *asterisks* or _underscores_.
+
+Strong emphasis, aka bold, with **asterisks** or __underscores__.
+
+Combined emphasis with **asterisks and _underscores_**.
+
+Strikethrough uses two tildes. ~~Scratch this.~~
+
+---
+
+## Lists
+
+1. First ordered list item
+1. Another item
+   - Unordered sub-list.
+1. Actual numbers don't matter, just that it's a number
+   1. Ordered sub-list
+1. And another item.
+
+* Unordered list can use asterisks
+
+- Or minuses
+
++ Or pluses
+
+---
+
+## Links
+
+[I'm an inline-style link](https://www.google.com/)
+
+[I'm an inline-style link with title](https://www.google.com/ "Google's Homepage")
+
+[I'm a reference-style link][arbitrary case-insensitive reference text]
+
+[You can use numbers for reference-style link definitions][1]
+
+Or leave it empty and use the [link text itself].
+
+URLs and URLs in angle brackets will automatically get turned into links. http://www.example.com/ or <http://www.example.com/> and sometimes example.com (but not on GitHub, for example).
+
+Some text to show that the reference links can follow later.
+
+[arbitrary case-insensitive reference text]: https://www.mozilla.org/
+[1]: http://slashdot.org/
+[link text itself]: http://www.reddit.com/
+
+---
+
+## Images
+
+Here's our logo (hover to see the title text):
+
+Inline-style: ![alt text](https://github.com/adam-p/markdown-here/raw/master/src/common/images/icon48.png 'Logo Title Text 1')
+
+Reference-style: ![alt text][logo]
+
+[logo]: https://github.com/adam-p/markdown-here/raw/master/src/common/images/icon48.png 'Logo Title Text 2'
+
+Images from any folder can be used by providing path to file. Path should be relative to markdown file.
+
+![img](/img/premake-logo.png)
+
+---
+
+## Code
+
+```lua title="premake5.lua"
+print("Hello World")
+```
+
+```javascript
+var s = 'JavaScript syntax highlighting';
+alert(s);
+```
+
+```python
+s = "Python syntax highlighting"
+print(s)
+```
+
+```
+No language indicated, so no syntax highlighting.
+But let's throw in a <b>tag</b>.
+```
+
+```js {2}
+function highlightMe() {
+  console.log('This line can be highlighted!');
+}
+```
+
+---
+
+## Tables
+
+Colons can be used to align columns.
+
+| Tables        |      Are      |   Cool |
+| ------------- | :-----------: | -----: |
+| col 3 is      | right-aligned | \$1600 |
+| col 2 is      |   centered    |   \$12 |
+| zebra stripes |   are neat    |    \$1 |
+
+There must be at least 3 dashes separating each header cell. The outer pipes (|) are optional, and you don't need to make the raw Markdown line up prettily. You can also use inline Markdown.
+
+| Markdown | Less      | Pretty     |
+| -------- | --------- | ---------- |
+| _Still_  | `renders` | **nicely** |
+| 1        | 2         | 3          |
+
+---
+
+## Blockquotes
+
+> Blockquotes are very handy in email to emulate reply text. This line is part of the same quote.
+
+Quote break.
+
+> This is a very long line that will still be quoted properly when it wraps. Oh boy let's keep writing to make sure this is long enough to actually wrap for everyone. Oh, you can _put_ **Markdown** into a blockquote.
+
+---
+
+## Inline HTML
+
+<dl>
+  <dt>Definition list</dt>
+  <dd>Is something people use sometimes.</dd>
+
+  <dt>Markdown in HTML</dt>
+  <dd>Does *not* work **very** well. Use HTML <em>tags</em>.</dd>
+</dl>
+
+---
+
+## Line Breaks
+
+Here's a line for us to start with.
+
+This line is separated from the one above by two newlines, so it will be a _separate paragraph_.
+
+This line is also a separate paragraph, but... This line is only separated by a single newline, so it's a separate line in the _same paragraph_.
+
+---
+
+## Admonitions
+
+:::note
+
+This is a note
+
+:::
+
+:::tip
+
+This is a tip
+
+:::
+
+:::important
+
+This is important
+
+:::
+
+:::caution
+
+This is a caution
+
+:::
+
+:::warning
+
+This is a warning
+
+:::

website/docs/Using-Premake.md

@@ -0,0 +1,69 @@
+---
+title: Using Premake
+---
+
+*New to Premake? You might want to start with [What is Premake?](/docs/)*
+
+
+### Getting Premake ###
+
+If you don't have Premake already, see [Getting Premake](Getting-Premake.md) to learn how.
+
+Premake is a small command line executable, delivered as a single file. Just unpack the download and place the executable on your system search path, or anywhere else convenient.
+
+
+### Using Premake to Generate Project Files ###
+
+The simplest Premake command is:
+
+    premake5 [action]
+
+Premake defines the following list of actions out of the box; projects may also add their own custom actions.
+
+| Action      | Description                                       |
+|-------------|---------------------------------------------------|
+| vs2019      | Generate Visual Studio 2019 project files         |
+| vs2017      | Generate Visual Studio 2017 project files         |
+| vs2015      | Generate Visual Studio 2015 project files         |
+| vs2013      | Generate Visual Studio 2013 project files         |
+| vs2012      | Generate Visual Studio 2012 project files         |
+| vs2010      | Generate Visual Studio 2010 project files         |
+| vs2008      | Generate Visual Studio 2008 project files         |
+| vs2005      | Generate Visual Studio 2005 project files         |
+| gmake       | Generate GNU Makefiles (This generator is deprecated by gmake2) |
+| gmake2      | Generate GNU Makefiles (including [Cygwin][1] and [MinGW][2]) |
+| xcode4      | XCode projects (built-in [extension](https://github.com/premake/premake-core/tree/master/modules/xcode)) |
+| codelite    | CodeLite projects (built-in [extension](https://github.com/premake/premake-core/tree/master/modules/codelite)) |
+
+(Premake4 supported some additional actions that haven't yet been ported to this new version; see the [Available Feature Matrix](Feature-Matrix.md) for the whole list.)
+
+To generate Visual Studio 2013 project files, use the command:
+
+    premake5 vs2013
+
+You can see a complete list of the actions and other options supported by a project with the command:
+
+    premake5 --help
+
+
+### Using the Generated Projects ###
+
+For toolsets like Visual Studio and Xcode, you can simply load the generated workspace or workspace into your IDE and build as you normally would.
+
+If you have generated makefiles, running **make** with no options will build all targets using the default configuration, as set by the project author. To see the list of available configurations, type:
+
+    make help
+
+To build a different configuration, add the **config** argument:
+
+    make config=release
+
+To remove all generated binaries and intermediate files:
+
+    make clean                 # to clean the default target
+    make config=release clean  # to clean a different target
+
+Premake generated makefiles do not (currently) support a **make install** step. Instead, project owners are encouraged to [add an install action](Command-Line-Arguments.md) to their Premake scripts, which has the advantage of working with any toolset on any platform. You can check for the existence of an install action by viewing the help (run premake5 --help in the project directory).
+
+[1]: http://www.cygwin.com/
+[2]: http://www.mingw.org/

website/docs/What-Is-Premake.md

@@ -0,0 +1,79 @@
+---
+title: What is Premake
+---
+
+Premake is a command line utility which reads a scripted definition of a software project and, most commonly, uses it to generate project files for toolsets like Visual Studio, Xcode, or GNU Make.
+
+
+-----------------------------------------
+
+```lua
+workspace "MyWorkspace"
+   configurations { "Debug", "Release" }
+
+project "MyProject"
+   kind "ConsoleApp"
+   language "C++"
+   files { "**.h", "**.cpp" }
+
+   filter { "configurations:Debug" }
+      defines { "DEBUG" }
+      symbols "On"
+
+   filter { "configurations:Release" }
+      defines { "NDEBUG" }
+      optimize "On"
+```
+*A sample Premake script.*
+
+```
+$ premake5 vs2012
+Building configurations...
+Running action 'vs2012'...
+Generating MyWorkspace.sln...
+Generating MyProject.vcxproj...
+Generating MyProject.vcxproj.user...
+Done.
+```
+*Premake reads the script and generates project scripts.*
+
+-----------------------------------------
+
+### Use Premake To… ###
+
+* Maximize your potential audience by allowing developers to use the platforms and toolsets they prefer.
+
+* Allow developers to customize the build, and output project files specific to that configuration.
+
+* Keep builds in sync across toolsets by generating project from the Premake scripts on demand.
+
+* Quickly update large codebases with many workspaces and projects: make the change once in your Premake script and then regenerate.
+
+* Create project files for toolsets you don't own.
+
+* Quickly upgrade to newer versions of your chosen toolset.
+
+* Script common configuration and build maintenance tasks.
+
+
+### Key Features ###
+
+The current development version of Premake 5.0 can generate C, C++, or C# projects targeting:
+
+* Microsft Visual Studio 2005-2019
+* GNU Make, including Cygwin and MinGW
+* Xcode
+* Codelite
+
+Previous version of Premake also supported exporting for MonoDevelop and Code::Blocks. We are in the process of bringing these exporters back online for the final release.
+
+Premake 5.0 generated projects can support:
+
+* 32- and 64-bit builds
+* Xbox 360 (Visual Studio only)
+
+[Add-on modules](Modules.md) can extend Premake with support for additional languages, frameworks, and toolsets.
+
+In addition to its project generation capabilities, Premake also provides a complete [Lua](http://lua.org/) scripting environment, enabling the automation of complex configuration tasks such as setting up new source tree checkouts or creating deployment packages. These scripts will run on any platform, ending batch/shell script duplication.
+
+Premake is a "plain old C" application, distributed as a single executable file. It is small, weighing in at around 200K. It does not require any additional libraries or runtimes to be installed, and should build and run pretty much anywhere. It is currently being tested and used on Windows, Mac OS X, Linux, and other POSIX environments. It uses only a handful of platform dependent routines (directory management, mostly). Adding support for additional toolsets and languages is straightforward. The source code is available under the BSD License. The source code is hosted right here on GitHub; file downloads are currently hosted on SourceForge.

website/docs/Who-Uses-Premake.md

@@ -0,0 +1,39 @@
+---
+title: Who Uses Premake
+---
+
+If you use Premake, feel free to add your organization or project to the lists below.
+
+## Organizations Using Premake ##
+
+* [Air Navigation](http://airnavigation.aero/) (former Xample)
+* [Blizzard Entertainment](http://blizzard.com)
+* [Centaurean](https://github.com/centaurean)
+* [Fresh3D](http://www.fresh3d.com/)
+* [Kalydo](http://www.kalydo.com/)
+* [Mono](http://www.mono-project.com/)
+* [Olde Sküül](http://www.oldeskuul.com)
+* [Simlaps.com](http://www.simlaps.com)
+* [Utomik](https://www.utomik.com/)
+* [WhiteMoonDreams](http://www.whitemoondreams.com/)
+
+## Open Source Projects Using Premake ##
+
+* [0 A.D.](https://play0ad.com/)
+* [Box2D](http://box2d.org)
+* [Bullet Physics Library](http://bulletphysics.org)
+* [CppSharp](https://github.com/mono/CppSharp)
+* [Decoda Lua IDE](https://github.com/unknownworlds/decoda)
+* [Density](https://github.com/centaurean/density)
+* [GpuCV](http://picoforge.int-evry.fr/cgi-bin/twiki/view/Gpucv/Web/WebHome)
+* [Multi Theft Auto](https://github.com/multitheftauto/mtasa-blue)
+* [OOLua](http://oolua.org/)
+* [Open Dynamics Engine](http://www.ode.org/)
+* [The Unofficial OpenGL SDK](http://glsdk.sourceforge.net/docs/html/index.html), and the companion [Learning Modern Graphics eBook](http://alfonse.bitbucket.org/oldtut/)
+* [TinyXML++](https://github.com/rjpcomputing/ticpp)
+* [VDrift](http://vdrift.net/)
+* [PacketNgin](https://github.com/packetngin/rtos)
+* [Recast Navigation](https://github.com/recastnavigation/recastnavigation)
+* [wxFormBuilder](https://github.com/wxFormBuilder/wxFormBuilder)
+* [Hazel Game Engine](https://github.com/TheCherno/Hazel)
+* [PopHead](https://github.com/SPC-Some-Polish-Coders/PopHead)

website/docs/basedir.md

@@ -0,0 +1,23 @@
+---
+title: basedir
+---
+
+Sets the base directory for a configuration, from with other paths contained by the configuration will be made relative at export time.
+
+```lua
+basedir ("value")
+```
+
+You do not normally need to set this value, as it is filled in automatically with the current working directory at the time the configuration block is created by the script.
+
+### Parameters ###
+
+`value` is an absolute path, from which other paths contained by the configuration should be made relative.
+
+### Applies To ###
+
+Any configuration.
+
+### Availability ###
+
+Premake 4.4 or later.

website/docs/os.chdir.md

@@ -0,0 +1,22 @@
+Changes the current working directory.
+
+```lua
+ok, err = os.chdir("path")
+```
+
+### Parameters ###
+
+`path` is the file system path to the new working directory.
+
+### Return Value ###
+
+**True** if successful, otherwise **nil** and an error message.
+
+### Availability ###
+
+Premake 4.0 or later.
+
+### See Also ###
+
+* [os.getcwd](os.getcwd.md)
+* [os.mkdir](os.mkdir.md)

website/docs/os.mkdir.md

@@ -0,0 +1,26 @@
+Creates a new file system directory.
+
+```lua
+os.mkdir("path")
+```
+
+### Parameters ###
+
+`path` is the file system path to be created.
+
+
+### Return Value ###
+
+True if successful, otherwise nil and an error message.
+
+
+### Availability ###
+
+Premake 4.0 or later.
+
+
+### See Also ###
+
+* [os.chdir](os.chdir.md)
+* [os.getcwd](os.getcwd.md)
+* [os.rmdir](os.rmdir.md)

website/docs/os.rmdir.md

@@ -0,0 +1,26 @@
+Removes an existing directory as well as any files or subdirectories it contains.
+
+```lua
+os.rmdir("path")
+```
+
+### Parameters ###
+
+`path` is the file system path to be removed.
+
+
+### Return Value ###
+
+True if successful, otherwise nil and an error message.
+
+
+### Availability ###
+
+Premake 4.0 or later.
+
+
+### See Also ###
+
+* [os.chdir](os.chdir.md)
+* [os.getcwd](os.getcwd.md)
+* [os.mkdir](os.mkdir.md)

website/docs/path.getabsolute.md

@@ -0,0 +1,23 @@
+Converts a relative path to an absolute path.
+
+```lua
+p = path.getabsolute("path", "relativeTo")
+```
+
+### Parameters ###
+
+`path` is the relative path to be converted. It does not need to actually exist on the file system.
+
+If provided, `relativeTo` specifies an absolute path from which `path` is considered relative. If not specified, the current working directory will be used.
+
+### Return Value ###
+
+A new absolute path, calculated from the current working directory, or the `relativeTo` parameter if provided.
+
+### Availability ###
+
+Premake 4.0 or later. The `relativeTo` parameter is available in Premake 5.0 or later.
+
+### See Also ###
+
+* [path.isabsolute](path.isabsolute.md)

website/docs/path.getbasename.md

@@ -0,0 +1,27 @@
+Returns the base file portion of a path, with the directory and file extension removed.
+
+```lua
+p = path.getbasename("path")
+```
+
+### Parameters ###
+
+`path` is the file system path to be split.
+
+
+### Return Value ###
+
+The base name portion of the supplied path, with any directory and file extension removed.
+
+
+### Availability ###
+
+Premake 4.0 or later.
+
+
+### See Also ###
+
+* [path.getdirectory](path.getdirectory.md)
+* [path.getdrive](path.getdrive.md)
+* [path.extension](path.getextension.md)
+* [path.getname](path.getname.md)

website/docs/path.getdirectory.md

@@ -0,0 +1,27 @@
+Returns the directory portion of a path, with any file name removed.
+
+```lua
+p = path.getdirectory("path")
+```
+
+### Parameters ###
+
+`path` is the file system path to be split.
+
+
+### Return Value ###
+
+The directory portion of the path, with any file name removed. If the path does not include any directory information, the "." (single dot) current directory is returned.
+
+
+### Availability ###
+
+Premake 4.0 or later.
+
+
+### See Also ###
+
+* [path.getbasename](path.getbasename.md)
+* [path.getdrive](path.getdrive.md)
+* [path.extension](path.getextension.md)
+* [path.getname](path.getname.md)

website/docs/path.getdrive.md

@@ -0,0 +1,27 @@
+Returns the drive letter portion of a path, if present.
+
+```lua
+p = path.getdrive("path")
+```
+
+### Parameters ###
+
+`path` is the file system path to be split.
+
+
+### Return Value ###
+
+The drive letter portion of the path, if one is specified. Otherwise, nil.
+
+
+### Availability ###
+
+Premake 4.0 or later.
+
+
+### See Also ###
+
+* [path.getbasename](path.getbasename.md)
+* [path.getdirectory](path.getdirectory.md)
+* [path.extension](path.getextension.md)
+* [path.getname](path.getname.md)

website/docs/path.getextension.md

@@ -0,0 +1,27 @@
+Returns the file extension portion of a path.
+
+```lua
+p = path.getextension("path")
+```
+
+### Parameters ###
+
+`path` is the file system path to be split.
+
+
+### Return Value ###
+
+The file extension portion of the path, or an empty string if no extension is present.
+
+
+### Availability ###
+
+Premake 4.0 or later.
+
+
+### See Also ###
+
+* [path.getbasename](path.getbasename.md)
+* [path.getdirectory](path.getdirectory.md)
+* [path.getdrive](path.getdrive.md)
+* [path.getname](path.getname.md)

website/docs/path.getname.md

@@ -0,0 +1,27 @@
+Returns the file name and extension, with any directory information removed.
+
+```lua
+p = path.getname("path")
+```
+
+### Parameters ###
+
+`path` is the file system path to be split.
+
+
+### Return Value ###
+
+The file name and extension, with no directory information.
+
+
+### Availability ###
+
+Premake 4.0 or later.
+
+
+### See Also ###
+
+* [path.getbasename](path.getbasename.md)
+* [path.getdirectory](path.getdirectory.md)
+* [path.getdrive](path.getdrive.md)
+* [path.getextension](path.getextension.md)

website/docusaurus.config.js

@@ -0,0 +1,112 @@
+module.exports = {
+  title: 'Premake',
+  tagline: 'Powerfully simple build configuration',
+  url: 'https://premake.github.io/',
+  baseUrl: '/premake-core/',
+  onBrokenLinks: 'warn', // FIXME: when docs are ready change it to 'throw'
+  onBrokenMarkdownLinks: 'warn',
+  favicon: 'img/premake-logo.png', // FIXME: make actual favicon.ico file
+  organizationName: 'premake',
+  projectName: 'premake-core',
+  themeConfig: {
+  prism: {
+    additionalLanguages: ['lua'],
+  },
+    navbar: {
+      title: 'Premake',
+      logo: {
+        alt: 'Premake Logo',
+        src: 'img/premake-logo.png',
+      },
+      items: [
+        {
+          to: 'docs/',
+          activeBasePath: 'docs',
+          label: 'Docs',
+          position: 'left',
+        },
+        {
+        to: '/download',
+        label: 'Download',
+        position: 'left'
+        },
+        {
+          href: 'https://github.com/premake/premake-core',
+          label: 'GitHub',
+          position: 'left',
+        },
+        {
+            type: 'docsVersionDropdown',
+            position: 'right',
+            dropdownActiveClassDisabled: true,
+        }
+      ],
+    },
+    footer: {
+      style: 'dark',
+      links: [
+        {
+          title: 'Documentation',
+          items: [
+            {
+              label: 'Premake 5.0',
+              to: 'docs/',
+            },
+            {
+              label: 'Premake 4.x',
+              to: 'docs/4.x/',
+            },
+          ],
+        },
+        {
+          title: 'Community',
+          items: [
+            {
+              label: 'Who uses Premake',
+              href: 'docs/Who-Uses-Premake',
+            },
+            {
+              label: 'StackOverflow',
+              href: 'https://stackoverflow.com/questions/tagged/premake',
+            },
+            {
+              label: 'Twitter',
+              href: 'https://twitter.com/premakeapp',
+            },
+          ],
+        },
+        {
+          title: 'More',
+          items: [
+            {
+              label: 'GitHub',
+              href: 'https://github.com/premake/premake-core/',
+            },
+          ],
+        },
+      ],
+      copyright: `Copyright © ${new Date().getFullYear()} Premake`,
+    },
+  },
+  presets: [
+    [
+      '@docusaurus/preset-classic',
+      {
+        docs: {
+          sidebarPath: require.resolve('./sidebars.js'),
+          editUrl: 'https://github.com/premake/premake-core/edit/master/website/',
+          lastVersion: "current",
+          versions: {
+            current: {
+              label: "5.0",
+              path: ""
+            }
+          }
+        },
+        theme: {
+          customCss: require.resolve('./src/css/custom.css'),
+        },
+      },
+    ],
+  ]
+};

website/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "website",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "docusaurus": "docusaurus",
+    "start": "docusaurus start",
+    "build": "docusaurus build",
+    "swizzle": "docusaurus swizzle",
+    "deploy": "docusaurus deploy",
+    "serve": "docusaurus serve",
+    "clear": "docusaurus clear"
+  },
+  "dependencies": {
+    "@docusaurus/core": "2.0.0-alpha.70",
+    "@docusaurus/preset-classic": "2.0.0-alpha.70",
+    "@mdx-js/react": "^1.6.21",
+    "clsx": "^1.1.1",
+    "react": "^16.8.4",
+    "react-dom": "^16.8.4"
+  },
+  "browserslist": {
+    "production": [
+      ">0.5%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  }
+}

website/sidebars.js

@@ -0,0 +1,57 @@
+module.exports = {
+  mainSidebar: [
+    {
+      collapsed: false,
+      type: 'category',
+      label: 'Getting Started',
+      items: [
+        'Home',
+        'What-Is-Premake',
+        'Building-Premake',
+        'Getting-Premake',
+        'Using-Premake',
+        'Getting-Help',
+        'Who-Uses-Premake'
+      ]
+    },
+    {
+      collapsed: true,
+      type: 'category',
+      label: 'Guides',
+      items: [
+        'Sharing-Configuration-Settings'
+      ]
+    },
+    {
+      collapsed: true,
+      type: 'category',
+      label: 'Reference',
+      items: [
+        'basedir',
+        {
+          collapsed: false,
+          type: 'category',
+          label: 'os',
+          items: [
+            'os.chdir',
+            'os.mkdir',
+            'os.rmdir'
+          ]
+        },
+        {
+          collapsed: false,
+          type: 'category',
+          label: 'path',
+          items: [
+            'path.getabsolute',
+            'path.getbasename',
+            'path.getdirectory',
+            'path.getdrive',
+            'path.getextension',
+            'path.getname'
+          ]
+        }
+      ],
+    }
+  ],
+};

website/src/css/custom.css

@@ -0,0 +1,25 @@
+/* stylelint-disable docusaurus/copyright-header */
+/**
+ * Any CSS included here will be global. The classic template
+ * bundles Infima by default. Infima is a CSS framework designed to
+ * work well for content-centric websites.
+ */
+
+/* You can override the default Infima variables here. */
+:root {
+  --ifm-color-primary: #2b86cc;
+  --ifm-color-primary-dark: #2779b8;
+  --ifm-color-primary-darker: #2572ad;
+  --ifm-color-primary-darkest: #1e5e8f;
+  --ifm-color-primary-light: #3a92d6;
+  --ifm-color-primary-lighter: #4498d8;
+  --ifm-color-primary-lightest: #63a9de;
+  --ifm-code-font-size: 95%;
+}
+
+.docusaurus-highlight-code-line {
+  background-color: rgb(72, 77, 91);
+  display: block;
+  margin: 0 calc(-1 * var(--ifm-pre-padding));
+  padding: 0 var(--ifm-pre-padding);
+}

website/src/pages/download.md

@@ -0,0 +1,3 @@
+# Download Premake
+
+*Work in progress*

website/src/pages/index.js

@@ -0,0 +1,100 @@
+import React from 'react';
+import clsx from 'clsx';
+import Layout from '@theme/Layout';
+import Link from '@docusaurus/Link';
+import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
+import useBaseUrl from '@docusaurus/useBaseUrl';
+import styles from './styles.module.css';
+
+const features = [
+  {
+    title: 'Easy to Use',
+    description: (
+      <div>
+        <p>Describe your software project just once, using Premake's simple and easy to read syntax, and build it everywhere.</p>
+        <p>Generate project files for Visual Studio, GNU Make, Xcode, Code::Blocks, and more across Windows, Mac OS X, and
+        Linux. Use the full featured Lua scripting engine to make build configuration tasks a breeze.</p>
+      </div>
+    ),
+  },
+  {
+    title: 'Version 5.0 (alpha)',
+    description: (
+      <div>
+        <p>The latest iteration of Premake, featuring an improved platform system, support for third-party modules, and loads of new features.</p>
+		    <p className={styles.bigText}><a href='download/'>Download</a>&nbsp;·&nbsp;<a href='docs/'>Documentation</a></p>
+      </div>
+    ),
+  },
+  {
+    title: 'Version 4.4 (beta)',
+    description: (
+      <div>
+        <p>The latest in Premake's 4.x stable branch.</p>
+		    <p className={styles.bigText}><a href='download/'>Download</a>&nbsp;·&nbsp;<a href='docs/4.x/'>Documentation</a></p>
+      </div>
+    ),
+  },
+];
+
+function Feature({imageUrl, title, description}) {
+  const imgUrl = useBaseUrl(imageUrl);
+  return (
+    <div className={clsx('col col--4', styles.feature)}>
+      <h3>{title}</h3>
+      <>{description}</>
+    </div>
+  );
+}
+
+function Home() {
+  const context = useDocusaurusContext();
+  const {siteConfig = {}} = context;
+  return (
+    <Layout
+      title={`${siteConfig.title}`}
+      description="Description will go into a meta tag in <head />">
+      <header className={clsx('hero shadow--lw', styles.heroBanner)}>
+        <div className="container">
+          <img className={styles.featureImage} src={useBaseUrl('img/premake-logo.png')} alt={'Premake logo'} />
+          <h1 className="hero__title">{siteConfig.title}</h1>
+          <p className="hero__subtitle">{siteConfig.tagline}</p>
+          <div className={styles.buttons}>
+            <Link
+              className={clsx(
+                'button button--outline button--primary button--lg',
+                styles.getStarted,
+              )}
+              to={useBaseUrl('docs/')}>
+              Get Started
+            </Link>
+			&nbsp;&nbsp;
+			<Link
+              className={clsx(
+                'button button--outline button--primary button--lg',
+                styles.getStarted,
+              )}
+              to={useBaseUrl('download/')}>
+              Download
+            </Link>
+          </div>
+        </div>
+      </header>
+      <main>
+        {features && features.length > 0 && (
+          <section className={styles.features}>
+            <div className="container">
+              <div className="row">
+                {features.map((props, idx) => (
+                  <Feature key={idx} {...props} />
+                ))}
+              </div>
+            </div>
+          </section>
+        )}
+      </main>
+    </Layout>
+  );
+}
+
+export default Home;

website/src/pages/styles.module.css

@@ -0,0 +1,42 @@
+/* stylelint-disable docusaurus/copyright-header */
+
+/**
+ * CSS files with the .module.css suffix will be treated as CSS modules
+ * and scoped locally.
+ */
+
+.heroBanner {
+  padding: 4rem 0;
+  text-align: center;
+  position: relative;
+  overflow: hidden;
+}
+
+@media screen and (max-width: 966px) {
+  .heroBanner {
+    padding: 2rem;
+  }
+}
+
+.bigText {
+	font-size: larger;
+	font-weight: bold;
+}
+
+.buttons {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.features {
+  display: flex;
+  align-items: center;
+  padding: 2rem 0;
+  width: 100%;
+}
+
+.featureImage {
+  height: 200px;
+  width: 200px;
+}

website/versioned_docs/version-4.x/Basic-Premake-Extension.md

@@ -0,0 +1,43 @@
+---
+title: Basic Premake Extension
+---
+
+*Some things you should know before you digging into the Premake internals, in no particular order:*
+
+## Managing script files ##
+
+Before you begin, you should be able to [build and run the debug configuration of Premake](Building-Premake.md). This will save you the trouble of embedding the scripts and recompiling with each change, and will greatly speed up development.
+
+When you have completed your changes and are ready to roll them out, note that you must run `premake4 embed` and recompile in order to see your changes in the release build of Premake. Debug builds load the scripts dynamically at startup and so can skip this step.
+
+Premake knows which scripts to load and run by reading the file `src/_manifest.lua`. Any new script file you create must be listed in the manifest if you want it to run. This is a common mistake; I still make it myself every once in a while.
+
+The command `premake4 embed` copies all of the scripts listed in the manifest into static C buffers in the file `src/host/scripts.c`, which then gets compiled into the final executable. This is how I can ship a single binary, rather than the whole source tree.
+
+## Testing ##
+
+There is a fairly comprehensive set of automated tests in the `tests/` folder. Create a debug build of Premake and then, in this tests directory, run the command:
+
+```
+../bin/debug/premake4 test
+```
+
+Or, if you're in a POSIX environment, run the `./test` shell script. I am using my own homegrown testing framework, which is defined in `tests/testfx.lua`. You can add new test files in `tests/premake4.lua`.
+
+## Namespaces ##
+
+Lua allows the creation of namespaces (of a sort) by putting your functions into a table. This example creates a function `bar` in the namespace `premake.foo`.
+
+```lua
+premake.foo = { }
+
+function premake.foo.bar()
+  -- do something useful
+end
+```
+
+I have begun moving all of Premake's internals into the *premake* namespace, but it is a work in progress.
+
+## And finally... ##
+
+Finally, [post any questions you might have over in the forums](https://groups.google.com/forum/#!forum/premake-development) and I will be delighted (yes, delighted) to help you out. Your questions will help me improve this documentation and Premake itself and are very much appreciated.

website/versioned_docs/version-4.x/Building-Premake.md

@@ -0,0 +1,81 @@
+---
+title: Building Premake
+---
+
+If you downloaded a prebuilt binary package you can skip this page, which discusses how to build the Premake source code. Jump ahead to [Quick Start](Premake-Quick-Start.md) to begin learning how to use and develop with Premake.
+
+## Generating the Project Files ##
+
+If you downloaded one of the [official source code release packages](http://sourceforge.net/projects/premake/files/), the project files have already been generated for you, and may be found in the **build/** directory. Skip ahead to the next section to learn about the important differences between the build configurations.
+
+Premake's [Git repository](https://github.com/premake/premake-4.x) does not contain any project files. Instead, use an [existing copy of Premake](http://premake.github.io/premake-core/download.html) to generate the files for your particular toolset and environment.
+
+Once you have a working Premake installed, embed the scripts by opening a console or terminal to the source code directory and running the command
+
+```bash
+premake4 embed
+```
+
+Now generate the project files with a command like:
+
+```bash
+premake4 gmake    # for GNU makefiles using GCC
+premake4 vs2008   # for a Visual Studio 2008 solution
+```
+
+Use the --help option to see all of the available targets. You now have a solution/makefile/workspace that you can load and build.
+
+Note that when working against the Git sources it is a good idea to refresh the embedded scripts after each update.
+
+```bash
+git pull -u
+premake4 embed
+```
+
+See **Debug vs. Release Modes** below for an explanation (and maybe eventually I'll think of a better way to do this).
+
+## Building the Source Code ##
+
+Premake can be built in either "release" (the default) or "debug" modes. If you are using Makefiles (as opposed to an IDE), you can choose which configuration to build with the **config** argument:
+
+```bash
+make               # build in release mode, both versions
+make config=debug  # build in debug mode, when generated with Premake 4.x
+make CONFIG=Debug  # build in debug mode, when generated with Premake 3.x
+```
+
+If you do not supply a **config** argument, release mode will be used. IDEs like Visual Studio provide their own mechanism for switching build configurations.
+
+## Debug vs Release Modes ##
+
+A significant portion of Premake is written in Lua. For release builds (the default) this has no impact, just build as normal and go.
+
+When built in Debug mode, Premake will read its Lua scripts from the disk at startup, enabling compile-less code/test iterations, and therefore faster development. But it needs a little help finding the scripts. You can use the **/scripts** command line argument, like so:
+
+```bash
+premake4 /scripts=~/Code/premake4/src gmake
+```
+
+Or set a **PREMAKE_PATH** environment variable:
+
+```bash
+PREMAKE_PATH=~/Code/premake4/src
+```
+
+You need to specify the location of the Premake **src/** directory, the one containing **_premake_main.lua**.
+
+## Embedding the Scripts ##
+
+In release builds, Premake uses a copy of the scripts embedded into static strings: see **src/host/scripts.c**. If you modify any of the core Lua scripts (anything ending in **.lua**), you must also update these embedded strings before your changes will appear in the release mode build.
+
+You can update these strings by using the **embed** action, which is part of Premake's own build script.
+
+```bash
+premake4 embed
+```
+
+This command embeds all of the scripts listed in **_manifest.lua** into **src/host/scripts.c**. The next release build will include the updated scripts.
+
+## Confused? ##
+
+The inclusion of the Lua scripts throws a wrench in things, and I certainly understand if you have questions. I'll be glad to help you out. Leave a note [in the forums](https://groups.google.com/forum/#!forum/premake-development). Your questions will help me improve these instructions.

website/versioned_docs/version-4.x/Create-A-New-Action.md

@@ -0,0 +1,47 @@
+---
+title: Create A New Action
+---
+
+An *action* is what gets triggered when you run Premake; the command `premake4 vs2008` triggers the Visual Studio 2008 action, while `premake4 clean` triggers the clean action.
+
+I created an example action, available in the source code packages at `src/actions/example`, to help you get started. This example writes out simple *solution* and *project* files, showing how to get out the project information using the Premake APIs. The tutorial below will show you how to use these example files to get started on your own actions.
+
+## Setting Up ##
+
+I keep all of the actions in `src/actions`, so create a new folder there with an appropriate name. Look at the other folders at that location, you'll get the idea.
+
+Copy the files from `src/actions/example` to your new folder and rename them appropriately. The leading underscore on `_example.lua` is optional; it is a convention I use to indicate which file contains the action description (more on that below). The underscore sorts this file to the top of the list making it easy to locate. Files without the leading underscore contain the actual implementation of the action.
+
+I'll continue to use the original file names (like `_example.lua`) through this explanation. Substitute in your new names.
+
+Add your new files (and any others you create later) to the script manifest at `src/_manifest.lua`.
+
+```lua
+-- The master list of built-in scripts. Order is important! If you want to
+-- build a new script into Premake, add it to this list.
+
+    return
+    {
+        -- core files
+        "base/os.lua",
+        "base/path.lua",
+
+        "...and so on...",
+
+        -- Clean action
+        "actions/clean/_clean.lua",
+
+        -- Your new action goes here
+        "actions/example/_example.lua",
+        "actions/example/example_solution.lua",
+        "actions/example/example_project.lua",
+    }
+```
+
+Order matters a little here: `_example.lua` defines the namespace for the action and must appear first. See the comments in that file for more information.
+
+## Start coding ##
+
+I've loaded up the example files, particularly the action description, to help you make sense of them. Rather than repeating all of that here, I'll just let you go browse through the files and start plugging in the code for your own actions.
+
+If you get stuck, if something isn't clear, or you want to see a demonstration of something that isn't covered by the example [drop a note in the forums](https://groups.google.com/forum/#!forum/premake-development) and I'll try to help you out.

website/versioned_docs/version-4.x/Extending-Premake.md

@@ -0,0 +1,12 @@
+---
+title: Extending Premake
+---
+
+A collection of how-to articles on extending and improving Premake. These are intended for folks who want to add new actions or API functions to Premake. If you just want to script your projects, have a look at [Scripting with Premake](Scripting_With_Premake) instead.
+
+This section is very much a work in progress, which I hope to gradually build up over time.
+
+---
+
+ * [Basic Premake Extension](Basic-Premake-Extension.md)
+ * [Create A New Action](Create-A-New-Action.md)

website/versioned_docs/version-4.x/Home.md

@@ -0,0 +1,27 @@
+---
+title: Home
+slug: /
+---
+## Welcome ##
+
+Welcome to the Premake-4.x wiki! You'll find the documentation for Premake's 4.x series of releases below.
+
+* For [Downloads, click here](http://premake.github.io/premake-core/download.html#v4)
+* For [Premake 5.0, click here](https://github.com/premake/premake-core/wiki)
+
+## User Guide ##
+
+This user guide reflects the current state of the software fairly closely, but may lag in places, or get a little ahead of the official releases in others. When in doubt, feel free to post a question over in the forums. If you spot any problems, or think something is unclear, feel free to leave a comment.
+
+ * [What Is Premake](What-Is-Premake.md)
+ * [Building Premake](Building-Premake.md)
+ * [Premake Quick Start](Premake-Quick-Start.md)
+ * [Scripting With Premake](Scripting-With-Premake.md)
+ * [Help!](Help.md)
+ * [FAQs](FAQs.md)
+ * [Scripting Reference](Scripting-Reference.md)
+ * [Extending Premake](Extending-Premake.md)
+
+## Contributing to Premake ##
+
+* [Development Roadmap](Development-Roadmap.md)

website/versioned_docs/version-4.x/Premake-Quick-Start.md

@@ -0,0 +1,77 @@
+---
+title: Premake Quick Start
+---
+
+*A quick introduction for people who arrived here directly: Premake is a build configuration tool. It reads a description of a software project and generates the files for one of several different toolsets. By using Premake, software developers can save time and support more tools and users.* [Learn More](http://github.com/premake/premake-4.x/wiki).
+
+## Getting Premake ##
+
+If you don't have Premake already, you can [download](http://premake.github.io/download.html) it now.
+
+Premake is a small (around 200K) command line executable, delivered as a single file. Just unpack the download and place the executable on your system search path or anywhere else convenient.
+
+## Using Premake ##
+
+The simplest Premake command is:
+
+```
+premake4 [action]
+```
+
+Premake defines the following list of actions out of the box which generate project files for a particular toolset. It is also possible to define custom actions.
+
+| Action     | Description                                                         |
+|------------|---------------------------------------------------------------------|
+| vs2013     | Generate Visual Studio 2013 project files (coming in Premake 4.4)   |
+| vs2012     | Generate Visual Studio 2012 project files (coming in Premake 4.4)   |
+| vs2010     | Generate Visual Studio 2010 project files                           |
+| vs2008     | Generate Visual Studio 2008 project files                           |
+| vs2005     | Generate Visual Studio 2005 project files                           |
+| vs2003     | Generate Visual Studio 2003 project files                           |
+| vs2002     | Generate Visual Studio 2002 project files                           |
+| gmake      | Generate GNU Makefiles (including [Cygwin][2] and [MinGW][3])       |
+| xcode3     | Generate Apple Xcode 3 project files                                |
+| codeblocks | Generate [Code::Blocks][4] project files                            |
+| codelite   | Generate [CodeLite][5] project files                                |
+
+You can see a complete list of the actions and other options supported by a project with the command:
+
+```
+premake4 --help
+```
+
+Once the project files have been generated you can load the solution or workspace into your IDE and build as you normally would.
+
+## Using the Generated Makefiles ##
+
+Running **make** with no options will build all targets using the default configuration. To build a different configuration supply the **config** argument:
+
+```bash
+make config=release
+```
+
+Most projects provide debug and release configurations; to see the available targets and configurations, type:
+
+```bash
+make help
+```
+
+Remove all generated binaries and intermediate files with:
+
+```bash
+make clean
+```
+
+Premake generated makefiles do *not* support a **make install** step. Instead, project owners are encouraged to [add an install action](Command-Line-Arguments.md) to their Premake scripts, which has the advantage of working with any toolset on any platform. You can check for the existence of an install action by viewing the help (run **premake4 --help** in the project directory).
+
+## Next Steps ##
+
+If you are having trouble building your project, start by contacting the project manager. If you are having trouble building or using Premake, [visit our Support page](https://github.com/premake/premake-4.x/wiki/Help) and I'll try to help you out.
+
+To learn how to use Premake for your own software projects see [Scripting With Premake](Scripting-With-Premake.md).
+
+[1]: https://github.com/premake/premake-4.x/wiki/Premake_Quick_Start
+[2]: http://www.cygwin.com/
+[3]: http://www.mingw.org/
+[4]: http://www.codeblocks.org/
+[5]: http://codelite.org/

website/versioned_docs/version-4.x/What-Is-Premake.md

@@ -0,0 +1,34 @@
+---
+title: What Is Premake
+---
+
+Imagine yourself the owner of an open source software project. Your users are asking for a Visual Studio 2008 solution, but you don't have Visual Studio! Or perhaps you are a cross-platform game developer struggling to keep projects, solutions, and makefiles in sync. Its a common problem for open and cross-platform projects: restrict yourself to a single, potentially sub-optimal build tool — driving away potential contributors — or manually maintain two, three, or more sets of build scripts.
+
+Not working cross-platform? Have you ever been stuck using an old version of Visual Studio because it was too difficult to upgrade the entire team?
+
+Or maybe you just want an easy way to reconfigure your project for different situations or environments, pulling in different source code or libraries, switches and options.
+
+## Enter Premake ##
+
+Premake is a build configuration tool. Describe your C, C++, or C# software project using a [simple, easy to read syntax](A_Sample_Script) and let Premake generate the project files for:
+
+ * Microsoft Visual Studio 2002-2010, including the [Express editions](http://www.microsoft.com/express)
+ * GNU Make, including [Cygwin](http://www.cygwin.com/) and [MinGW](http://www.mingw.org/)
+ * [Apple Xcode](http://developer.apple.com/tools/xcode/)
+ * [Code::Blocks](http://www.codeblocks.org/)
+ * [CodeLite](http://codelite.org/)
+ * IC#Code [SharpDevelop](http://www.icsharpcode.net/OpenSource/SD/)
+ * [MonoDevelop](http://www.monodevelop.com/Main_Page)
+
+Version 4.1 of Premake added [experimental support for cross-compiling](Using Platforms), targeting:
+
+ * 32- and 64-bit builds
+ * Mac OS X 32- and 64-bit universal binaries
+ * Playstation 3 (Visual Studio and GNU Make)
+ * Xbox 360 (Visual Studio only)
+
+Premake allows you to manage your project configuration in one place and still support those pesky IDE-addicted Windows coders and/or cranky Linux command-line junkies. It allows you to generate project files for tools that you do not own. It saves the time that would otherwise be spent manually keeping several different toolsets in sync. And it provides an easy upgrade path as new versions of your favorite tools are released.
+
+In addition to these project generation capabilities, Premake also provides a complete [Lua scripting environment](http://www.lua.org/), enabling the automation of complex configuration tasks, such as setting up new source tree checkouts or creating deployment packages. These scripts will run on any platform, ending batch/shell script duplication.
+
+Premake is a "plain old C" application, distributed as a single executable file. It is small, weighing in at around 200K. It does not require any additional libraries or runtimes to be installed, and should build and run pretty much anywhere. It is currently being tested and used on Windows, Mac OS X, Linux, and other POSIX environments. It uses only a handful of platform dependent routines (directory management, mostly). Adding support for additional toolsets and languages is straightforward. The source code is available under the [BSD License](http://www.opensource.org/licenses/bsd-license.php). The source code is hosted on [GitHub](https://github.com/premake/premake-4.x); file downloads are hosted on [SourceForge](http://sourceforge.net/projects/premake).

website/versioned_docs/version-4.x/buildaction.md

@@ -0,0 +1,31 @@
+The **buildaction** function specifies how a file or set of files should be treated during the compilation process. It is usually paired with a configuration filter to select a file set. If no build action is specified for a file a default action will be used, based on the file's extension.
+
+```lua
+buildaction ("action")
+```
+
+Build actions are currently only supported for .NET projects, and not for C or C++.
+
+## Applies To ##
+
+Solutions, projects, and configurations.
+
+## Parameters ##
+
+*action* is one of:
+
+|   |   |
+|---|---|
+| Compile | Treat the file as source code; compile and link it. |
+| Embed | Embed the file into the target binary as a resource. |
+| Copy | Copy the file to the target directory. |
+| None | Do nothing with this file. |
+
+## Examples ##
+
+Embed all PNG image files into the target binary.
+
+```lua
+configuration "**.png"
+   buildaction "Embed"
+```

website/versioned_docs/version-4.x/buildoptions.md

@@ -0,0 +1,24 @@
+The **buildoptions** function passes arguments directly to the compiler command line without translation.
+
+```lua
+buildoptions { "options" }
+```
+
+If a project includes multiple calls to **buildoptions** the lists are concatenated, in the order in which they appear in the script.
+
+## Applies To ##
+
+Solutions, projects, and configurations.
+
+## Parameters ##
+
+*options* is a list of compiler flags and options, specific to a particular compiler.
+
+## Examples ##
+
+Use `pkg-config` style configuration when building on Linux with GCC. Build options are always compiler specific and should be targeted to a particular toolset.
+
+```lua
+configuration { "linux", "gmake" }
+  buildoptions { "`wx-config --cxxflags`", "-ansi", "-pedantic" }
+```

website/versioned_sidebars/version-4.x-sidebars.json

@@ -0,0 +1,34 @@
+{
+  "version-4.x/mainSidebar": [
+    {
+      "collapsed": false,
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        "version-4.x/Home",
+        "version-4.x/What-Is-Premake",
+        "version-4.x/Building-Premake",
+        "version-4.x/Premake-Quick-Start"
+      ]
+    },
+    {
+      "collapsed": true,
+      "type": "category",
+      "label": "Guides",
+      "items": [
+        "version-4.x/Extending-Premake",
+        "version-4.x/Basic-Premake-Extension",
+        "version-4.x/Create-A-New-Action"
+      ]
+    },
+    {
+      "collapsed": false,
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        "version-4.x/buildaction",
+        "version-4.x/buildoptions"
+      ]
+    }
+  ]
+}

website/versions.json

@@ -0,0 +1,3 @@
+[
+  "4.x"
+]