gen_version.py

# Added generating of new version for each DX Compiler build. 

# There are 3 kinds of version:
# 1. **Official build**
# Built by using `hctbuild -official`. The version is based on the current DXIL version, latest official 
# release and a number of commits since then. The format is `dxil_major.dxil_minor.release_no.commit_count`.
# For example a current official version would be something like `1.5.1905.42`. The latest release 
# information is read from `utils\version\latest-release.json`. The `1905` corresponds to `dxil-2019-05-16`
# release branch and `42` is the number of commits since that release branch was created. For main branch 
# the `commit_count` will be incremented by 10000 to distinguish it from stabilized official release branch 
# builds. So the current official version of main would be someting like `1.5.1905.10042`.

# 2. **Dev build**
# Build by using `hctbuild` with no other version-related option. 
# The format is `dxil_major.dxil_minor.0.commit_count` where commit_count is the number of total commits 
# since the beginning of the project.

# 3. **Fixed version build**
# Build by using `hctbuild -fv`. Enables overriding of the version information. The fixed version is 
# read from `utils\version\version.inc`. Location of the version file can be overriden by `-fvloc` option
# on `hctbuild`.

# In addition to the numbered version the product version string on the binaries will also include branch
# name and last commit sha - `"1.5.1905.10042 (main, 47e31c8a)"`. This product version string is included 
# in `dxc -?` output.

import argparse
import json
import os
import re
import subprocess

def get_output_of(cmd):
    enlistment_root=os.path.dirname(os.path.abspath( __file__ ))
    output = subprocess.check_output(cmd, cwd=enlistment_root)
    return output.decode('ASCII').strip()

def is_dirty():
    diff = get_output_of(["git", "diff", "HEAD", "--shortstat"])
    return len(diff.strip()) != 0

def get_last_commit_sha():
    try:
        sha = get_output_of(["git", "rev-parse", "--short", "HEAD"])
        if is_dirty():
            sha += "-dirty"
        return sha
    except subprocess.CalledProcessError:
        return "00000000"

def get_current_branch():
    try:
        return get_output_of(["git", "rev-parse", "--abbrev-ref", "HEAD"])
    except subprocess.CalledProcessError:
        return "private"

def get_commit_count(sha):
    try:
        return get_output_of(["git", "rev-list", "--count", sha])
    except subprocess.CalledProcessError:
        return 0
    
def read_latest_release_info():
    latest_release_file = os.path.join(os.path.dirname(os.path.abspath( __file__)), "latest-release.json")
    with open(latest_release_file, 'r') as f:
        return json.load(f)

class VersionGen():
    def __init__(self, options):
        self.options = options
        self.latest_release_info = read_latest_release_info()
        self.current_branch = get_current_branch()
        self.rc_version_field_4_cache = None

    def tool_name(self):
        return self.latest_release_info.get("toolname",
            "dxcoob" if self.options.official else "dxc(private)")

    def rc_version_field_1(self):
        return self.latest_release_info["version"]["major"]

    def rc_version_field_2(self):
        minor = self.latest_release_info["version"]["minor"]
        # If this is a preview branch, we use the preview_minor field as the
        # minor version in the RC file. This allows us to have a different
        # minor version for preview releases, without changing the highest
        # released minor version.
        minor = self.latest_release_info["version"].get("preview_minor", minor)
        return minor

    def rc_version_field_3(self):
        return self.latest_release_info["version"]["rev"] if self.options.official else "0"

    def rc_version_field_4(self):
        if self.rc_version_field_4_cache is None:
            base_commit_count = 0
            if self.options.official:
                base_commit_count = int(get_commit_count(self.latest_release_info["sha"]))
            current_commit_count = int(get_commit_count("HEAD"))
            distance_from_base = current_commit_count - base_commit_count
            if (self.current_branch == "main"):
                distance_from_base += 10000
            self.rc_version_field_4_cache = str(distance_from_base)
        return self.rc_version_field_4_cache

    def quoted_version_str(self):
        return '"{}.{}.{}.{}"'.format(
            self.rc_version_field_1(),
            self.rc_version_field_2(),
            self.rc_version_field_3(),
            self.rc_version_field_4())

    def product_version_str(self):
        if (self.options.no_commit_sha):
            return self.quoted_version_str()
        pv = '"{}.{}.{}.{} '.format(
                self.rc_version_field_1(),
                self.rc_version_field_2(),
                self.rc_version_field_3(),
                self.rc_version_field_4())
        if (self.current_branch != "HEAD"):
             pv += '({}, {})"'.format(self.current_branch, get_last_commit_sha())
        else:
             pv += '({})"'.format(get_last_commit_sha())
        return pv

    def print_define(self, name, value):
        print('#ifdef {}'.format(name))
        print('#undef {}'.format(name))
        print('#endif')
        print('#define {} {}'.format(name, value))
        print()

    def print_version(self):
        print('#pragma once')
        print()
        self.print_define('RC_COMPANY_NAME',      '"Microsoft(r) Corporation"')
        self.print_define('RC_VERSION_FIELD_1',   self.rc_version_field_1())
        self.print_define('RC_VERSION_FIELD_2',   self.rc_version_field_2())
        self.print_define('RC_VERSION_FIELD_3',   self.rc_version_field_3() if self.options.official else "0")
        self.print_define('RC_VERSION_FIELD_4',   self.rc_version_field_4())
        self.print_define('RC_FILE_VERSION',      self.quoted_version_str())
        self.print_define('RC_FILE_DESCRIPTION', '"DirectX Compiler - Out Of Band"')
        self.print_define('RC_COPYRIGHT',        '"(c) Microsoft Corporation. All rights reserved."')
        self.print_define('RC_PRODUCT_NAME',     '"Microsoft(r) DirectX for Windows(r) - Out Of Band"')
        self.print_define('RC_PRODUCT_VERSION',   self.product_version_str())
        self.print_define('HLSL_TOOL_NAME',       '"{}"'.format(self.tool_name()))
        self.print_define('HLSL_VERSION_MACRO',   'HLSL_TOOL_NAME " " RC_FILE_VERSION')
        self.print_define('HLSL_LLVM_IDENT',      'HLSL_TOOL_NAME " " RC_PRODUCT_VERSION')


def main():
    p = argparse.ArgumentParser("gen_version")
    p.add_argument("--no-commit-sha", action='store_true')
    p.add_argument("--official", action="store_true")
    args = p.parse_args()

    VersionGen(args).print_version() 


if __name__ == '__main__':
    main()