def _ParseFileAndImports(self, rel_filename, import_directories,
imported_filename_stack):
# Ignore already-parsed files.
if rel_filename.path in self._parsed_files:
return
if rel_filename.path in imported_filename_stack:
print "%s: Error: Circular dependency" % rel_filename.path + \
MakeImportStackMessage(imported_filename_stack + [rel_filename.path])
sys.exit(1)
try:
with open(rel_filename.path) as f:
source = f.read()
except IOError as e:
print "%s: Error: %s" % (e.rel_filename.path, e.strerror) + \
MakeImportStackMessage(imported_filename_stack + [rel_filename.path])
sys.exit(1)
try:
tree = Parse(source, rel_filename.path)
except Error as e:
full_stack = imported_filename_stack + [rel_filename.path]
print str(e) + MakeImportStackMessage(full_stack)
sys.exit(1)
dirname = os.path.split(rel_filename.path)[0]
for imp_entry in tree.import_list:
import_file_entry = FindImportFile(
RelativePath(dirname, rel_filename.source_root),
imp_entry.import_filename, import_directories)
self._ParseFileAndImports(import_file_entry, import_directories,
imported_filename_stack + [rel_filename.path])
self._parsed_files[rel_filename.path] = tree
def _ParseFileAndImports(self, filename, import_directories,
imported_filename_stack):
# Ignore already-parsed files.
if filename in self._parsed_files:
return
if filename in imported_filename_stack:
print "%s: Error: Circular dependency" % filename + \
MakeImportStackMessage(imported_filename_stack + [filename])
sys.exit(1)
try:
with open(filename) as f:
source = f.read()
except IOError as e:
print "%s: Error: %s" % (e.filename, e.strerror) + \
MakeImportStackMessage(imported_filename_stack + [filename])
sys.exit(1)
try:
tree = Parse(source, filename)
except Error as e:
full_stack = imported_filename_stack + [filename]
print str(e) + MakeImportStackMessage(full_stack)
sys.exit(1)
dirname = os.path.split(filename)[0]
for imp_entry in tree.import_list:
import_filename = FindImportFile(dirname,
imp_entry.import_filename,
import_directories)
self._ParseFileAndImports(import_filename, import_directories,
imported_filename_stack + [filename])
self._parsed_files[filename] = tree
def _maybe_download_dep(self, dep):
if not dep.maybe_is_a_url():
return False
for candidate in dep.generate_candidate_urls():
url = self._url_rewriter.rewrite(candidate)
response = self._requests_get("https://" + url)
if not response.ok:
# If we get an error, it just mean that this candidate URL is not
# correct. We must try the other ones before giving up.
logging.debug("Error while downloading %s (%s)", candidate,
url)
continue
# This is an external dependency
directory = os.path.dirname(candidate)
full_directory = os.path.join(
self._repository.get_external_directory(), directory)
try:
self._os_makedirs(full_directory)
except OSError as e:
# The directory may already exist, we don't care.
if e.errno != errno.EEXIST:
raise
with self._open(
os.path.join(self._repository.get_external_directory(),
candidate), "w") as f:
data = response.content
try:
Parse(data, candidate)
except ParseError:
logging.warn("File at %s is not a mojom", url)
break
f.write(data)
return True
return False
def mojom_path(filename):
with open(filename) as f:
source = f.read()
tree = Parse(source, filename)
_, name = os.path.split(filename)
mojom = Translate(tree, name)
elements = mojom['namespace'].split('.')
elements.append("%s" % mojom['name'])
return os.path.join(*elements)
def AddPath(mojom):
path = os.path.join(GetChromiumRoot(), mojom)
if path in mojom_paths:
return
mojom_paths.add(path)
with open(path) as f:
code = f.read()
ast = Parse(code, path)
for imp in ast.import_list:
AddPath(imp.import_filename)
def _load_mojom(path_to_mojom):
filename = os.path.abspath(path_to_mojom)
name = os.path.basename(filename)
# Read in mojom file.
with open(filename) as f:
source = f.read()
# Parse
tree = Parse(source, name)
mojom = Translate(tree, name)
return mojom
def main(argv):
if len(argv) < 2:
print "usage: %s filename" % sys.argv[0]
return 1
for filename in argv[1:]:
with open(filename) as f:
print "%s:" % filename
print Translate(Parse(f.read(), filename),
os.path.splitext(os.path.basename(filename))[0])
return 0
def main(argv):
if len(argv) < 2:
print "usage: %s filename" % argv[0]
return 0
for filename in argv[1:]:
with open(filename) as f:
print "%s:" % filename
try:
print Parse(f.read(), filename)
except ParseError, e:
print e
return 1
def _ParseFile(args, rel_filename):
try:
with open(rel_filename.path) as f:
source = f.read()
except IOError as e:
print("%s: Error: %s" % (rel_filename.path, e.strerror))
sys.exit(1)
try:
tree = Parse(source, rel_filename.path)
RemoveDisabledDefinitions(tree, args.enabled_features)
except Error as e:
print("%s: Error: %s" % (rel_filename.path, str(e)))
sys.exit(1)
_PickleAST(tree, _GetPicklePath(rel_filename, args.output_dir))
def get_all_external_mojom_directories(self):
"""Get all external directories populated with their mojom files."""
mojoms = self._get_all_mojom_in_directory(
self.get_external_directory())
directories = {}
for mojom_path in mojoms:
directory_path = os.path.dirname(mojom_path)
directory = directories.setdefault(directory_path,
MojomDirectory(directory_path))
with self._open(mojom_path) as f:
source = f.read()
tree = Parse(source, mojom_path)
mojom = MojomFile(self, mojom_path)
directory.add_mojom(mojom)
for dep in tree.import_list:
mojom.add_dependency(dep.import_filename)
return directories.values()
def get_missing_dependencies(self):
"""get_missing_dependencies returns a set of dependencies that are required
by mojoms in this repository but not available.
"""
# Update the list of available mojoms in this repository.
mojoms = set(self._get_all_mojom_in_directory(self._root_dir))
# Find all declared dependencies
needed_deps = set([])
for mojom in mojoms:
with self._open(mojom) as f:
source = f.read()
tree = Parse(source, mojom)
for dep in tree.import_list:
needed_deps.add(
Dependency(self, dep.filename, dep.import_filename))
missing_deps = self._resolve_dependencies(needed_deps, mojoms)
return missing_deps
def process_mojom(path_to_mojom):
filename = os.path.abspath(path_to_mojom)
name = os.path.basename(filename)
# Read in mojom file.
try:
with open(filename) as f:
source = f.read()
except IOError:
print("Error reading %s" % filename)
sys.exit(2)
# Parse
try:
tree = Parse(source, name)
except Error:
print("Error parsing %s" % filename)
sys.exit(2)
mojom = Translate(tree, name)
# Output path
attributes = mojom.get('attributes')
print(mojom_path(mojom['name'], mojom['namespace'], attributes))
def ProcessFile(args,
generator_modules,
filename,
_processed_files={},
_imported_filename_stack=[]):
# Memoized results.
if filename in _processed_files:
return _processed_files[filename]
# Ensure we only visit each file once.
if filename in _imported_filename_stack:
print "%s: Error: Circular dependency" % filename + \
MakeImportStackMessage(_imported_filename_stack + [filename])
sys.exit(1)
try:
with open(filename) as f:
source = f.read()
except IOError as e:
print "%s: Error: %s" % (e.filename, e.strerror) + \
MakeImportStackMessage(_imported_filename_stack + [filename])
sys.exit(1)
try:
tree = Parse(source, filename)
except Error as e:
print str(e) + MakeImportStackMessage(_imported_filename_stack +
[filename])
sys.exit(1)
dirname, name = os.path.split(filename)
mojom = Translate(tree, name)
if args.debug_print_intermediate:
pprint.PrettyPrinter().pprint(mojom)
# Process all our imports first and collect the module object for each.
# We use these to generate proper type info.
for import_data in mojom['imports']:
import_filename = os.path.join(dirname, import_data['filename'])
import_data['module'] = ProcessFile(
args,
generator_modules,
import_filename,
_processed_files=_processed_files,
_imported_filename_stack=_imported_filename_stack + [filename])
module = OrderedModuleFromData(mojom)
# Set the path as relative to the source root.
module.path = os.path.relpath(os.path.abspath(filename),
os.path.abspath(args.depth))
# Normalize to unix-style path here to keep the generators simpler.
module.path = module.path.replace('\\', '/')
for generator_module in generator_modules:
generator = generator_module.Generator(module, args.output_dir)
generator.GenerateFiles()
# Save result.
_processed_files[filename] = module
return module
from mojom.parse.parser import Parse
from mojom.generator.definitions_generator import GenerateDefinitions
from mojom.generator.servers_generator import GenerateServers
from mojom.generator.runtime_generator import GenerateRuntime
from mojom.generator.clients_generator import GenerateClients
import shutil
import glob
filenames = glob.glob("mojom/*.mojom")
trees = []
dst = 'mojom/generator/gene'
for filename in filenames:
f = open(filename)
tree = Parse(f.read(), filename)
trees.append(tree)
GenerateDefinitions(tree, filename)
GenerateClients(tree, filename)
GenerateServers(tree, filename)
shutil.copy(filename + '.h', dst)
shutil.copy(filename + '.client.h', dst)
shutil.copy(filename + '.server.h', dst)
GenerateRuntime(trees, filenames)
shutil.copy('gene_runtime.h', dst)
def ProcessFile(self,
args,
remaining_args,
generator_modules,
filename,
_imported_filename_stack=None):
# Memoized results.
if filename in self._processed_files:
return self._processed_files[filename]
if _imported_filename_stack is None:
_imported_filename_stack = []
# Ensure we only visit each file once.
if filename in _imported_filename_stack:
print "%s: Error: Circular dependency" % filename + \
MakeImportStackMessage(_imported_filename_stack + [filename])
sys.exit(1)
try:
with open(filename) as f:
source = f.read()
except IOError as e:
print "%s: Error: %s" % (e.filename, e.strerror) + \
MakeImportStackMessage(_imported_filename_stack + [filename])
sys.exit(1)
try:
tree = Parse(source, filename)
except Error as e:
full_stack = _imported_filename_stack + [filename]
print str(e) + MakeImportStackMessage(full_stack)
sys.exit(1)
dirname, name = os.path.split(filename)
mojom = Translate(tree, name)
if args.debug_print_intermediate:
pprint.PrettyPrinter().pprint(mojom)
# Process all our imports first and collect the module object for each.
# We use these to generate proper type info.
for import_data in mojom['imports']:
import_filename = FindImportFile(dirname, import_data['filename'],
args.import_directories)
import_data['module'] = self.ProcessFile(
args,
remaining_args,
generator_modules,
import_filename,
_imported_filename_stack=_imported_filename_stack + [filename])
module = OrderedModuleFromData(mojom)
# Set the path as relative to the source root.
module.path = os.path.relpath(os.path.abspath(filename),
os.path.abspath(args.depth))
# Normalize to unix-style path here to keep the generators simpler.
module.path = module.path.replace('\\', '/')
if self._should_generate(filename):
for generator_module in generator_modules:
generator = generator_module.Generator(module, args.output_dir)
filtered_args = []
if hasattr(generator_module, 'GENERATOR_PREFIX'):
prefix = '--' + generator_module.GENERATOR_PREFIX + '_'
filtered_args = [
arg for arg in remaining_args if arg.startswith(prefix)
]
generator.GenerateFiles(filtered_args)
# Save result.
self._processed_files[filename] = module
return module
