diff --git a/scripts/generate_psa_constants.py b/scripts/generate_psa_constants.py
index 997bd3c..d772a77 100755
--- a/scripts/generate_psa_constants.py
+++ b/scripts/generate_psa_constants.py
@@ -10,7 +10,7 @@
 import re
 import sys
 
-output_template = '''\
+OUTPUT_TEMPLATE = '''\
 /* Automatically generated by generate_psa_constant.py. DO NOT EDIT. */
 
 static const char *psa_strerror(psa_status_t status)
@@ -154,19 +154,19 @@
 /* End of automatically generated file. */
 '''
 
-key_type_from_curve_template = '''if (%(tester)s(type)) {
+KEY_TYPE_FROM_CURVE_TEMPLATE = '''if (%(tester)s(type)) {
             append_with_curve(&buffer, buffer_size, &required_size,
                               "%(builder)s", %(builder_length)s,
                               PSA_KEY_TYPE_GET_CURVE(type));
         } else '''
 
-key_type_from_group_template = '''if (%(tester)s(type)) {
+KEY_TYPE_FROM_GROUP_TEMPLATE = '''if (%(tester)s(type)) {
             append_with_group(&buffer, buffer_size, &required_size,
                               "%(builder)s", %(builder_length)s,
                               PSA_KEY_TYPE_GET_GROUP(type));
         } else '''
 
-algorithm_from_hash_template = '''if (%(tester)s(core_alg)) {
+ALGORITHM_FROM_HASH_TEMPLATE = '''if (%(tester)s(core_alg)) {
             append(&buffer, buffer_size, &required_size,
                    "%(builder)s(", %(builder_length)s + 1);
             append_with_alg(&buffer, buffer_size, &required_size,
@@ -175,7 +175,7 @@
             append(&buffer, buffer_size, &required_size, ")", 1);
         } else '''
 
-bit_test_template = '''\
+BIT_TEST_TEMPLATE = '''\
     if (%(var)s & %(flag)s) {
         if (required_size != 0) {
             append(&buffer, buffer_size, &required_size, " | ", 3);
@@ -274,102 +274,104 @@
         for line in header_file:
             self.read_line(line)
 
-    def make_return_case(self, name):
+    @staticmethod
+    def _make_return_case(name):
         return 'case %(name)s: return "%(name)s";' % {'name': name}
 
-    def make_append_case(self, name):
+    @staticmethod
+    def _make_append_case(name):
         template = ('case %(name)s: '
                     'append(&buffer, buffer_size, &required_size, "%(name)s", %(length)d); '
                     'break;')
         return template % {'name': name, 'length': len(name)}
 
-    def make_inner_append_case(self, name):
-        template = ('case %(name)s: '
-                    'append(buffer, buffer_size, required_size, "%(name)s", %(length)d); '
-                    'break;')
-        return template % {'name': name, 'length': len(name)}
-
-    def make_bit_test(self, var, flag):
-        return bit_test_template % {'var': var,
+    @staticmethod
+    def _make_bit_test(var, flag):
+        return BIT_TEST_TEMPLATE % {'var': var,
                                     'flag': flag,
                                     'length': len(flag)}
 
-    def make_status_cases(self):
-        return '\n    '.join(map(self.make_return_case,
+    def _make_status_cases(self):
+        return '\n    '.join(map(self._make_return_case,
                                  sorted(self.statuses)))
 
-    def make_ecc_curve_cases(self):
-        return '\n    '.join(map(self.make_return_case,
+    def _make_ecc_curve_cases(self):
+        return '\n    '.join(map(self._make_return_case,
                                  sorted(self.ecc_curves)))
 
-    def make_dh_group_cases(self):
-        return '\n    '.join(map(self.make_return_case,
+    def _make_dh_group_cases(self):
+        return '\n    '.join(map(self._make_return_case,
                                  sorted(self.dh_groups)))
 
-    def make_key_type_cases(self):
-        return '\n    '.join(map(self.make_append_case,
+    def _make_key_type_cases(self):
+        return '\n    '.join(map(self._make_append_case,
                                  sorted(self.key_types)))
 
-    def make_key_type_from_curve_code(self, builder, tester):
-        return key_type_from_curve_template % {'builder': builder,
+    @staticmethod
+    def _make_key_type_from_curve_code(builder, tester):
+        return KEY_TYPE_FROM_CURVE_TEMPLATE % {'builder': builder,
                                                'builder_length': len(builder),
                                                'tester': tester}
 
-    def make_key_type_from_group_code(self, builder, tester):
-        return key_type_from_group_template % {'builder': builder,
+    @staticmethod
+    def _make_key_type_from_group_code(builder, tester):
+        return KEY_TYPE_FROM_GROUP_TEMPLATE % {'builder': builder,
                                                'builder_length': len(builder),
                                                'tester': tester}
 
-    def make_ecc_key_type_code(self):
+    def _make_ecc_key_type_code(self):
         d = self.key_types_from_curve
-        make = self.make_key_type_from_curve_code
+        make = self._make_key_type_from_curve_code
         return ''.join([make(k, d[k]) for k in sorted(d.keys())])
 
-    def make_dh_key_type_code(self):
+    def _make_dh_key_type_code(self):
         d = self.key_types_from_group
-        make = self.make_key_type_from_group_code
+        make = self._make_key_type_from_group_code
         return ''.join([make(k, d[k]) for k in sorted(d.keys())])
 
-    def make_hash_algorithm_cases(self):
-        return '\n    '.join(map(self.make_return_case,
+    def _make_hash_algorithm_cases(self):
+        return '\n    '.join(map(self._make_return_case,
                                  sorted(self.hash_algorithms)))
 
-    def make_ka_algorithm_cases(self):
-        return '\n    '.join(map(self.make_return_case,
+    def _make_ka_algorithm_cases(self):
+        return '\n    '.join(map(self._make_return_case,
                                  sorted(self.ka_algorithms)))
 
-    def make_algorithm_cases(self):
-        return '\n    '.join(map(self.make_append_case,
+    def _make_algorithm_cases(self):
+        return '\n    '.join(map(self._make_append_case,
                                  sorted(self.algorithms)))
 
-    def make_algorithm_from_hash_code(self, builder, tester):
-        return algorithm_from_hash_template % {'builder': builder,
+    @staticmethod
+    def _make_algorithm_from_hash_code(builder, tester):
+        return ALGORITHM_FROM_HASH_TEMPLATE % {'builder': builder,
                                                'builder_length': len(builder),
                                                'tester': tester}
 
-    def make_algorithm_code(self):
+    def _make_algorithm_code(self):
         d = self.algorithms_from_hash
-        make = self.make_algorithm_from_hash_code
+        make = self._make_algorithm_from_hash_code
         return ''.join([make(k, d[k]) for k in sorted(d.keys())])
 
-    def make_key_usage_code(self):
-        return '\n'.join([self.make_bit_test('usage', bit)
+    def _make_key_usage_code(self):
+        return '\n'.join([self._make_bit_test('usage', bit)
                           for bit in sorted(self.key_usages)])
 
     def write_file(self, output_file):
+        """Generate the pretty-printer function code from the gathered
+        constant definitions."""
         data = {}
-        data['status_cases'] = self.make_status_cases()
-        data['ecc_curve_cases'] = self.make_ecc_curve_cases()
-        data['dh_group_cases'] = self.make_dh_group_cases()
-        data['key_type_cases'] = self.make_key_type_cases()
-        data['key_type_code'] = (self.make_ecc_key_type_code() +
-                                 self.make_dh_key_type_code())
-        data['hash_algorithm_cases'] = self.make_hash_algorithm_cases()
-        data['ka_algorithm_cases'] = self.make_ka_algorithm_cases()
-        data['algorithm_cases'] = self.make_algorithm_cases()
-        data['algorithm_code'] = self.make_algorithm_code()
-        data['key_usage_code'] = self.make_key_usage_code()
-        output_file.write(output_template % data)
+        data['status_cases'] = self._make_status_cases()
+        data['ecc_curve_cases'] = self._make_ecc_curve_cases()
+        data['dh_group_cases'] = self._make_dh_group_cases()
+        data['key_type_cases'] = self._make_key_type_cases()
+        data['key_type_code'] = (self._make_ecc_key_type_code() +
+                                 self._make_dh_key_type_code())
+        data['hash_algorithm_cases'] = self._make_hash_algorithm_cases()
+        data['ka_algorithm_cases'] = self._make_ka_algorithm_cases()
+        data['algorithm_cases'] = self._make_algorithm_cases()
+        data['algorithm_code'] = self._make_algorithm_code()
+        data['key_usage_code'] = self._make_key_usage_code()
+        output_file.write(OUTPUT_TEMPLATE % data)
 
 def generate_psa_constants(header_file_names, output_file_name):
     collector = MacroCollector()