Update the code-generation setup

Author: IvanUkhov

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lapack-sys"]
+	path = lapack-sys
+	url = https://github.com/blas-lapack-rs/lapack-sys.git

README.md

@@ -26,6 +26,16 @@ for (one, another) in w.iter().zip(&[2.0, 2.0, 5.0]) {
 }
 ```
 
+## Development
+
+The code is generated via a Python script based on the content the `lapack-sys`
+submodule. To re-generate, run the following commands:
+
+```sh
+./bin/generate.py > src/lapack-sys.rs
+rustfmt src/lapack-sys.rs
+```
+
 ## Contribution
 
 Your contribution is highly appreciated. Do not hesitate to open an issue or a

bin/function.py

@@ -4,7 +4,9 @@
 name_re = re.compile('\s*pub fn (?:LAPACKE_)?(\w+[a-z0-9])(_?)')
 return_re = re.compile('(?:\s*->\s*([^;]+))?')
 
+
 class Function(object):
+
     def __init__(self, name, args, ret):
         self.name = name
         self.args = args
@@ -16,7 +18,7 @@ def parse(line):
         if name is None:
             return None
 
-        assert(line[0] == '(')
+        assert line[0] == '('
         line = line[1:]
         args = []
         while True:
@@ -32,23 +34,27 @@ def parse(line):
 
         return Function(name, args, ret)
 
+
 def pull_argument(s):
     match = argument_re.match(s)
     if match is None:
         return None, None, s
     return match.group(1), match.group(2), s[match.end(3):]
 
+
 def pull_name(s):
     match = name_re.match(s)
-    assert(match is not None)
+    assert match is not None
     return match.group(1), s[match.end(2):]
 
+
 def pull_return(s):
     match = return_re.match(s)
     if match is None:
         return None, s
     return match.group(1), s[match.end(1):]
 
+
 def read_functions(path):
     lines = []
     with open(path) as file:

bin/generate.py

@@ -1,17 +1,14 @@
 #!/usr/bin/env python
 
-from function import Function, read_functions
 import argparse
 import os
 import re
 
-select_re = re.compile('LAPACK_(\w)_SELECT(\d)')
+from function import Function
+from function import read_functions
 
-def is_const(name, cty):
-    return '*const' in cty
+select_re = re.compile('LAPACK_(\w)_SELECT(\d)')
 
-def is_mut(name, cty):
-    return '*mut' in cty
 
 def is_scalar(name, cty, f):
     return (
@@ -69,20 +66,8 @@ def is_scalar(name, cty, f):
         name.startswith('vers')
     )
 
-def translate_argument(name, cty, f):
-    if is_const(name, cty):
-        base = translate_type_base(cty, f)
-        if is_scalar(name, cty, f):
-            return base
-        else:
-            return '&[{}]'.format(base)
-    elif is_mut(name, cty):
-        base = translate_type_base(cty, f)
-        if is_scalar(name, cty, f):
-            return '&mut {}'.format(base)
-        else:
-            return '&mut [{}]'.format(base)
 
+def translate_argument(name, cty, f):
     m = select_re.match(cty)
     if m is not None:
         if m.group(1) == 'S':
@@ -94,25 +79,47 @@ def translate_argument(name, cty, f):
         elif m.group(1) == 'Z':
             return 'Select{}C64'.format(m.group(2))
 
-    assert False, 'cannot translate `{}: {}`'.format(name, cty)
+    base = translate_type_base(cty)
+    if '*const' in cty:
+        if is_scalar(name, cty, f):
+            return base
+        else:
+            return '&[{}]'.format(base)
+    elif '*mut' in cty:
+        if is_scalar(name, cty, f):
+            return '&mut {}'.format(base)
+        else:
+            return '&mut [{}]'.format(base)
+
+    return base
+
+
+def translate_type_base(cty):
+    cty = cty.replace('__BindgenComplex<f32>', 'lapack_complex_float')
+    cty = cty.replace('__BindgenComplex<f64>', 'lapack_complex_double')
+    cty = cty.replace('f32', 'c_float')
+    cty = cty.replace('f64', 'c_double')
 
-def translate_type_base(cty, f):
     if 'c_char' in cty:
         return 'u8'
-    elif 'lapack_int' in cty or 'lapack_logical' in cty:
+    elif 'c_int' in cty:
         return 'i32'
-    elif 'lapack_complex_double' in cty:
-        return 'c64'
-    elif 'lapack_complex_float' in cty:
-        return 'c32'
-    elif 'c_double' in cty:
-        return 'f64'
     elif 'c_float' in cty:
         return 'f32'
+    elif 'c_double' in cty:
+        return 'f64'
+    elif 'lapack_complex_float' in cty:
+        return 'c32'
+    elif 'lapack_complex_double' in cty:
+        return 'c64'
+
+    assert False, 'cannot translate `{}`'.format(cty)
 
-    assert False, 'cannot translate `{}` in `{}`'.format(cty, f.name)
 
 def translate_body_argument(name, rty):
+    if rty.startswith('Select'):
+        return 'transmute({})'.format(name)
+
     if rty == 'u8':
         return '&({} as c_char)'.format(name)
     elif rty == '&mut u8':
@@ -130,7 +137,7 @@ def translate_body_argument(name, rty):
     elif rty.startswith('f'):
         return '&{}'.format(name)
     elif rty.startswith('&mut f'):
-        return '{}'.format(name)
+        return name
     elif rty.startswith('&[f'):
         return '{}.as_ptr()'.format(name)
     elif rty.startswith('&mut [f'):
@@ -145,57 +152,69 @@ def translate_body_argument(name, rty):
     elif rty.startswith('&mut [c'):
         return '{}.as_mut_ptr() as *mut _'.format(name)
 
-    if rty.startswith('Select'):
-        return 'transmute({})'.format(name)
-
     assert False, 'cannot translate `{}: {}`'.format(name, rty)
 
+
 def translate_return_type(cty):
-    if cty == 'c_float':
+    cty = cty.replace('lapack_float_return', 'c_float')
+    cty = cty.replace('f64', 'c_double')
+
+    if cty == 'c_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)
     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_return_type(f.ret))
+
 
 def format_body(f):
     return 'ffi::{}_({})'.format(f.name, format_body_arguments(f))
 
+
 def format_header_arguments(f):
     s = []
     for arg in f.args:
         s.append('{}: {}'.format(arg[0], translate_argument(*arg, f=f)))
     return ', '.join(s)
 
+
 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))
     return ', '.join(s)
 
+
 def prepare(code):
-    lines = filter(lambda line: not re.match(r'^\s*//.*', line), code.split('\n'))
+    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):
     for f in functions:
         print('\n#[inline]')
         print(format_header(f) + ' {')
         print('    ' + format_body(f) + '\n}')
 
+
 if __name__ == '__main__':
     parser = argparse.ArgumentParser()
-    parser.add_argument('--sys', required=True)
+    parser.add_argument('--sys', default='lapack-sys')
     arguments = parser.parse_args()
-    path = os.path.join(arguments.sys, 'src', 'lib.rs')
+    path = os.path.join(arguments.sys, 'src', 'lapack.rs')
     do(prepare(read_functions(path)))