Refactor the generator

Author: IvanUkhov

bin/function.py

@@ -5,7 +5,7 @@
 return_re = re.compile('(?:\s*->\s*([^;]+))?')
 
 
-class Function(object):
+class Function():
 
     def __init__(self, name, args, ret):
         self.name = name
@@ -25,8 +25,6 @@ def parse(line):
             arg, aty, line = pull_argument(line)
             if arg is None:
                 break
-            if arg == 'matrix_layout':
-                arg = 'layout'
             args.append((arg, aty))
             line = line.strip()
 
@@ -55,7 +53,7 @@ def pull_return(s):
     return match.group(1), s[match.end(1):]
 
 
-def read_functions(path):
+def read(path):
     lines = []
     with open(path) as file:
         append = False

bin/generate.py

@@ -5,13 +5,13 @@
 import re
 
 from function import Function
-from function import read_functions
+from function import read
 
 select_re = re.compile('LAPACK_(\w)_SELECT(\d)')
 
 
 def is_scalar(name, cty, f):
-    return (
+    return ( \
         'c_char' in cty or
         name in [
             'abnrm',
@@ -73,7 +73,33 @@ def is_scalar(name, cty, f):
     )
 
 
-def translate_argument(name, cty, f):
+def translate_name(name):
+    mapping = {
+        'matrix_layout': 'layout',
+    }
+    return mapping.get(name, name)
+
+
+def translate_base_type(cty):
+    if 'c_char' in cty:
+        return 'u8'
+    elif 'c_float' in cty:
+        return 'f32'
+    elif 'c_double' in cty:
+        return 'f64'
+    elif 'lapack_int' in cty:
+        return 'i32'
+    elif 'lapack_logical' in cty:
+        return 'i32'
+    elif 'lapack_complex_float' in cty:
+        return 'c32'
+    elif 'lapack_complex_double' in cty:
+        return 'c64'
+
+    assert False, 'cannot translate `{}`'.format(cty)
+
+
+def translate_signature_type(name, cty, f):
     if name == 'layout':
         return 'Layout'
 
@@ -88,7 +114,7 @@ def translate_argument(name, cty, f):
         elif m.group(1) == 'Z':
             return 'Select{}C64'.format(m.group(2))
 
-    base = translate_type_base(cty)
+    base = translate_base_type(cty)
     if '*const' in cty:
         if is_scalar(name, cty, f):
             return base
@@ -103,25 +129,6 @@ def translate_argument(name, cty, f):
     return base
 
 
-def translate_type_base(cty):
-    if 'c_char' in cty:
-        return 'u8'
-    elif 'c_float' in cty:
-        return 'f32'
-    elif 'c_double' in cty:
-        return 'f64'
-    elif 'lapack_int' in cty:
-        return 'i32'
-    elif 'lapack_logical' in cty:
-        return 'i32'
-    elif 'lapack_complex_float' in cty:
-        return 'c32'
-    elif 'lapack_complex_double' in cty:
-        return 'c64'
-
-    assert False, 'cannot translate `{}`'.format(cty)
-
-
 def translate_body_argument(name, rty):
     if rty == 'Layout':
         return '{}.into()'.format(name)
@@ -164,56 +171,48 @@ def translate_body_argument(name, rty):
     assert False, 'cannot translate `{}: {}`'.format(name, rty)
 
 
-def translate_return_type(cty):
-    if cty == 'lapack_int':
-        return 'i32'
-    elif cty == 'c_float':
-        return 'f32'
-    elif cty == 'c_double':
-        return 'f64'
-
-    assert False, 'cannot translate `{}`'.format(cty)
-
-
-def format_header(f):
-    args = format_header_arguments(f)
+def format_signature(f):
+    args = format_signature_arguments(f)
     if f.ret is None:
         return 'pub unsafe fn {}({})'.format(f.name, args)
     else:
-        return 'pub unsafe fn {}({}) -> {}'.format(f.name, args, translate_return_type(f.ret))
+        return 'pub unsafe fn {}({}) -> {}'.format(f.name, args,
+                                                   translate_base_type(f.ret))
 
 
-def format_body(f):
-    return 'ffi::LAPACKE_{}({})'.format(f.name, format_body_arguments(f))
-
-
-def format_header_arguments(f):
+def format_signature_arguments(f):
     s = []
-    for arg in f.args:
-        s.append('{}: {}'.format(arg[0], translate_argument(*arg, f=f)))
+    for name, cty in f.args:
+        name = translate_name(name)
+        s.append('{}: {}'.format(name, translate_signature_type(name, cty, f)))
     return ', '.join(s)
 
 
+def format_body(f):
+    return 'ffi::LAPACKE_{}({})'.format(f.name, format_body_arguments(f))
+
+
 def format_body_arguments(f):
     s = []
-    for arg in f.args:
-        rty = translate_argument(*arg, f=f)
-        s.append(translate_body_argument(arg[0], rty))
+    for name, cty in f.args:
+        name = translate_name(name)
+        rty = translate_signature_type(name, cty, f)
+        s.append(translate_body_argument(name, rty))
     return ', '.join(s)
 
 
-def prepare(code):
+def process(code):
     lines = filter(lambda line: not re.match(r'^\s*//.*', line),
                    code.split('\n'))
     lines = re.sub(r'\s+', ' ', ''.join(lines)).strip().split(';')
     lines = filter(lambda line: not re.match(r'^\s*$', line), lines)
     return [Function.parse(line) for line in lines]
 
 
-def do(functions):
+def write(functions):
     for f in functions:
         print('\n#[inline]')
-        print(format_header(f) + ' {')
+        print(format_signature(f) + ' {')
         print('    ' + format_body(f) + '\n}')
 
 
@@ -222,4 +221,4 @@ def do(functions):
     parser.add_argument('--sys', default='lapacke-sys')
     arguments = parser.parse_args()
     path = os.path.join(arguments.sys, 'src', 'lib.rs')
-    do(prepare(read_functions(path)))
+    write(process(read(path)))