Rearrange mojo/nacl files.

nacl_bindings_generator/generate_nacl_bindings.py

 #!/usr/bin/python
 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # pylint: disable=W0104,W0106,F0401,R0201
 
 import errno
-import optparse
 import os.path
 import sys
 
 import interface
 
 
-def _ScriptDir():
+def ScriptDir():
   return os.path.dirname(os.path.abspath(__file__))
 
 
-def _GetDirAbove(dirname):
-  """Returns the directory "above" this file containing |dirname| (which must
-  also be "above" this file)."""
-  path = _ScriptDir()
-  while True:
-    path, tail = os.path.split(path)
-    assert tail
-    if tail == dirname:
-      return path
+def RepoRoot():
+  return os.path.dirname(ScriptDir())
 
 
 def _AddThirdPartyImportPath():
-  sys.path.append(os.path.join(_GetDirAbove('mojo'), 'third_party'))
+  sys.path.append(os.path.join(RepoRoot(), 'third_party'))
 
 
 _AddThirdPartyImportPath()
 import jinja2
 
-loader = jinja2.FileSystemLoader(_ScriptDir())
+loader = jinja2.FileSystemLoader(ScriptDir())
 jinja_env = jinja2.Environment(loader=loader, keep_trailing_newline=True)
 
 
 # Accumulate lines of code with varying levels of indentation.
 class CodeWriter(object):
   def __init__(self):
     self._lines = []
     self._margin = ''
     self._margin_stack = []
 
@@ skipping 47 matching lines @@
   return lines
 
 
 def GeneratorWarning():
   return ('// WARNING this file was generated by %s\n// Do not edit by hand.' %
           os.path.basename(__file__))
 
 
 # Untrusted library which thunks from the public Mojo API to the IRT interface
 # implementing the public Mojo API.
-def GenerateLibMojo(functions, out):
+def GenerateLibMojo(functions, common_vars, out):
   template = jinja_env.get_template('libmojo.cc.tmpl')
 
   code = CodeWriter()
 
   for f in functions:
     for line in Wrap('%s %s(' % (f.return_type, f.name), f.ParamList(), ') {'):
       code << line
 
     with code.Indent():
       code << 'struct nacl_irt_mojo* irt_mojo = get_irt_mojo();'
       code << 'if (irt_mojo == NULL)'
       with code.Indent():
         code << 'return MOJO_RESULT_INTERNAL;'
       code << 'return irt_mojo->%s(%s);' % (
           f.name, ', '.join([p.name for p in f.params]))
 
     code << '}'
     code << ''
 
   body = code.GetValue()
   text = template.render(
-    generator_warning=GeneratorWarning(),
-    body=body)
+    body=body,
+    **common_vars)
   out.write(text)
 
 
 # Parameters passed into trusted code are handled differently depending on
 # details of the parameter.  ParamImpl instances encapsulate these differences
 # and are used to generate the code that transfers parameters across the
 # untrusted/trusted boundary.
 class ParamImpl(object):
   def __init__(self, param):
     self.param = param
@@ skipping 161 matching lines @@
       return ScalarOutputImpl(p)
   assert False, p.name
 
 
 def CBool(value):
   return 'true' if value else 'false'
 
 
 # A trusted wrapper that validates the arguments passed from untrusted code
 # before passing them to the underlying public Mojo API.
-def GenerateMojoSyscall(functions, out):
+def GenerateMojoSyscall(functions, common_vars, out):
   template = jinja_env.get_template('mojo_syscall.cc.tmpl')
 
   code = CodeWriter()
   code.PushMargin()
 
   for f in functions:
     impls = [ImplForParam(p) for p in f.params]
     impls.append(ImplForParam(f.result_param))
 
     code << 'case %d:' % f.uid
@@ skipping 48 matching lines @@
       code << '}'
       code << ''
 
       code << 'return 0;'
     code << '}'
 
     code.PopMargin()
 
   body = code.GetValue()
   text = template.render(
-    generator_warning=GeneratorWarning(),
-    body=body)
+    body=body,
+    **common_vars)
   out.write(text)
 
 
 # A header declaring the IRT interface for accessing Mojo functions.
