Rune - Pass-through -O[n], drop more insns in RAS

[rune.git] / COPYRIGHT

                            RUNE LANGUAGE COPYRIGHT

    This software is (c)Copyright 1993-2016 by Matthew Dillon.  Use of
    this code and binaries produced by this code are governed by the
    following stipulations:

    (1) All files making up the Rune distribution are defined as "the product"
        and subject to these terms.

    (2) There are two Rune Language licenses:  A commercial license, and a
        free license.  The license you need depends on the conditions under
        which you use this program.  Most open-source programmers and users
        will fall under the free license.

        The free license, when applicable, does NOT require registration or
        a signed contract.  Commercial licenses are negotiated on a
        case-by-case basis.

    (3) All uses of the product are governed by these copyright terms PLUS
        the license terms under the appropriate license.  WITHOUT A LICENSE,
        YOU HAVE NO RIGHTS AT ALL TO USE OR MODIFY THIS PRODUCT.  IF THE
        LICENSE IS DEEMED WHOLELY INVALID, YOU HAVE NO RIGHTS AT ALL TO USE
        OR MODIFY THIS PRODUCT.

    (4) NON TRANSFERABILITY: Unless otherwise stated, licenses are 
        non-transferable.  This means that it applies to you and does not
        automatically transfer to the people you distribute your product to.
        In order to use the product you have distributed, those people will
        be subject to the same copyright terms and MAY OR MAY NOT qualify for
        their own separate, free, unregistered license.

    (5) This copyright notice, applicable licenses, copyright notices in
        all distributed source code and documentation, and copyright notices
        embedded in object code and binaries, must be retained at all times,
        even when codebase modifications are allowed.  In particular, the
        copyright and license must be retained and readily accessible in
        the directory tree containing the the files it applies to.  If you
        are managing code with a repository (for example, git), the copyright
        and license must also be retained in the repository.

    (6) Any documentation referencing this work must refer to or contain
        this copyright notice and the following acknowledgement: "This product
        includes software developed by Matthew Dillon and contributors.".

        ---------------------------------------------------------
                        The "FREE" Rune Language License
                               (when applicable)

    Synopsis: This license is designed to support and promote an open-source
    and open-use environment while still protecting the author's interests
    in preventing misuse.  All use of this distribution not covered by this
    license requires a negotiated commercial license.

    (1) There are distinctions between using this product, porting
        modifications, enhancement modifications, integrations, and
        redistributions.  This license may be used for these purposes
        in the limited fashion covered in the clauses below.

        Clause (1) covers binary derived works (below).
        Clause (2) covers using the product.
        Clause (3) covers porting modifications.
        Clause (4) covers enhancements.
        Clause (5) covers integrations.
        Clause (6) covers packaging systems.

        When you write a program in Rune, intermediate, library, and binary
        files will contain some copyrighted Rune code simply by being linked
        against the rune core and the runtime will also have dynamic library
        dependencies against the rune core.  You are granted a perpetual,
        non-revocable license to be able to run such binaries as well as to
        distribute such binaries and the related run-time support
        infrastructure commercially or non-commercially, as long as your
        application is not substantially similar to the Rune product itself
        (e.g. not used to simply wrap our product, with or without enhancement).

        Your own wholely written source files and the derived program binary
        itself is yours, you can copyright and license them as you wish.  The
        specific elements of Rune embedded in these files (such as the Rune
        grammar) are not yours, but operate under a perpetual license which
        allows your program binary to use them.

    (2) Using Rune is defined as downloading, compiling, installing, and
        then using the Rune binaries and libraries to write your own
        applications in the Rune language.

        Just as with most computer languages, installing and using the rune
        environment is unrevocably free and covered by the free license.

    (3) Porting modifications.  Any commercial or non-commercial entity can
        make modifications to the Rune distribution for the purpose of
        porting the distribution to an architecture under the following
        stipulations.

        * If you distribute your modifications or anything derived from your
          modifications, including binaries, you agree to make all such
          modifications available in patch or GIT form as an
          internet-accessible publically available patch or GIT repo,
          and:

        * You agree to relinquish all the rights releaseable under your
          country's law to said modifications such that anyone else can use
          your modifications, including any recopyrighting and relicensing,
          almost as if they were in the public domain.  In return, anyone
          using your modifications agrees to attribute them to you.  A
          GIT commit message in the repo is considered sufficient, and
          if the modification is significant enough the person using your
          modifications (under his sole discretion) may also add the author
          of the modification to the contributors list at the top of the file.

          The Rune copyright holder (Matthew Dillon) will specifically use
          this release to integrate patches into the main distribution under
          the Rune copyright.

        * If the law does not allow the degree of freedom required to allow
          others to use modifications as stipulated, then you may not make
          modifications under this clause.

        * Contributions to the project are assumed to be made as a good
          faith donation as stipulated above.  For example, if a patch is
          mailed to us, posted on a public forum, or integrated into any
          open-source distribution.  We assume these to be contributions
          that fall under these stipulations.

          If you do this mistakenly and do not wish to contribute the
          material, within a reasonable period of time of 6 months or as
          allowed by law from when you published it, you must notify us and
          we will withdraw it from the public.  Your only recourse is that
          it be withdrawn from the HEAD of the repo and no longer used in
          ongoing distributions down the line.  The repo history will remain
          intact.

        * The author of any modifications stipulates that they are entirely 
          his own work and that he or she agrees to the terms of the license.
          If multiple authors, that all authors have read and agree to the
          terms of this license.

        * These stipulates remain in effect whether the copyright holder
          of the product (Matthew Dillon) decides to integrate the
          modifications into the base distribution or not.

        * Again, as a clarification, you cannot apply your own license or
          copyright to modifications, even whole-file modifications.

          In the open-source world, authors typically name themselves in
          source files via a copyright line near the top of the file.  We
          wish to allow authors to include their names in source files but
          it cannot be done with a copyright line.  Instead, you may add
          your name in comments near the top of a source file using the
          following example form:

          /*
           * Contributor - Charlie Chan <charlie@backplane.com> - bug fixes
           */

          or (if Rune code)

           #
           # ... other contributors ...
           # Contributor - Charlie Chan <charlie@backplane.com> - bug fixes
           #

    (4) An 'enhancement' is defined to be the addition of any new feature
        to Rune.  As a clarification, features include optimizations,
        grammar changes, additions to the core classes, and anything else
        that adds functionality to the Rune language that isn't a simple
        patch for porting purposes or bug fix to existing functionality.

        This clause is meant to control the open-source forking problem that
        can quickly destroy portability (particularly for a language), and
        indeed can destroy the whole project.  Enhancements can be made with
        the following stipulations:

        * All stipulations in section (3).

        * Your enhancements are being made with the intent of getting them
          back into the core distribution.  The copyright holder and core
          team for Rune have final say on whether features and enhancements
          go in or not.  We will probably say 'no' a lot, we do not want Rune
          to become a kitchen-sink language and complex features have to be
          extremely well-tested before they can be considered for inclusion.
          On the otherhand, there is a huge amount of work that needs to
          be done especially on the core classes.

        * You cannot fork the project, meaning you can't take rejected
          enhancements and start your own project up to support them.
          That said, we need and expect contributors to maintain their
          own GIT repos with all their work.  Theoretically these repos
          are a fork of a sort, but there is a big difference between using
          a repo to hold side branches in a supporting role and using copies
          of the repo in a primary role.  We distinguish between these two
          use cases.

          Using copies of the repo in a supporting role is fully supported
          and allowed by this clause.

        * SUNSET CLAUSE FOR FORK RESTRICTIONS - The restriction on forking
          the project will be lifted on December 31 2018.  The project
          forking stipulation above will no longer be applicable and can be
          removed on that date.
          
    (5) We consider an 'integration' of our product to be any situation where
        a substantial portion of the functionality of our product, such as
        being able to parse, compile, assemble, link, or interpret a Rune
        program (including JIT compilation), is repackaged into some other
        distribution not under our (the copyright holder, Matthew Dillon's)
        control.  Integrations are governed by the following stipulations:

        * Integration into any non-commercial open-source product is allowed,
          defined as any product governed by the BSD or any GPL license whos
          controlling entity is not also distributing (or associated with an
          entity distributing) a proprietary form of the product.

          For example, Rune could be integrated into most linux distributions
          under this clause.

        * Integration into any commercial product or by any commercial
          entity who distributes a proprietary form of an open-source
          product requires a commercial license.  The Free license may not
          be used in this case.

        * A commercial license is required for any other integration of Rune. 
          Also, keep in mind that this license is not transferable so any
          users of your distribution must separately qualify for the free
          license or obtain their own.

    (6) Packaging.  Any packaging system which packages the core Rune
        distribution, unenhanced, with only porting modifications which
        follow clause (3), may use this license to generate the port,
        maintain a copy of the sources, and build and host binary
        distributions.

    (7) LIMITED-REVOKABILITY of the FREE license by Matthew Dillon.  This
        clause exists to protect the integrity of the Free License for both
        the licensee and the copyright holder, protecting both sides from
        extreme levels of liability should a conflict arise.  This clause
        does NOT prevent the copyright holder (Matthew Dillon) from filing
        a lawsuit based on copyright law, but it does say in writing what the
        intent of the copyright holder is and any judge is expected to take
        that into account.

        By using this software the licensee is agreeing to the terms and
        conditions of this license.  The Free license is not revocable when
        used in good faith.  However, situations may arise where the licensee
        does not act in good faith.

        The copyright holder (Matthew Dillon) reserves the right to revoke
        the free license if he believes the licensee is not using it in
        good faith.  Upon notification, the licensee is no longer able to use
        the Free license and must immediately stop using the product.  If
        the licensee stops using the product and does not contest the
        revocation the conflict is considered resolved.

        The licensee has the right to contest the revocation by posting
        bond within 30 days at the going rate (as determined by the mediation
        company chosen by the copyright holder) for a licensed mediator to
        resolve the conflict.  If the revocation is not contested within
        the time limit the mediation option is taken off the table and the
        copyright holder (Matthew Dillon) may resort to a lawsuit.

        If bond is posted within the time limit or as otherwise agreed to
        by the copyright holder if past the time-limit, The copyright holder
        (Matthew Dillon) will then hire a licensed mediator who will then
        mediate the conflict within 30 days and render a final verdict.
        The question to the mediator is solely as to whether the free license
        was applicable to the licensee's use case or not, it is not meant to
        adjudicate royalties or other payments (though such conversations can
        occur directly between licensee and copyright holder).

        If the copyright holder wins the licensee pays for the mediation via
        the bond and the licensee agrees to stop using the product.  If the
        licensee wins the bond is returned and the copyright holder
        (Matthew Dillon) pays for the mediation.

        Note that 'good faith' is a matter of interpretation.  It is not meant
        to be a strict reading of the license, but it is meant to distinguish
        between honest mistakes and intentional actions.  Of course, given
        notification of a mistake, an honest mistake can quickly turn into an
        intentional one if the licensee does not quickly address it.  The
        mediator is asked to take this into account as well.

        Once revoked, the person or entity in question will no longer be
        able to use the Free license for Rune for any purpose, indefinitely,
        and must withdraw any products already distributed or sold using
        the license, and any future products.

    (8) LIMITED LIABILITY.  THIS SOFTWARE IS PROVIDED BY MATTHEW DILLON AND
        CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
        INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
        MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
        IN NO EVENT SHALL MATT DILLON OR CONTRIBUTORS BE LIABLE FOR ANY
        DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
        GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
        INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
        IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
        OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
        EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    (9) Sunset provision for entire project.  On December 31st 2030 the
        copyright on the official distribution will be replaced with the
        2-clause BSD copyright in its entirely.  This license will no longer
        be applicable at that time and instead of the almost-public-domain
        BSD license will become applicable, allowing the codebase to be
        used for virtually any purpose by virtually anyone, commercial or
        not.

        ---------------------------------------------------------
                        Examples of Free vs Commercial use.

    These examples are meant to clarify the intent of our copyright and
    license.  These examples are not part of the official copyright or
    license, but may be used by mediator or the courts for clarification.
    Generally speaking my goal is for Rune to be freely useable in
    open-source-friendly settings but I want a piece of the pie if a
    commercial entity integrates it into a commercial product.  A commercial
    license is generally required when you wish to make proprietary 
    modifications or extensions to Rune, or integrate Rune into a commercial
    product.  If you aren't sure, assume that a commercial license is required.

    * Lets say you are FreeBSD or Debian and you wish to distribute Rune
      as part of the base system or as a package, including hosting copies
      of the repo and/or binary packages.  The Free license will allow you
      to do so.  Keep in mind that any patches you place in the ports
      system must adhere to clause (3).

    * Lets say you are a commercial CD printing outfit and wish to include
      Rune on one of your CDs, which you sell.  The Free license will allow
      you to do so under clause (5)... that is, if the CD printing outfit is
      merely redistributing a wholely open-source product as a product and
      not distributing its own proprietary version of the product, then it
      may use clause (5).  However if the CD printing outfit wants to
      sell both a fully-open-source and a proprietatry product, then a
      commercial license is required for both

    * Lets say you are a company that wishes to make proprietary modifications
      to Rune and sell the result.  A Commercial license would be required.

    * Lets say you are a company that wishes to create proprietary extensions
      to Rune, for example by interfacing it to your own proprietary backend.
      We consider this an enhancement (even if it operates as a separate
      program) and not an application and you would need a commercial license.

    * Lets say you are a company that wishes to incorporate Rune into your
      proprietary commercial application in order to allow users of your
      application to write code in Rune via the application.  We consider
      this a proprietary 'Integration' of our product and a commercial
      license would be required.

    * Lets say you are a company that uses Rune to develop an application.
      You can distribute binaries of your application without having to
      get a Rune Commercial License.

    * Lets say you want to rebrand Rune and sell the result.  We consider
      this wrapping and a commercial license would be required.

    * Lets say you wish certain negotiated rights to be transfered to the
      end-user.  Since the Free License is non-transferable you would need
      a commercial license to be able to grant your end-users negotiated
      rights.  For example, if you want to give your end-users the right
      to make proprietary extensions to Rune libraries you would need a
      commercial license from us because the Free License does not provide
      any such right.