Palamida scan fix (#68)

* Changed copyright statements to meet AMD requirements.

* Re-engineering Hipify Trie:
(1) Re-engineering Trie.
(2) More documentation or comments for easier understanding

Ported from: pytorch/pytorch#118433

Author: wenchenvincent

Diff for: LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017 AMD Compute Libraries
+Copyright (c) 2021-2024, Advanced Micro Devices, Inc. All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Diff for: hipify_torch/hipify_python.py

@@ -628,40 +628,66 @@ def is_caffe2_gpu_file(rel_filepath):
     _, ext = os.path.splitext(filename)
     return ('gpu' in filename or ext in ['.cu', '.cuh']) and ('cudnn' not in filename)
 
+class TrieNode:
+    """A Trie node whose children are represented as a directory of char: TrieNode.
+       A special char '' represents end of word
+    """
+
+    def __init__(self):
+        self.children = {}
 
-# Cribbed from https://stackoverflow.com/questions/42742810/speed-up-millions-of-regex-replacements-in-python-3/42789508#42789508
-class Trie():
-    """Regex::Trie in Python. Creates a Trie out of a list of words. The trie can be exported to a Regex pattern.
+class Trie:
+    """Creates a Trie out of a list of words. The trie can be exported to a Regex pattern.
     The corresponding Regex should match much faster than a simple Regex union."""
 
     def __init__(self):
-        self.data = {}
+        """Initialize the trie with an empty root node."""
+        self.root = TrieNode()
 
     def add(self, word):
-        ref = self.data
+        """Add a word to the Trie. """
+        node = self.root
+
         for char in word:
-            ref[char] = char in ref and ref[char] or {}
-            ref = ref[char]
-        ref[''] = 1
+            node.children.setdefault(char, TrieNode())
+            node = node.children[char]
+        node.children[''] = True    # Mark the end of the word
 
     def dump(self):
-        return self.data
+        """Return the root node of Trie. """
+        return self.root
 
     def quote(self, char):
+        """ Escape a char for regex. """
         return re.escape(char)
 
-    def _pattern(self, pData):
-        data = pData
-        if "" in data and len(data.keys()) == 1:
+    def search(self, word):
+        """Search whether word is present in the Trie.
+        Returns True if yes, else return False"""
+        node = self.root
+        for char in word:
+            if char in node.children:
+                node = node.children[char]
+            else:
+                return False
+
+        # make sure to check the end-of-word marker present
+        return '' in node.children
+
+    def _pattern(self, root):
+        """Convert a Trie into a regular expression pattern"""
+        node = root
+
+        if "" in node.children and len(node.children.keys()) == 1:
             return None
 
-        alt = []
-        cc = []
-        q = 0
-        for char in sorted(data.keys()):
-            if isinstance(data[char], dict):
+        alt = []    # store alternative patterns
+        cc = []     # store char to char classes
+        q = 0       # for node representing the end of word
+        for char in sorted(node.children.keys()):
+            if isinstance(node.children[char], TrieNode):
                 try:
-                    recurse = self._pattern(data[char])
+                    recurse = self._pattern(node.children[char])
                     alt.append(self.quote(char) + recurse)
                 except Exception:
                     cc.append(self.quote(char))
@@ -684,12 +710,16 @@ def _pattern(self, pData):
             if cconly:
                 result += "?"
             else:
-                result = "(?:%s)?" % result
+                result = f"(?:{result})?"
         return result
 
     def pattern(self):
-        return self._pattern(self.dump())
+        """Export the Trie to a regex pattern."""
+        return self._pattern(self.root)
 
+    def export_to_regex(self):
+        """Export the Trie to a regex pattern."""
+        return self._pattern(self.root)
 
 CAFFE2_TRIE = Trie()
 CAFFE2_MAP = {}
@@ -724,8 +754,8 @@ def pattern(self):
         if constants.API_PYTORCH not in meta_data:
             CAFFE2_TRIE.add(src)
             CAFFE2_MAP[src] = dst
-RE_CAFFE2_PREPROCESSOR = re.compile(CAFFE2_TRIE.pattern())
-RE_PYTORCH_PREPROCESSOR = re.compile(r'(?<=\W)({0})(?=\W)'.format(PYTORCH_TRIE.pattern()))
+RE_CAFFE2_PREPROCESSOR = re.compile(CAFFE2_TRIE.export_to_regex())
+RE_PYTORCH_PREPROCESSOR = re.compile(r'(?<=\W)({0})(?=\W)'.format(PYTORCH_TRIE.export_to_regex()))
 
 RE_QUOTE_HEADER = re.compile(r'#include "([^"]+)"')
 RE_ANGLE_HEADER = re.compile(r'#include <([^>]+)>')