-def GenerateMojoIrtHeader(functions, out):
+def GenerateMojoIrtHeader(functions, common_vars, out):
   template = jinja_env.get_template('mojo_irt.h.tmpl')
   code = CodeWriter()
 
   code << 'struct nacl_irt_mojo {'
   with code.Indent():
     for f in functions:
       for line in Wrap('%s (*%s)(' % (f.return_type, f.name),
                        f.ParamList(),
                        ');'):
         code << line
 
   code << '};'
 
   body = code.GetValue()
 
   text = template.render(
-    generator_warning=GeneratorWarning(),
-    body=body)
+    body=body,
+    **common_vars)
   out.write(text)
 
 # IRT interface which implements the Mojo public API.
-def GenerateMojoIrtImplementation(functions, out):
+def GenerateMojoIrtImplementation(functions, common_vars, out):
   template = jinja_env.get_template('mojo_irt.c.tmpl')
   code = CodeWriter()
 
   for f in functions:
     for line in Wrap('static %s irt_%s(' % (f.return_type, f.name),
                      f.ParamList(),
                      ') {'):
       code << line
 
     # 2 extra parameters: message ID and return value.
@@ skipping 33 matching lines @@
   # definition.
   code << 'struct nacl_irt_mojo kIrtMojo = {'
   for f in functions:
     with code.Indent():
       code << '&irt_%s,' % f.name
   code << '};'
 
   body = code.GetValue()
 
   text = template.render(
-    generator_warning=GeneratorWarning(),
-    body=body)
+    body=body,
+    **common_vars)
   out.write(text)
 
 
 def OutFile(dir_path, name):
   if not os.path.exists(dir_path):
     try:
       os.makedirs(dir_path)
     except OSError as e:
       # There may have been a race to create this directory.
       if e.errno != errno.EEXIST:
         raise
-  return open(os.path.join(dir_path, name), 'w')
+  full_path = os.path.join(dir_path, name)
+  print full_path
+  return open(full_path, 'w')
 
 
-def main(args):
-  usage = 'usage: %prog [options]'
-  parser = optparse.OptionParser(usage=usage)
-  parser.add_option(
-      '-d',
-      dest='out_dir',
-      metavar='DIR',
-      help='output generated code into directory DIR')
-  options, args = parser.parse_args(args=args)
-  if not options.out_dir:
-    parser.error('-d is required')
-  if args:
-    parser.error('unexpected positional arguments: %s' % ' '.join(args))
+def main():
+  root_dir = RepoRoot()
+
+  platform_dir = 'mojo/public/platform/nacl'
+  bindings_dir = 'nacl_bindings'
+
+  full_platform_dir = os.path.join(root_dir, platform_dir)
+  full_bindings_dir = os.path.join(root_dir, bindings_dir)
+
+  common_vars = dict(
+    generator_warning=GeneratorWarning(),
+    platform_dir=platform_dir,
+    platform_dir_header_path=platform_dir.replace("/", "_").upper(),
+    bindings_dir=bindings_dir,
+  )
 
   mojo = interface.MakeInterface()
 
-  out = OutFile(options.out_dir, 'libmojo.cc')
-  GenerateLibMojo(mojo.functions, out)
+  out = OutFile(full_platform_dir, 'libmojo.cc')
+  GenerateLibMojo(mojo.functions, common_vars, out)
 
-  out = OutFile(options.out_dir, 'mojo_syscall.cc')
-  GenerateMojoSyscall(mojo.functions, out)
+  out = OutFile(full_bindings_dir, 'mojo_syscall.cc')
+  GenerateMojoSyscall(mojo.functions, common_vars, out)
 
-  out = OutFile(options.out_dir, 'mojo_irt.h')
-  GenerateMojoIrtHeader(mojo.functions, out)
+  out = OutFile(full_platform_dir, 'mojo_irt.h')
+  GenerateMojoIrtHeader(mojo.functions, common_vars, out)
 
-  out = OutFile(options.out_dir, 'mojo_irt.c')
-  GenerateMojoIrtImplementation(mojo.functions, out)
+  out = OutFile(full_bindings_dir, 'mojo_irt.c')
+  GenerateMojoIrtImplementation(mojo.functions, common_vars, out)
 
 if __name__ == '__main__':
-  main(sys.argv[1:])
+  main()