Update make for hello examples

native_client_sdk/src/tools/create_nmf.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 import errno
 import json
 import optparse
 import os
 import re
@@ skipping 29 matching lines @@
     'arm': 'lib',
 }
 
 
 # These constants are used within nmf files.
 RUNNABLE_LD = 'runnable-ld.so'  # Name of the dynamic loader
 MAIN_NEXE = 'main.nexe'  # Name of entry point for execution
 PROGRAM_KEY = 'program'  # Key of the program section in an nmf file
 URL_KEY = 'url'  # Key of the url field for a particular file in an nmf file
 FILES_KEY = 'files'  # Key of the files section in an nmf file
+PORTABLE_KEY = 'portable' # key for portable section of manifest
+TRANSLATE_KEY = 'pnacl-translate' # key for translatable objects
+
 
 # The proper name of the dynamic linker, as kept in the IRT.  This is
 # excluded from the nmf file by convention.
 LD_NACL_MAP = {
     'x86-32': 'ld-nacl-x86-32.so.1',
     'x86-64': 'ld-nacl-x86-64.so.1',
     'arm': None,
 }
 
 
@@ skipping 161 matching lines @@
       remap: Remaps the library name in the manifest.
       '''
     self.objdump = objdump
     self.main_files = main_files or []
     self.extra_files = extra_files or []
     self.lib_path = lib_path or []
     self.manifest = None
     self.needed = {}
     self.lib_prefix = lib_prefix or []
     self.remap = remap or {}
+    self.pnacl = len(main_files) > 0 and main_files[0].endswith('pexe')
 
   def GleanFromObjdump(self, files):
     '''Get architecture and dependency information for given files
 
     Args:
       files: A dict with key=filename and value=list or set of archs.  E.g.:
           { '/path/to/my.nexe': ['x86-32']
             '/path/to/lib64/libmy.so': ['x86-64'],
             '/path/to/mydata.so': ['x86-32', 'x86-64'],
             '/path/to/my.data': None }  # Indicates all architectures
@@ skipping 57 matching lines @@
     return files
 
   def GetNeeded(self):
     '''Collect the list of dependencies for the main_files
 
     Returns:
       A dict with key=filename and value=ArchFile of input files.
           Includes the input files as well, with arch filled in if absent.
           Example: { '/path/to/my.nexe': ArchFile(my.nexe),
                      '/path/to/libfoo.so': ArchFile(libfoo.so) }'''
+
     if self.needed:
       return self.needed
 
     DebugPrint('GetNeeded(%s)' % self.main_files)
 
     dynamic = any(ParseElfHeader(f)[1] for f in self.main_files)
 
     if dynamic:
       examined = set()
       all_files, unexamined = self.GleanFromObjdump(
@@ skipping 47 matching lines @@
       destination = os.path.join(destination_dir, urldest)
 
       if (os.path.normcase(os.path.abspath(source)) !=
           os.path.normcase(os.path.abspath(destination))):
         # make sure target dir exists
         MakeDir(os.path.dirname(destination))
 
         Trace("copy: %s -> %s" % (source, destination))
         shutil.copy2(source, destination)
 
+  def _GeneratePNaClManifest(self):
+    manifest = {}
+    manifest[PROGRAM_KEY] = {}
+    manifest[PROGRAM_KEY][PORTABLE_KEY] = {}
+    manifest[PROGRAM_KEY][PORTABLE_KEY][TRANSLATE_KEY] = {
+      "url": os.path.basename(self.main_files[0])
+    }
+    self.manifest = manifest
+
   def _GenerateManifest(self):
     '''Create a JSON formatted dict containing the files
 
     NaCl will map url requests based on architecture.  The startup NEXE
     can always be found under the top key PROGRAM.  Additional files are under
     the FILES key further mapped by file name.  In the case of 'runnable' the
     PROGRAM key is populated with urls pointing the runnable-ld.so which acts
     as the startup nexe.  The application itself is then placed under the
     FILES key mapped as 'main.exe' instead of the original name so that the
     loader can find it. '''
@@ skipping 34 matching lines @@
 
       name = self.remap.get(name, name)
       fileinfo = manifest[FILES_KEY].get(name, {})
       fileinfo[archinfo.arch] = urlinfo
       manifest[FILES_KEY][name] = fileinfo
     self.manifest = manifest
 
   def GetManifest(self):
     '''Returns a JSON-formatted dict containing the NaCl dependencies'''
     if not self.manifest:
-      self._GenerateManifest()
-
+      if self.pnacl:
+        self._GeneratePNaClManifest()
+      else:
+        self._GenerateManifest()
     return self.manifest
 
   def GetJson(self):
     '''Returns the Manifest as a JSON-formatted string'''
     pretty_string = json.dumps(self.GetManifest(), indent=2)
     # json.dumps sometimes returns trailing whitespace and does not put
     # a newline at the end.  This code fixes these problems.
     pretty_lines = pretty_string.split('\n')
     return '\n'.join([line.rstrip() for line in pretty_lines]) + '\n'
 
@@ skipping 114 matching lines @@
                  lib_prefix=path_prefix,
                  remap=remap)
 
   nmf.GetManifest()
   if options.output is None:
     sys.stdout.write(nmf.GetJson())
   else:
     with open(options.output, 'w') as output:
       output.write(nmf.GetJson())
 
-  if options.stage_dependencies:
+  if options.stage_dependencies and not nmf.pnacl:
     Trace("Staging dependencies...")
     nmf.StageDependencies(options.stage_dependencies)
 
   return 0
 
 
 # Invoke this file directly for simple testing.
 if __name__ == '__main__':
   try:
     rtn = main(sys.argv[1:])
   except Error, e:
     sys.stderr.write("%s: %s\n" % (os.path.basename(__file__), e))
     rtn = 1
   sys.exit(rtn)