linux-imx

#!/usr/bin/env python

# SPDX-License-Identifier: GPL-2.0

# Copyright Thomas Gleixner <tglx@linutronix.de>

​

from argparse import ArgumentParser

from ply import lex, yacc

import locale

import traceback

import sys

import git

import re

import os

​

class ParserException(Exception):

    def __init__(self, tok, txt):

        self.tok = tok

        self.txt = txt

​

class SPDXException(Exception):

    def __init__(self, el, txt):

        self.el = el

        self.txt = txt

​

class SPDXdata(object):

    def __init__(self):

        self.license_files = 0

        self.exception_files = 0

        self.licenses = [ ]

        self.exceptions = { }

​

# Read the spdx data from the LICENSES directory

def read_spdxdata(repo):

​

    # The subdirectories of LICENSES in the kernel source

    license_dirs = [ "preferred", "other", "exceptions" ]

    lictree = repo.head.commit.tree['LICENSES']

​

    spdx = SPDXdata()

​

    for d in license_dirs:

        for el in lictree[d].traverse():

            if not os.path.isfile(el.path):

                continue

​

            exception = None

            for l in open(el.path).readlines():

                if l.startswith('Valid-License-Identifier:'):

                    lid = l.split(':')[1].strip().upper()

                    if lid in spdx.licenses:

                        raise SPDXException(el, 'Duplicate License Identifier: %s' %lid)

                    else:

                        spdx.licenses.append(lid)

​

                elif l.startswith('SPDX-Exception-Identifier:'):

                    exception = l.split(':')[1].strip().upper()

                    spdx.exceptions[exception] = []

​

                elif l.startswith('SPDX-Licenses:'):

                    for lic in l.split(':')[1].upper().strip().replace(' ', '').replace('\t', '').split(','):

                        if not lic in spdx.licenses:

                            raise SPDXException(None, 'Exception %s missing license %s' %(ex, lic))

                        spdx.exceptions[exception].append(lic)

​

                elif l.startswith("License-Text:"):

                    if exception:

                        if not len(spdx.exceptions[exception]):

                            raise SPDXException(el, 'Exception %s is missing SPDX-Licenses' %excid)

                        spdx.exception_files += 1

                    else:

                        spdx.license_files += 1

                    break

    return spdx

​

class id_parser(object):

​

    reserved = [ 'AND', 'OR', 'WITH' ]

    tokens = [ 'LPAR', 'RPAR', 'ID', 'EXC' ] + reserved

​

    precedence = ( ('nonassoc', 'AND', 'OR'), )

​

    t_ignore = ' \t'

​

    def __init__(self, spdx):

        self.spdx = spdx

        self.lasttok = None

        self.lastid = None

        self.lexer = lex.lex(module = self, reflags = re.UNICODE)

        # Initialize the parser. No debug file and no parser rules stored on disk

        # The rules are small enough to be generated on the fly

        self.parser = yacc.yacc(module = self, write_tables = False, debug = False)

        self.lines_checked = 0

        self.checked = 0