utils: ipc: import mojo
Import mojo from the Chromium repository, so that we can use it for
generating code for the IPC mechanism. The commit from which this was
taken is:
a079161ec8c6907b883f9cb84fc8c4e7896cb1d0 "Add PPAPI constructs for
sending focus object to PdfAccessibilityTree"
This tree has been pruned to remove directories that didn't have any
necessary code:
- mojo/* except for mojo/public
- mojo core, docs, and misc files
- mojo/public/* except for mojo/public/{tools,LICENSE}
- language bindings for IPC, tests, and some mojo internals
- mojo/public/tools/{fuzzers,chrome_ipc}
- mojo/public/tools/bindings/generators
- code generation for other languages
No files were modified.
Signed-off-by: Paul Elder <paul.elder@ideasonboard.com>
Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Acked-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
Acked-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
This commit is contained in:
Paul Elder
parent
3d624b745b
commit
82ba73535c
54 changed files with 12855 additions and 0 deletions
27
utils/ipc/mojo/public/LICENSE
Normal file
27
utils/ipc/mojo/public/LICENSE
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
// Copyright 2014 The Chromium Authors. All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
6
utils/ipc/mojo/public/tools/.style.yapf
Normal file
6
utils/ipc/mojo/public/tools/.style.yapf
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
[style]
|
||||
based_on_style = pep8
|
||||
|
||||
# New directories should use a .style.yapf that does not include the following:
|
||||
column_limit = 80
|
||||
indent_width = 2
|
||||
18
utils/ipc/mojo/public/tools/BUILD.gn
Normal file
18
utils/ipc/mojo/public/tools/BUILD.gn
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
# Copyright 2020 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.
|
||||
|
||||
# The main target used to aggregate all unit tests for Python-based Mojo tools.
|
||||
# This is used to generate a complete isolate which can be pushed to bots to run
|
||||
# the tests.
|
||||
group("mojo_python_unittests") {
|
||||
data = [
|
||||
"run_all_python_unittests.py",
|
||||
"//testing/scripts/common.py",
|
||||
"//testing/scripts/run_isolated_script_test.py",
|
||||
"//testing/test_env.py",
|
||||
"//testing/xvfb.py",
|
||||
]
|
||||
deps = [ "//mojo/public/tools/mojom/mojom:tests" ]
|
||||
data_deps = [ "//third_party/catapult/third_party/typ/" ]
|
||||
}
|
||||
108
utils/ipc/mojo/public/tools/bindings/BUILD.gn
Normal file
108
utils/ipc/mojo/public/tools/bindings/BUILD.gn
Normal file
|
|
@ -0,0 +1,108 @@
|
|||
# Copyright 2016 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("//mojo/public/tools/bindings/mojom.gni")
|
||||
import("//third_party/jinja2/jinja2.gni")
|
||||
|
||||
action("precompile_templates") {
|
||||
sources = mojom_generator_sources
|
||||
sources += [
|
||||
"$mojom_generator_root/generators/cpp_templates/enum_macros.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/enum_serialization_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/interface_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/interface_definition.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/interface_macros.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/interface_proxy_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/interface_request_validator_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/interface_response_validator_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/interface_stub_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/module-forward.h.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/module-import-headers.h.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/module-params-data.h.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/module-shared-internal.h.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/module-shared-message-ids.h.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/module-shared.cc.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/module-shared.h.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/module-test-utils.cc.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/module-test-utils.h.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/module.cc.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/module.h.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/struct_data_view_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/struct_data_view_definition.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/struct_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/struct_definition.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/struct_macros.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/struct_serialization_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/struct_traits_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/struct_traits_definition.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/struct_unserialized_message_context.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/union_data_view_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/union_data_view_definition.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/union_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/union_definition.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/union_serialization_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/union_traits_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/union_traits_definition.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/validation_macros.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/wrapper_class_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/wrapper_class_definition.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/wrapper_class_template_definition.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/wrapper_union_class_declaration.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/wrapper_union_class_definition.tmpl",
|
||||
"$mojom_generator_root/generators/cpp_templates/wrapper_union_class_template_definition.tmpl",
|
||||
"$mojom_generator_root/generators/java_templates/constant_definition.tmpl",
|
||||
"$mojom_generator_root/generators/java_templates/constants.java.tmpl",
|
||||
"$mojom_generator_root/generators/java_templates/data_types_definition.tmpl",
|
||||
"$mojom_generator_root/generators/java_templates/enum.java.tmpl",
|
||||
"$mojom_generator_root/generators/java_templates/enum_definition.tmpl",
|
||||
"$mojom_generator_root/generators/java_templates/header.java.tmpl",
|
||||
"$mojom_generator_root/generators/java_templates/interface.java.tmpl",
|
||||
"$mojom_generator_root/generators/java_templates/interface_definition.tmpl",
|
||||
"$mojom_generator_root/generators/java_templates/interface_internal.java.tmpl",
|
||||
"$mojom_generator_root/generators/java_templates/struct.java.tmpl",
|
||||
"$mojom_generator_root/generators/java_templates/union.java.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/enum_definition.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/externs/interface_definition.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/externs/module.externs.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/externs/struct_definition.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/fuzzing.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/interface_definition.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/lite/enum_definition.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/lite/interface_definition.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/lite/module_definition.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/lite/mojom-lite.js.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/lite/struct_definition.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/lite/union_definition.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/module.amd.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/module_definition.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/struct_definition.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/union_definition.tmpl",
|
||||
"$mojom_generator_root/generators/js_templates/validation_macros.tmpl",
|
||||
"$mojom_generator_root/generators/mojolpm_templates/mojolpm.cc.tmpl",
|
||||
"$mojom_generator_root/generators/mojolpm_templates/mojolpm.h.tmpl",
|
||||
"$mojom_generator_root/generators/mojolpm_templates/mojolpm.proto.tmpl",
|
||||
"$mojom_generator_root/generators/mojolpm_templates/mojolpm_from_proto_macros.tmpl",
|
||||
"$mojom_generator_root/generators/mojolpm_templates/mojolpm_macros.tmpl",
|
||||
"$mojom_generator_root/generators/mojolpm_templates/mojolpm_to_proto_macros.tmpl",
|
||||
"$mojom_generator_root/generators/mojolpm_templates/mojolpm_traits_specialization_macros.tmpl",
|
||||
"$mojom_generator_root/generators/ts_templates/module_definition.tmpl",
|
||||
"$mojom_generator_root/generators/ts_templates/mojom.tmpl",
|
||||
]
|
||||
script = mojom_generator_script
|
||||
|
||||
inputs = jinja2_sources
|
||||
outputs = [
|
||||
"$target_gen_dir/cpp_templates.zip",
|
||||
"$target_gen_dir/java_templates.zip",
|
||||
"$target_gen_dir/mojolpm_templates.zip",
|
||||
"$target_gen_dir/js_templates.zip",
|
||||
"$target_gen_dir/ts_templates.zip",
|
||||
]
|
||||
args = [
|
||||
"-o",
|
||||
rebase_path(target_gen_dir, root_build_dir),
|
||||
"--use_bundled_pylibs",
|
||||
"precompile",
|
||||
]
|
||||
}
|
||||
816
utils/ipc/mojo/public/tools/bindings/README.md
Normal file
816
utils/ipc/mojo/public/tools/bindings/README.md
Normal file
|
|
@ -0,0 +1,816 @@
|
|||
# Mojom Interface Definition Language (IDL)
|
||||
This document is a subset of the [Mojo documentation](/mojo/README.md).
|
||||
|
||||
[TOC]
|
||||
|
||||
## Overview
|
||||
|
||||
Mojom is the IDL for Mojo interfaces. Given a `.mojom` file, the
|
||||
[bindings
|
||||
generator](https://cs.chromium.org/chromium/src/mojo/public/tools/bindings/) can
|
||||
output bindings for any supported language: **C++**, **JavaScript**, or
|
||||
**Java**.
|
||||
|
||||
For a trivial example consider the following hypothetical Mojom file we write to
|
||||
`//services/widget/public/mojom/frobinator.mojom`:
|
||||
|
||||
```
|
||||
module widget.mojom;
|
||||
|
||||
interface Frobinator {
|
||||
Frobinate();
|
||||
};
|
||||
```
|
||||
|
||||
This defines a single [interface](#Interfaces) named `Frobinator` in a
|
||||
[module](#Modules) named `widget.mojom` (and thus fully qualified in Mojom as
|
||||
`widget.mojom.Frobinator`.) Note that many interfaces and/or other types of
|
||||
definitions (structs, enums, *etc.*) may be included in a single Mojom file.
|
||||
|
||||
If we add a corresponding GN target to
|
||||
`//services/widget/public/mojom/BUILD.gn`:
|
||||
|
||||
```
|
||||
import("mojo/public/tools/bindings/mojom.gni")
|
||||
|
||||
mojom("mojom") {
|
||||
sources = [
|
||||
"frobinator.mojom",
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
and then build this target:
|
||||
|
||||
```
|
||||
ninja -C out/r services/widget/public/mojom
|
||||
```
|
||||
|
||||
we'll find several generated sources in our output directory:
|
||||
|
||||
```
|
||||
out/r/gen/services/widget/public/mojom/frobinator.mojom.cc
|
||||
out/r/gen/services/widget/public/mojom/frobinator.mojom.h
|
||||
out/r/gen/services/widget/public/mojom/frobinator.mojom-shared.h
|
||||
etc...
|
||||
```
|
||||
|
||||
Each of these generated source modules includes a set of definitions
|
||||
representing the Mojom contents in C++. You can also build or depend on suffixed
|
||||
target names to get bindings for other languages. For example,
|
||||
|
||||
```
|
||||
ninja -C out/r services/widget/public/mojom:mojom_js
|
||||
ninja -C out/r services/widget/public/mojom:mojom_java
|
||||
```
|
||||
|
||||
would generate JavaScript and Java bindings respectively, in the same generated
|
||||
output directory.
|
||||
|
||||
For more details regarding the generated
|
||||
outputs please see
|
||||
[documentation for individual target languages](#Generated-Code-For-Target-Languages).
|
||||
|
||||
## Mojom Syntax
|
||||
|
||||
Mojom IDL allows developers to define **structs**, **unions**, **interfaces**,
|
||||
**constants**, and **enums**, all within the context of a **module**. These
|
||||
definitions are used to generate code in the supported target languages at build
|
||||
time.
|
||||
|
||||
Mojom files may **import** other Mojom files in order to reference their
|
||||
definitions.
|
||||
|
||||
### Primitive Types
|
||||
Mojom supports a few basic data types which may be composed into structs or used
|
||||
for message parameters.
|
||||
|
||||
| Type | Description
|
||||
|-------------------------------|-------------------------------------------------------|
|
||||
| `bool` | Boolean type (`true` or `false`.)
|
||||
| `int8`, `uint8` | Signed or unsigned 8-bit integer.
|
||||
| `int16`, `uint16` | Signed or unsigned 16-bit integer.
|
||||
| `int32`, `uint32` | Signed or unsigned 32-bit integer.
|
||||
| `int64`, `uint64` | Signed or unsigned 64-bit integer.
|
||||
| `float`, `double` | 32- or 64-bit floating point number.
|
||||
| `string` | UTF-8 encoded string.
|
||||
| `array<T>` | Array of any Mojom type *T*; for example, `array<uint8>` or `array<array<string>>`.
|
||||
| `array<T, N>` | Fixed-length array of any Mojom type *T*. The parameter *N* must be an integral constant.
|
||||
| `map<S, T>` | Associated array maping values of type *S* to values of type *T*. *S* may be a `string`, `enum`, or numeric type.
|
||||
| `handle` | Generic Mojo handle. May be any type of handle, including a wrapped native platform handle.
|
||||
| `handle<message_pipe>` | Generic message pipe handle.
|
||||
| `handle<shared_buffer>` | Shared buffer handle.
|
||||
| `handle<data_pipe_producer>` | Data pipe producer handle.
|
||||
| `handle<data_pipe_consumer>` | Data pipe consumer handle.
|
||||
| `handle<platform>` | A native platform/OS handle.
|
||||
| *`pending_remote<InterfaceType>`* | Any user-defined Mojom interface type. This is sugar for a strongly-typed message pipe handle which should eventually be used to make outgoing calls on the interface.
|
||||
| *`pending_receiver<InterfaceType>`* | A pending receiver for any user-defined Mojom interface type. This is sugar for a more strongly-typed message pipe handle which is expected to receive request messages and should therefore eventually be bound to an implementation of the interface.
|
||||
| *`pending_associated_remote<InterfaceType>`* | An associated interface handle. See [Associated Interfaces](#Associated-Interfaces)
|
||||
| *`pending_associated_receiver<InterfaceType>`* | A pending associated receiver. See [Associated Interfaces](#Associated-Interfaces)
|
||||
| *T*? | An optional (nullable) value. Primitive numeric types (integers, floats, booleans, and enums) are not nullable. All other types are nullable.
|
||||
|
||||
### Modules
|
||||
|
||||
Every Mojom file may optionally specify a single **module** to which it belongs.
|
||||
|
||||
This is used strictly for aggregaging all defined symbols therein within a
|
||||
common Mojom namespace. The specific impact this has on generated binidngs code
|
||||
varies for each target language. For example, if the following Mojom is used to
|
||||
generate bindings:
|
||||
|
||||
```
|
||||
module business.stuff;
|
||||
|
||||
interface MoneyGenerator {
|
||||
GenerateMoney();
|
||||
};
|
||||
```
|
||||
|
||||
Generated C++ bindings will define a class interface `MoneyGenerator` in the
|
||||
`business::stuff` namespace, while Java bindings will define an interface
|
||||
`MoneyGenerator` in the `org.chromium.business.stuff` package. JavaScript
|
||||
bindings at this time are unaffected by module declarations.
|
||||
|
||||
**NOTE:** By convention in the Chromium codebase, **all** Mojom files should
|
||||
declare a module name with at least (and preferrably exactly) one top-level name
|
||||
as well as an inner `mojom` module suffix. *e.g.*, `chrome.mojom`,
|
||||
`business.mojom`, *etc.*
|
||||
|
||||
This convention makes it easy to tell which symbols are generated by Mojom when
|
||||
reading non-Mojom code, and it also avoids namespace collisions in the fairly
|
||||
common scenario where you have a real C++ or Java `Foo` along with a
|
||||
corresponding Mojom `Foo` for its serialized representation.
|
||||
|
||||
### Imports
|
||||
|
||||
If your Mojom references definitions from other Mojom files, you must **import**
|
||||
those files. Import syntax is as follows:
|
||||
|
||||
```
|
||||
import "services/widget/public/mojom/frobinator.mojom";
|
||||
```
|
||||
|
||||
Import paths are always relative to the top-level directory.
|
||||
|
||||
Note that circular imports are **not** supported.
|
||||
|
||||
### Structs
|
||||
|
||||
Structs are defined using the **struct** keyword, and they provide a way to
|
||||
group related fields together:
|
||||
|
||||
``` cpp
|
||||
struct StringPair {
|
||||
string first;
|
||||
string second;
|
||||
};
|
||||
```
|
||||
|
||||
Struct fields may be comprised of any of the types listed above in the
|
||||
[Primitive Types](#Primitive-Types) section.
|
||||
|
||||
Default values may be specified as long as they are constant:
|
||||
|
||||
``` cpp
|
||||
struct Request {
|
||||
int32 id = -1;
|
||||
string details;
|
||||
};
|
||||
```
|
||||
|
||||
What follows is a fairly
|
||||
comprehensive example using the supported field types:
|
||||
|
||||
``` cpp
|
||||
struct StringPair {
|
||||
string first;
|
||||
string second;
|
||||
};
|
||||
|
||||
enum AnEnum {
|
||||
YES,
|
||||
NO
|
||||
};
|
||||
|
||||
interface SampleInterface {
|
||||
DoStuff();
|
||||
};
|
||||
|
||||
struct AllTheThings {
|
||||
// Note that these types can never be marked nullable!
|
||||
bool boolean_value;
|
||||
int8 signed_8bit_value = 42;
|
||||
uint8 unsigned_8bit_value;
|
||||
int16 signed_16bit_value;
|
||||
uint16 unsigned_16bit_value;
|
||||
int32 signed_32bit_value;
|
||||
uint32 unsigned_32bit_value;
|
||||
int64 signed_64bit_value;
|
||||
uint64 unsigned_64bit_value;
|
||||
float float_value_32bit;
|
||||
double float_value_64bit;
|
||||
AnEnum enum_value = AnEnum.YES;
|
||||
|
||||
// Strings may be nullable.
|
||||
string? maybe_a_string_maybe_not;
|
||||
|
||||
// Structs may contain other structs. These may also be nullable.
|
||||
StringPair some_strings;
|
||||
StringPair? maybe_some_more_strings;
|
||||
|
||||
// In fact structs can also be nested, though in practice you must always make
|
||||
// such fields nullable -- otherwise messages would need to be infinitely long
|
||||
// in order to pass validation!
|
||||
AllTheThings? more_things;
|
||||
|
||||
// Arrays may be templated over any Mojom type, and are always nullable:
|
||||
array<int32> numbers;
|
||||
array<int32>? maybe_more_numbers;
|
||||
|
||||
// Arrays of arrays of arrays... are fine.
|
||||
array<array<array<AnEnum>>> this_works_but_really_plz_stop;
|
||||
|
||||
// The element type may be nullable if it's a type which is allowed to be
|
||||
// nullable.
|
||||
array<AllTheThings?> more_maybe_things;
|
||||
|
||||
// Fixed-size arrays get some extra validation on the receiving end to ensure
|
||||
// that the correct number of elements is always received.
|
||||
array<uint64, 2> uuid;
|
||||
|
||||
// Maps follow many of the same rules as arrays. Key types may be any
|
||||
// non-handle, non-collection type, and value types may be any supported
|
||||
// struct field type. Maps may also be nullable.
|
||||
map<string, int32> one_map;
|
||||
map<AnEnum, string>? maybe_another_map;
|
||||
map<StringPair, AllTheThings?>? maybe_a_pretty_weird_but_valid_map;
|
||||
map<StringPair, map<int32, array<map<string, string>?>?>?> ridiculous;
|
||||
|
||||
// And finally, all handle types are valid as struct fields and may be
|
||||
// nullable. Note that interfaces and interface requests (the "Foo" and
|
||||
// "Foo&" type syntax respectively) are just strongly-typed message pipe
|
||||
// handles.
|
||||
handle generic_handle;
|
||||
handle<data_pipe_consumer> reader;
|
||||
handle<data_pipe_producer>? maybe_writer;
|
||||
handle<shared_buffer> dumping_ground;
|
||||
handle<message_pipe> raw_message_pipe;
|
||||
pending_remote<SampleInterface>? maybe_a_sample_interface_client_pipe;
|
||||
pending_receiver<SampleInterface> non_nullable_sample_pending_receiver;
|
||||
pending_receiver<SampleInterface>? nullable_sample_pending_receiver;
|
||||
pending_associated_remote<SampleInterface> associated_interface_client;
|
||||
pending_associated_receiver<SampleInterface> associated_pending_receiver;
|
||||
pending_associated_receiver<SampleInterface>? maybe_another_pending_receiver;
|
||||
};
|
||||
```
|
||||
|
||||
For details on how all of these different types translate to usable generated
|
||||
code, see
|
||||
[documentation for individual target languages](#Generated-Code-For-Target-Languages).
|
||||
|
||||
### Unions
|
||||
|
||||
Mojom supports tagged unions using the **union** keyword. A union is a
|
||||
collection of fields which may taken the value of any single one of those fields
|
||||
at a time. Thus they provide a way to represent a variant value type while
|
||||
minimizing storage requirements.
|
||||
|
||||
Union fields may be of any type supported by [struct](#Structs) fields. For
|
||||
example:
|
||||
|
||||
```cpp
|
||||
union ExampleUnion {
|
||||
string str;
|
||||
StringPair pair;
|
||||
int64 id;
|
||||
array<uint64, 2> guid;
|
||||
SampleInterface iface;
|
||||
};
|
||||
```
|
||||
|
||||
For details on how unions like this translate to generated bindings code, see
|
||||
[documentation for individual target languages](#Generated-Code-For-Target-Languages).
|
||||
|
||||
### Enumeration Types
|
||||
|
||||
Enumeration types may be defined using the **enum** keyword either directly
|
||||
within a module or nested within the namespace of some struct or interface:
|
||||
|
||||
```
|
||||
module business.mojom;
|
||||
|
||||
enum Department {
|
||||
SALES = 0,
|
||||
DEV,
|
||||
};
|
||||
|
||||
struct Employee {
|
||||
enum Type {
|
||||
FULL_TIME,
|
||||
PART_TIME,
|
||||
};
|
||||
|
||||
Type type;
|
||||
// ...
|
||||
};
|
||||
```
|
||||
|
||||
Similar to C-style enums, individual values may be explicitly assigned within an
|
||||
enum definition. By default, values are based at zero and increment by
|
||||
1 sequentially.
|
||||
|
||||
The effect of nested definitions on generated bindings varies depending on the
|
||||
target language. See [documentation for individual target languages](#Generated-Code-For-Target-Languages)
|
||||
|
||||
### Constants
|
||||
|
||||
Constants may be defined using the **const** keyword either directly within a
|
||||
module or nested within the namespace of some struct or interface:
|
||||
|
||||
```
|
||||
module business.mojom;
|
||||
|
||||
const string kServiceName = "business";
|
||||
|
||||
struct Employee {
|
||||
const uint64 kInvalidId = 0;
|
||||
|
||||
enum Type {
|
||||
FULL_TIME,
|
||||
PART_TIME,
|
||||
};
|
||||
|
||||
uint64 id = kInvalidId;
|
||||
Type type;
|
||||
};
|
||||
```
|
||||
|
||||
The effect of nested definitions on generated bindings varies depending on the
|
||||
target language. See [documentation for individual target languages](#Generated-Code-For-Target-Languages)
|
||||
|
||||
### Interfaces
|
||||
|
||||
An **interface** is a logical bundle of parameterized request messages. Each
|
||||
request message may optionally define a parameterized response message. Here's
|
||||
an example to define an interface `Foo` with various kinds of requests:
|
||||
|
||||
```
|
||||
interface Foo {
|
||||
// A request which takes no arguments and expects no response.
|
||||
MyMessage();
|
||||
|
||||
// A request which has some arguments and expects no response.
|
||||
MyOtherMessage(string name, array<uint8> bytes);
|
||||
|
||||
// A request which expects a single-argument response.
|
||||
MyMessageWithResponse(string command) => (bool success);
|
||||
|
||||
// A request which expects a response with multiple arguments.
|
||||
MyMessageWithMoarResponse(string a, string b) => (int8 c, int8 d);
|
||||
};
|
||||
```
|
||||
|
||||
Anything which is a valid struct field type (see [Structs](#Structs)) is also a
|
||||
valid request or response argument type. The type notation is the same for both.
|
||||
|
||||
### Attributes
|
||||
|
||||
Mojom definitions may have their meaning altered by **attributes**, specified
|
||||
with a syntax similar to Java or C# attributes. There are a handle of
|
||||
interesting attributes supported today.
|
||||
|
||||
**`[Sync]`**
|
||||
: The `Sync` attribute may be specified for any interface method which expects
|
||||
a response. This makes it so that callers of the method can wait
|
||||
synchronously for a response. See
|
||||
[Synchronous Calls](/mojo/public/cpp/bindings/README.md#Synchronous-Calls)
|
||||
in the C++ bindings documentation. Note that sync methods are only actually
|
||||
synchronous when called from C++.
|
||||
|
||||
**`[Extensible]`**
|
||||
: The `Extensible` attribute may be specified for any enum definition. This
|
||||
essentially disables builtin range validation when receiving values of the
|
||||
enum type in a message, allowing older bindings to tolerate unrecognized
|
||||
values from newer versions of the enum.
|
||||
|
||||
**`[Native]`**
|
||||
: The `Native` attribute may be specified for an empty struct declaration to
|
||||
provide a nominal bridge between Mojo IPC and legacy `IPC::ParamTraits` or
|
||||
`IPC_STRUCT_TRAITS*` macros.
|
||||
See
|
||||
[Repurposing Legacy IPC Traits](/docs/mojo_ipc_conversion.md#repurposing-and-invocations)
|
||||
for more details. Note support for this attribute is strictly limited to C++
|
||||
bindings generation.
|
||||
|
||||
**`[MinVersion=N]`**
|
||||
: The `MinVersion` attribute is used to specify the version at which a given
|
||||
field, enum value, interface method, or method parameter was introduced.
|
||||
See [Versioning](#Versioning) for more details.
|
||||
|
||||
**`[Stable]`**
|
||||
: The `Stable` attribute specifies that a given mojom type or interface
|
||||
definition can be considered stable over time, meaning it is safe to use for
|
||||
things like persistent storage or communication between independent
|
||||
version-skewed binaries. Stable definitions may only depend on builtin mojom
|
||||
types or other stable definitions, and changes to such definitions MUST
|
||||
preserve backward-compatibility through appropriate use of versioning.
|
||||
Backward-compatibility of changes is enforced in the Chromium tree using a
|
||||
strict presubmit check. See [Versioning](#Versioning) for more details on
|
||||
backward-compatibility constraints.
|
||||
|
||||
**`[EnableIf=value]`**
|
||||
: The `EnableIf` attribute is used to conditionally enable definitions when
|
||||
the mojom is parsed. If the `mojom` target in the GN file does not include
|
||||
the matching `value` in the list of `enabled_features`, the definition
|
||||
will be disabled. This is useful for mojom definitions that only make
|
||||
sense on one platform. Note that the `EnableIf` attribute can only be set
|
||||
once per definition.
|
||||
|
||||
## Generated Code For Target Languages
|
||||
|
||||
When the bindings generator successfully processes an input Mojom file, it emits
|
||||
corresponding code for each supported target language. For more details on how
|
||||
Mojom concepts translate to a given target langauge, please refer to the
|
||||
bindings API documentation for that language:
|
||||
|
||||
* [C++ Bindings](/mojo/public/cpp/bindings/README.md)
|
||||
* [JavaScript Bindings](/mojo/public/js/README.md)
|
||||
* [Java Bindings](/mojo/public/java/bindings/README.md)
|
||||
|
||||
## Message Validation
|
||||
|
||||
Regardless of target language, all interface messages are validated during
|
||||
deserialization before they are dispatched to a receiving implementation of the
|
||||
interface. This helps to ensure consitent validation across interfaces without
|
||||
leaving the burden to developers and security reviewers every time a new message
|
||||
is added.
|
||||
|
||||
If a message fails validation, it is never dispatched. Instead a **connection
|
||||
error** is raised on the binding object (see
|
||||
[C++ Connection Errors](/mojo/public/cpp/bindings/README.md#Connection-Errors),
|
||||
[Java Connection Errors](/mojo/public/java/bindings/README.md#Connection-Errors),
|
||||
or
|
||||
[JavaScript Connection Errors](/mojo/public/js/README.md#Connection-Errors) for
|
||||
details.)
|
||||
|
||||
Some baseline level of validation is done automatically for primitive Mojom
|
||||
types.
|
||||
|
||||
### Non-Nullable Objects
|
||||
|
||||
Mojom fields or parameter values (*e.g.*, structs, interfaces, arrays, *etc.*)
|
||||
may be marked nullable in Mojom definitions (see
|
||||
[Primitive Types](#Primitive-Types).) If a field or parameter is **not** marked
|
||||
nullable but a message is received with a null value in its place, that message
|
||||
will fail validation.
|
||||
|
||||
### Enums
|
||||
|
||||
Enums declared in Mojom are automatically validated against the range of legal
|
||||
values. For example if a Mojom declares the enum:
|
||||
|
||||
``` cpp
|
||||
enum AdvancedBoolean {
|
||||
TRUE = 0,
|
||||
FALSE = 1,
|
||||
FILE_NOT_FOUND = 2,
|
||||
};
|
||||
```
|
||||
|
||||
and a message is received with the integral value 3 (or anything other than 0,
|
||||
1, or 2) in place of some `AdvancedBoolean` field or parameter, the message will
|
||||
fail validation.
|
||||
|
||||
*** note
|
||||
NOTE: It's possible to avoid this type of validation error by explicitly marking
|
||||
an enum as [Extensible](#Attributes) if you anticipate your enum being exchanged
|
||||
between two different versions of the binding interface. See
|
||||
[Versioning](#Versioning).
|
||||
***
|
||||
|
||||
### Other failures
|
||||
|
||||
There are a host of internal validation errors that may occur when a malformed
|
||||
message is received, but developers should not be concerned with these
|
||||
specifically; in general they can only result from internal bindings bugs,
|
||||
compromised processes, or some remote endpoint making a dubious effort to
|
||||
manually encode their own bindings messages.
|
||||
|
||||
### Custom Validation
|
||||
|
||||
It's also possible for developers to define custom validation logic for specific
|
||||
Mojom struct types by exploiting the
|
||||
[type mapping](/mojo/public/cpp/bindings/README.md#Type-Mapping) system for C++
|
||||
bindings. Messages rejected by custom validation logic trigger the same
|
||||
validation failure behavior as the built-in type validation routines.
|
||||
|
||||
## Associated Interfaces
|
||||
|
||||
As mentioned in the [Primitive Types](#Primitive-Types) section above, pending_remote
|
||||
and pending_receiver fields and parameters may be marked as `associated`. This
|
||||
essentially means that they are piggy-backed on some other interface's message
|
||||
pipe.
|
||||
|
||||
Because individual interface message pipes operate independently there can be no
|
||||
relative ordering guarantees among them. Associated interfaces are useful when
|
||||
one interface needs to guarantee strict FIFO ordering with respect to one or
|
||||
more other interfaces, as they allow interfaces to share a single pipe.
|
||||
|
||||
Currently associated interfaces are only supported in generated C++ bindings.
|
||||
See the documentation for
|
||||
[C++ Associated Interfaces](/mojo/public/cpp/bindings/README.md#Associated-Interfaces).
|
||||
|
||||
## Versioning
|
||||
|
||||
### Overview
|
||||
|
||||
*** note
|
||||
**NOTE:** You don't need to worry about versioning if you don't care about
|
||||
backwards compatibility. Specifically, all parts of Chrome are updated
|
||||
atomically today and there is not yet any possibility of any two Chrome
|
||||
processes communicating with two different versions of any given Mojom
|
||||
interface.
|
||||
***
|
||||
|
||||
Services extend their interfaces to support new features over time, and clients
|
||||
want to use those new features when they are available. If services and clients
|
||||
are not updated at the same time, it's important for them to be able to
|
||||
communicate with each other using different snapshots (versions) of their
|
||||
interfaces.
|
||||
|
||||
This document shows how to extend Mojom interfaces in a backwards-compatible
|
||||
way. Changing interfaces in a non-backwards-compatible way is not discussed,
|
||||
because in that case communication between different interface versions is
|
||||
impossible anyway.
|
||||
|
||||
### Versioned Structs
|
||||
|
||||
You can use the `MinVersion` [attribute](#Attributes) to indicate from which
|
||||
version a struct field is introduced. Assume you have the following struct:
|
||||
|
||||
``` cpp
|
||||
struct Employee {
|
||||
uint64 employee_id;
|
||||
string name;
|
||||
};
|
||||
```
|
||||
|
||||
and you would like to add a birthday field. You can do:
|
||||
|
||||
``` cpp
|
||||
struct Employee {
|
||||
uint64 employee_id;
|
||||
string name;
|
||||
[MinVersion=1] Date? birthday;
|
||||
};
|
||||
```
|
||||
|
||||
By default, fields belong to version 0. New fields must be appended to the
|
||||
struct definition (*i.e*., existing fields must not change **ordinal value**)
|
||||
with the `MinVersion` attribute set to a number greater than any previous
|
||||
existing versions.
|
||||
|
||||
*** note
|
||||
**NOTE:** do not change existing fields in versioned structs, as this is
|
||||
not backwards-compatible. Instead, rename the old field to make its
|
||||
deprecation clear and add a new field with the new version number.
|
||||
***
|
||||
|
||||
**Ordinal value** refers to the relative positional layout of a struct's fields
|
||||
(and an interface's methods) when encoded in a message. Implicitly, ordinal
|
||||
numbers are assigned to fields according to lexical position. In the example
|
||||
above, `employee_id` has an ordinal value of 0 and `name` has an ordinal value
|
||||
of 1.
|
||||
|
||||
Ordinal values can be specified explicitly using `**@**` notation, subject to
|
||||
the following hard constraints:
|
||||
|
||||
* For any given struct or interface, if any field or method explicitly specifies
|
||||
an ordinal value, all fields or methods must explicitly specify an ordinal
|
||||
value.
|
||||
* For an *N*-field struct or *N*-method interface, the set of explicitly
|
||||
assigned ordinal values must be limited to the range *[0, N-1]*. Interfaces
|
||||
should include placeholder methods to fill the ordinal positions of removed
|
||||
methods (for example "Unused_Message_7@7()" or "RemovedMessage@42()", etc).
|
||||
|
||||
You may reorder fields, but you must ensure that the ordinal values of existing
|
||||
fields remain unchanged. For example, the following struct remains
|
||||
backwards-compatible:
|
||||
|
||||
``` cpp
|
||||
struct Employee {
|
||||
uint64 employee_id@0;
|
||||
[MinVersion=1] Date? birthday@2;
|
||||
string name@1;
|
||||
};
|
||||
```
|
||||
|
||||
*** note
|
||||
**NOTE:** Newly added fields of Mojo object or handle types MUST be nullable.
|
||||
See [Primitive Types](#Primitive-Types).
|
||||
***
|
||||
|
||||
### Versioned Interfaces
|
||||
|
||||
There are two dimensions on which an interface can be extended
|
||||
|
||||
**Appending New Parameters To Existing Methods**
|
||||
: Parameter lists are treated as structs internally, so all the rules of
|
||||
versioned structs apply to method parameter lists. The only difference is
|
||||
that the version number is scoped to the whole interface rather than to any
|
||||
individual parameter list.
|
||||
|
||||
Please note that adding a response to a message which did not previously
|
||||
expect a response is a not a backwards-compatible change.
|
||||
|
||||
**Appending New Methods**
|
||||
: Similarly, you can reorder methods with explicit ordinal values as long as
|
||||
the ordinal values of existing methods are unchanged.
|
||||
|
||||
For example:
|
||||
|
||||
``` cpp
|
||||
// Old version:
|
||||
interface HumanResourceDatabase {
|
||||
AddEmployee(Employee employee) => (bool success);
|
||||
QueryEmployee(uint64 id) => (Employee? employee);
|
||||
};
|
||||
|
||||
// New version:
|
||||
interface HumanResourceDatabase {
|
||||
AddEmployee(Employee employee) => (bool success);
|
||||
|
||||
QueryEmployee(uint64 id, [MinVersion=1] bool retrieve_finger_print)
|
||||
=> (Employee? employee,
|
||||
[MinVersion=1] array<uint8>? finger_print);
|
||||
|
||||
[MinVersion=1]
|
||||
AttachFingerPrint(uint64 id, array<uint8> finger_print)
|
||||
=> (bool success);
|
||||
};
|
||||
```
|
||||
|
||||
Similar to [versioned structs](#Versioned-Structs), when you pass the parameter
|
||||
list of a request or response method to a destination using an older version of
|
||||
an interface, unrecognized fields are silently discarded. However, if the method
|
||||
call itself is not recognized, it is considered a validation error and the
|
||||
receiver will close its end of the interface pipe. For example, if a client on
|
||||
version 1 of the above interface sends an `AttachFingerPrint` request to an
|
||||
implementation of version 0, the client will be disconnected.
|
||||
|
||||
Bindings target languages that support versioning expose means to query or
|
||||
assert the remote version from a client handle (*e.g.*, an
|
||||
`mojo::Remote<T>` in C++ bindings.)
|
||||
|
||||
See
|
||||
[C++ Versioning Considerations](/mojo/public/cpp/bindings/README.md#Versioning-Considerations)
|
||||
and
|
||||
[Java Versioning Considerations](/mojo/public/java/bindings/README.md#Versioning-Considerations)
|
||||
|
||||
### Versioned Enums
|
||||
|
||||
**By default, enums are non-extensible**, which means that generated message
|
||||
validation code does not expect to see new values in the future. When an unknown
|
||||
value is seen for a non-extensible enum field or parameter, a validation error
|
||||
is raised.
|
||||
|
||||
If you want an enum to be extensible in the future, you can apply the
|
||||
`[Extensible]` [attribute](#Attributes):
|
||||
|
||||
``` cpp
|
||||
[Extensible]
|
||||
enum Department {
|
||||
SALES,
|
||||
DEV,
|
||||
};
|
||||
```
|
||||
|
||||
And later you can extend this enum without breaking backwards compatibility:
|
||||
|
||||
``` cpp
|
||||
[Extensible]
|
||||
enum Department {
|
||||
SALES,
|
||||
DEV,
|
||||
[MinVersion=1] RESEARCH,
|
||||
};
|
||||
```
|
||||
|
||||
*** note
|
||||
**NOTE:** For versioned enum definitions, the use of a `[MinVersion]` attribute
|
||||
is strictly for documentation purposes. It has no impact on the generated code.
|
||||
***
|
||||
|
||||
With extensible enums, bound interface implementations may receive unknown enum
|
||||
values and will need to deal with them gracefully. See
|
||||
[C++ Versioning Considerations](/mojo/public/cpp/bindings/README.md#Versioning-Considerations)
|
||||
for details.
|
||||
|
||||
## Grammar Reference
|
||||
|
||||
Below is the (BNF-ish) context-free grammar of the Mojom language:
|
||||
|
||||
```
|
||||
MojomFile = StatementList
|
||||
StatementList = Statement StatementList | Statement
|
||||
Statement = ModuleStatement | ImportStatement | Definition
|
||||
|
||||
ModuleStatement = AttributeSection "module" Identifier ";"
|
||||
ImportStatement = "import" StringLiteral ";"
|
||||
Definition = Struct Union Interface Enum Const
|
||||
|
||||
AttributeSection = <empty> | "[" AttributeList "]"
|
||||
AttributeList = <empty> | NonEmptyAttributeList
|
||||
NonEmptyAttributeList = Attribute
|
||||
| Attribute "," NonEmptyAttributeList
|
||||
Attribute = Name
|
||||
| Name "=" Name
|
||||
| Name "=" Literal
|
||||
|
||||
Struct = AttributeSection "struct" Name "{" StructBody "}" ";"
|
||||
| AttributeSection "struct" Name ";"
|
||||
StructBody = <empty>
|
||||
| StructBody Const
|
||||
| StructBody Enum
|
||||
| StructBody StructField
|
||||
StructField = AttributeSection TypeSpec Name Ordinal Default ";"
|
||||
|
||||
Union = AttributeSection "union" Name "{" UnionBody "}" ";"
|
||||
UnionBody = <empty> | UnionBody UnionField
|
||||
UnionField = AttributeSection TypeSpec Name Ordinal ";"
|
||||
|
||||
Interface = AttributeSection "interface" Name "{" InterfaceBody "}" ";"
|
||||
InterfaceBody = <empty>
|
||||
| InterfaceBody Const
|
||||
| InterfaceBody Enum
|
||||
| InterfaceBody Method
|
||||
Method = AttributeSection Name Ordinal "(" ParamterList ")" Response ";"
|
||||
ParameterList = <empty> | NonEmptyParameterList
|
||||
NonEmptyParameterList = Parameter
|
||||
| Parameter "," NonEmptyParameterList
|
||||
Parameter = AttributeSection TypeSpec Name Ordinal
|
||||
Response = <empty> | "=>" "(" ParameterList ")"
|
||||
|
||||
TypeSpec = TypeName "?" | TypeName
|
||||
TypeName = BasicTypeName
|
||||
| Array
|
||||
| FixedArray
|
||||
| Map
|
||||
| InterfaceRequest
|
||||
BasicTypeName = Identifier | "associated" Identifier | HandleType | NumericType
|
||||
NumericType = "bool" | "int8" | "uint8" | "int16" | "uint16" | "int32"
|
||||
| "uint32" | "int64" | "uint64" | "float" | "double"
|
||||
HandleType = "handle" | "handle" "<" SpecificHandleType ">"
|
||||
SpecificHandleType = "message_pipe"
|
||||
| "shared_buffer"
|
||||
| "data_pipe_consumer"
|
||||
| "data_pipe_producer"
|
||||
| "platform"
|
||||
Array = "array" "<" TypeSpec ">"
|
||||
FixedArray = "array" "<" TypeSpec "," IntConstDec ">"
|
||||
Map = "map" "<" Identifier "," TypeSpec ">"
|
||||
InterfaceRequest = Identifier "&" | "associated" Identifier "&"
|
||||
|
||||
Ordinal = <empty> | OrdinalValue
|
||||
|
||||
Default = <empty> | "=" Constant
|
||||
|
||||
Enum = AttributeSection "enum" Name "{" NonEmptyEnumValueList "}" ";"
|
||||
| AttributeSection "enum" Name "{" NonEmptyEnumValueList "," "}" ";"
|
||||
NonEmptyEnumValueList = EnumValue | NonEmptyEnumValueList "," EnumValue
|
||||
EnumValue = AttributeSection Name
|
||||
| AttributeSection Name "=" Integer
|
||||
| AttributeSection Name "=" Identifier
|
||||
|
||||
Const = "const" TypeSpec Name "=" Constant ";"
|
||||
|
||||
Constant = Literal | Identifier ";"
|
||||
|
||||
Identifier = Name | Name "." Identifier
|
||||
|
||||
Literal = Integer | Float | "true" | "false" | "default" | StringLiteral
|
||||
|
||||
Integer = IntConst | "+" IntConst | "-" IntConst
|
||||
IntConst = IntConstDec | IntConstHex
|
||||
|
||||
Float = FloatConst | "+" FloatConst | "-" FloatConst
|
||||
|
||||
; The rules below are for tokens matched strictly according to the given regexes
|
||||
|
||||
Identifier = /[a-zA-Z_][0-9a-zA-Z_]*/
|
||||
IntConstDec = /0|(1-9[0-9]*)/
|
||||
IntConstHex = /0[xX][0-9a-fA-F]+/
|
||||
OrdinalValue = /@(0|(1-9[0-9]*))/
|
||||
FloatConst = ... # Imagine it's close enough to C-style float syntax.
|
||||
StringLiteral = ... # Imagine it's close enough to C-style string literals, including escapes.
|
||||
```
|
||||
|
||||
## Additional Documentation
|
||||
|
||||
[Mojom Message Format](https://docs.google.com/document/d/13pv9cFh5YKuBggDBQ1-AL8VReF-IYpFOFpRfvWFrwio/edit)
|
||||
: Describes the wire format used by Mojo bindings interfaces over message
|
||||
pipes.
|
||||
|
||||
[Input Format of Mojom Message Validation Tests](https://docs.google.com/document/d/1-y-2IYctyX2NPaLxJjpJfzVNWCC2SR2MJAD9MpIytHQ/edit)
|
||||
: Describes a text format used to facilitate bindings message validation
|
||||
tests.
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
# Copyright 2016 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.
|
||||
|
||||
_typemap_imports = [
|
||||
"//chrome/chrome_cleaner/mojom/typemaps/typemaps.gni",
|
||||
"//chrome/common/importer/typemaps.gni",
|
||||
"//chrome/common/media_router/mojom/typemaps.gni",
|
||||
"//chrome/typemaps.gni",
|
||||
"//chromecast/typemaps.gni",
|
||||
"//chromeos/typemaps.gni",
|
||||
"//chromeos/components/multidevice/mojom/typemaps.gni",
|
||||
"//chromeos/services/cros_healthd/public/mojom/typemaps.gni",
|
||||
"//chromeos/services/device_sync/public/mojom/typemaps.gni",
|
||||
"//chromeos/services/network_config/public/mojom/typemaps.gni",
|
||||
"//chromeos/services/secure_channel/public/mojom/typemaps.gni",
|
||||
"//components/arc/mojom/typemaps.gni",
|
||||
"//components/chromeos_camera/common/typemaps.gni",
|
||||
"//components/services/storage/public/cpp/filesystem/typemaps.gni",
|
||||
"//components/sync/mojom/typemaps.gni",
|
||||
"//components/typemaps.gni",
|
||||
"//content/browser/typemaps.gni",
|
||||
"//content/public/common/typemaps.gni",
|
||||
"//sandbox/mac/mojom/typemaps.gni",
|
||||
"//services/media_session/public/cpp/typemaps.gni",
|
||||
"//services/proxy_resolver/public/cpp/typemaps.gni",
|
||||
"//services/resource_coordinator/public/cpp/typemaps.gni",
|
||||
"//services/service_manager/public/cpp/typemaps.gni",
|
||||
"//services/tracing/public/mojom/typemaps.gni",
|
||||
]
|
||||
|
||||
_typemaps = []
|
||||
foreach(typemap_import, _typemap_imports) {
|
||||
# Avoid reassignment error by assigning to empty scope first.
|
||||
_imported = {
|
||||
}
|
||||
_imported = read_file(typemap_import, "scope")
|
||||
_typemaps += _imported.typemaps
|
||||
}
|
||||
|
||||
typemaps = []
|
||||
foreach(typemap, _typemaps) {
|
||||
typemaps += [
|
||||
{
|
||||
filename = typemap
|
||||
config = read_file(typemap, "scope")
|
||||
},
|
||||
]
|
||||
}
|
||||
|
||||
component_macro_suffix = ""
|
||||
27
utils/ipc/mojo/public/tools/bindings/compile_typescript.py
Normal file
27
utils/ipc/mojo/public/tools/bindings/compile_typescript.py
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
# Copyright 2019 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 os
|
||||
import sys
|
||||
import argparse
|
||||
|
||||
_HERE_PATH = os.path.dirname(__file__)
|
||||
_SRC_PATH = os.path.normpath(os.path.join(_HERE_PATH, '..', '..', '..', '..'))
|
||||
|
||||
sys.path.append(os.path.join(_SRC_PATH, 'third_party', 'node'))
|
||||
import node
|
||||
import node_modules
|
||||
|
||||
def main(argv):
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('--tsconfig_path', required=True)
|
||||
args = parser.parse_args(argv)
|
||||
|
||||
result = node.RunNode([node_modules.PathToTypescript()] +
|
||||
['--project', args.tsconfig_path])
|
||||
if len(result) != 0:
|
||||
raise RuntimeError('Failed to compile Typescript: \n%s' % result)
|
||||
|
||||
if __name__ == '__main__':
|
||||
main(sys.argv[1:])
|
||||
54
utils/ipc/mojo/public/tools/bindings/concatenate-files.py
Executable file
54
utils/ipc/mojo/public/tools/bindings/concatenate-files.py
Executable file
|
|
@ -0,0 +1,54 @@
|
|||
#!/usr/bin/env python
|
||||
# Copyright 2019 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.
|
||||
#
|
||||
# This utility concatenates several files into one. On Unix-like systems
|
||||
# it is equivalent to:
|
||||
# cat file1 file2 file3 ...files... > target
|
||||
#
|
||||
# The reason for writing a separate utility is that 'cat' is not available
|
||||
# on all supported build platforms, but Python is, and hence this provides
|
||||
# us with an easy and uniform way of doing this on all platforms.
|
||||
|
||||
# for py2/py3 compatibility
|
||||
from __future__ import print_function
|
||||
|
||||
import optparse
|
||||
|
||||
|
||||
def Concatenate(filenames):
|
||||
"""Concatenate files.
|
||||
|
||||
Args:
|
||||
files: Array of file names.
|
||||
The last name is the target; all earlier ones are sources.
|
||||
|
||||
Returns:
|
||||
True, if the operation was successful.
|
||||
"""
|
||||
if len(filenames) < 2:
|
||||
print("An error occurred generating %s:\nNothing to do." % filenames[-1])
|
||||
return False
|
||||
|
||||
try:
|
||||
with open(filenames[-1], "wb") as target:
|
||||
for filename in filenames[:-1]:
|
||||
with open(filename, "rb") as current:
|
||||
target.write(current.read())
|
||||
return True
|
||||
except IOError as e:
|
||||
print("An error occurred when writing %s:\n%s" % (filenames[-1], e))
|
||||
return False
|
||||
|
||||
|
||||
def main():
|
||||
parser = optparse.OptionParser()
|
||||
parser.set_usage("""Concatenate several files into one.
|
||||
Equivalent to: cat file1 ... > target.""")
|
||||
(_options, args) = parser.parse_args()
|
||||
exit(0 if Concatenate(args) else 1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#!/usr/bin/env python
|
||||
# Copyright 2018 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.
|
||||
|
||||
"""Simple utility which concatenates a set of files into a single output file
|
||||
while also stripping any goog.provide or goog.require lines. This allows us to
|
||||
provide a very primitive sort of "compilation" without any extra toolchain
|
||||
support and without having to modify otherwise compilable sources in the tree
|
||||
which use these directives.
|
||||
|
||||
goog.provide lines are replaced with an equivalent invocation of
|
||||
mojo.internal.exportModule, which accomplishes essentially the same thing in an
|
||||
uncompiled context. A singular exception is made for the 'mojo.internal' export,
|
||||
which is instead replaced with an inlined assignment to initialize the
|
||||
namespace.
|
||||
"""
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import optparse
|
||||
import re
|
||||
|
||||
|
||||
_MOJO_INTERNAL_MODULE_NAME = "mojo.internal"
|
||||
_MOJO_EXPORT_MODULE_SYMBOL = "mojo.internal.exportModule"
|
||||
|
||||
|
||||
def FilterLine(filename, line, output):
|
||||
if line.startswith("goog.require"):
|
||||
return
|
||||
|
||||
if line.startswith("goog.provide"):
|
||||
match = re.match("goog.provide\('([^']+)'\);", line)
|
||||
if not match:
|
||||
print("Invalid goog.provide line in %s:\n%s" % (filename, line))
|
||||
exit(1)
|
||||
|
||||
module_name = match.group(1)
|
||||
if module_name == _MOJO_INTERNAL_MODULE_NAME:
|
||||
output.write("self.mojo = { internal: {} };")
|
||||
else:
|
||||
output.write("%s('%s');\n" % (_MOJO_EXPORT_MODULE_SYMBOL, module_name))
|
||||
return
|
||||
|
||||
output.write(line)
|
||||
|
||||
def ConcatenateAndReplaceExports(filenames):
|
||||
if (len(filenames) < 2):
|
||||
print("At least two filenames (one input and the output) are required.")
|
||||
return False
|
||||
|
||||
try:
|
||||
with open(filenames[-1], "w") as target:
|
||||
for filename in filenames[:-1]:
|
||||
with open(filename, "r") as current:
|
||||
for line in current.readlines():
|
||||
FilterLine(filename, line, target)
|
||||
return True
|
||||
except IOError as e:
|
||||
print("Error generating %s\n: %s" % (filenames[-1], e))
|
||||
return False
|
||||
|
||||
def main():
|
||||
parser = optparse.OptionParser()
|
||||
parser.set_usage("""file1 [file2...] outfile
|
||||
Concatenate several files into one, stripping Closure provide and
|
||||
require directives along the way.""")
|
||||
(_, args) = parser.parse_args()
|
||||
exit(0 if ConcatenateAndReplaceExports(args) else 1)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
36
utils/ipc/mojo/public/tools/bindings/format_typemap_generator_args.py
Executable file
36
utils/ipc/mojo/public/tools/bindings/format_typemap_generator_args.py
Executable file
|
|
@ -0,0 +1,36 @@
|
|||
#!/usr/bin/env python
|
||||
# Copyright 2016 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.
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import sys
|
||||
|
||||
# This utility converts mojom dependencies into their corresponding typemap
|
||||
# paths and formats them to be consumed by generate_type_mappings.py.
|
||||
|
||||
|
||||
def FormatTypemap(typemap_filename):
|
||||
# A simple typemap is valid Python with a minor alteration.
|
||||
with open(typemap_filename) as f:
|
||||
typemap_content = f.read().replace('=\n', '=')
|
||||
typemap = {}
|
||||
exec typemap_content in typemap
|
||||
|
||||
for header in typemap.get('public_headers', []):
|
||||
yield 'public_headers=%s' % header
|
||||
for header in typemap.get('traits_headers', []):
|
||||
yield 'traits_headers=%s' % header
|
||||
for header in typemap.get('type_mappings', []):
|
||||
yield 'type_mappings=%s' % header
|
||||
|
||||
|
||||
def main():
|
||||
typemaps = sys.argv[1:]
|
||||
print(' '.join('--start-typemap %s' % ' '.join(FormatTypemap(typemap))
|
||||
for typemap in typemaps))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
52
utils/ipc/mojo/public/tools/bindings/gen_data_files_list.py
Normal file
52
utils/ipc/mojo/public/tools/bindings/gen_data_files_list.py
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
# Copyright 2017 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.
|
||||
"""Generates a list of all files in a directory.
|
||||
|
||||
This script takes in a directory and an output file name as input.
|
||||
It then reads the directory and creates a list of all file names
|
||||
in that directory. The list is written to the output file.
|
||||
There is also an option to pass in '-p' or '--pattern'
|
||||
which will check each file name against a regular expression
|
||||
pattern that is passed in. Only files which match the regex
|
||||
will be written to the list.
|
||||
"""
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
from cStringIO import StringIO
|
||||
from optparse import OptionParser
|
||||
|
||||
sys.path.insert(
|
||||
0,
|
||||
os.path.join(
|
||||
os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "mojom"))
|
||||
|
||||
from mojom.generate.generator import WriteFile
|
||||
|
||||
|
||||
def main():
|
||||
parser = OptionParser()
|
||||
parser.add_option('-d', '--directory', help='Read files from DIRECTORY')
|
||||
parser.add_option('-o', '--output', help='Write list to FILE')
|
||||
parser.add_option('-p',
|
||||
'--pattern',
|
||||
help='Only reads files that name matches PATTERN',
|
||||
default=".")
|
||||
(options, _) = parser.parse_args()
|
||||
pattern = re.compile(options.pattern)
|
||||
files = [f for f in os.listdir(options.directory) if pattern.match(f)]
|
||||
|
||||
stream = StringIO()
|
||||
for f in files:
|
||||
print(f, file=stream)
|
||||
|
||||
WriteFile(stream.getvalue(), options.output)
|
||||
stream.close()
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
187
utils/ipc/mojo/public/tools/bindings/generate_type_mappings.py
Executable file
187
utils/ipc/mojo/public/tools/bindings/generate_type_mappings.py
Executable file
|
|
@ -0,0 +1,187 @@
|
|||
#!/usr/bin/env python
|
||||
# Copyright 2016 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.
|
||||
"""Generates a JSON typemap from its command-line arguments and dependencies.
|
||||
|
||||
Each typemap should be specified in an command-line argument of the form
|
||||
key=value, with an argument of "--start-typemap" preceding each typemap.
|
||||
|
||||
For example,
|
||||
generate_type_mappings.py --output=foo.typemap --start-typemap \\
|
||||
public_headers=foo.h traits_headers=foo_traits.h \\
|
||||
type_mappings=mojom.Foo=FooImpl
|
||||
|
||||
generates a foo.typemap containing
|
||||
{
|
||||
"c++": {
|
||||
"mojom.Foo": {
|
||||
"typename": "FooImpl",
|
||||
"traits_headers": [
|
||||
"foo_traits.h"
|
||||
],
|
||||
"public_headers": [
|
||||
"foo.h"
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Then,
|
||||
generate_type_mappings.py --dependency foo.typemap --output=bar.typemap \\
|
||||
--start-typemap public_headers=bar.h traits_headers=bar_traits.h \\
|
||||
type_mappings=mojom.Bar=BarImpl
|
||||
|
||||
generates a bar.typemap containing
|
||||
{
|
||||
"c++": {
|
||||
"mojom.Bar": {
|
||||
"typename": "BarImpl",
|
||||
"traits_headers": [
|
||||
"bar_traits.h"
|
||||
],
|
||||
"public_headers": [
|
||||
"bar.h"
|
||||
]
|
||||
},
|
||||
"mojom.Foo": {
|
||||
"typename": "FooImpl",
|
||||
"traits_headers": [
|
||||
"foo_traits.h"
|
||||
],
|
||||
"public_headers": [
|
||||
"foo.h"
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
sys.path.insert(
|
||||
0,
|
||||
os.path.join(
|
||||
os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "mojom"))
|
||||
|
||||
from mojom.generate.generator import WriteFile
|
||||
|
||||
def ReadTypemap(path):
|
||||
with open(path) as f:
|
||||
return json.load(f)['c++']
|
||||
|
||||
|
||||
def ParseTypemapArgs(args):
|
||||
typemaps = [s for s in '\n'.join(args).split('--start-typemap\n') if s]
|
||||
result = {}
|
||||
for typemap in typemaps:
|
||||
result.update(ParseTypemap(typemap))
|
||||
return result
|
||||
|
||||
|
||||
def LoadCppTypemapConfig(path):
|
||||
configs = {}
|
||||
with open(path) as f:
|
||||
for config in json.load(f):
|
||||
for entry in config['types']:
|
||||
configs[entry['mojom']] = {
|
||||
'typename': entry['cpp'],
|
||||
'public_headers': config.get('traits_headers', []),
|
||||
'traits_headers': config.get('traits_private_headers', []),
|
||||
'copyable_pass_by_value': entry.get('copyable_pass_by_value',
|
||||
False),
|
||||
'force_serialize': entry.get('force_serialize', False),
|
||||
'hashable': entry.get('hashable', False),
|
||||
'move_only': entry.get('move_only', False),
|
||||
'nullable_is_same_type': entry.get('nullable_is_same_type', False),
|
||||
'non_copyable_non_movable': False,
|
||||
}
|
||||
return configs
|
||||
|
||||
|
||||
def ParseTypemap(typemap):
|
||||
values = {'type_mappings': [], 'public_headers': [], 'traits_headers': []}
|
||||
for line in typemap.split('\n'):
|
||||
if not line:
|
||||
continue
|
||||
key, _, value = line.partition('=')
|
||||
values[key].append(value.lstrip('/'))
|
||||
result = {}
|
||||
mapping_pattern = \
|
||||
re.compile(r"""^([^=]+) # mojom type
|
||||
=
|
||||
([^[]+) # native type
|
||||
(?:\[([^]]+)\])?$ # optional attribute in square brackets
|
||||
""", re.X)
|
||||
for typename in values['type_mappings']:
|
||||
match_result = mapping_pattern.match(typename)
|
||||
assert match_result, (
|
||||
"Cannot parse entry in the \"type_mappings\" section: %s" % typename)
|
||||
|
||||
mojom_type = match_result.group(1)
|
||||
native_type = match_result.group(2)
|
||||
attributes = []
|
||||
if match_result.group(3):
|
||||
attributes = match_result.group(3).split(',')
|
||||
|
||||
assert mojom_type not in result, (
|
||||
"Cannot map multiple native types (%s, %s) to the same mojom type: %s" %
|
||||
(result[mojom_type]['typename'], native_type, mojom_type))
|
||||
|
||||
result[mojom_type] = {
|
||||
'public_headers': values['public_headers'],
|
||||
'traits_headers': values['traits_headers'],
|
||||
'typename': native_type,
|
||||
|
||||
# Attributes supported for individual mappings.
|
||||
'copyable_pass_by_value': 'copyable_pass_by_value' in attributes,
|
||||
'force_serialize': 'force_serialize' in attributes,
|
||||
'hashable': 'hashable' in attributes,
|
||||
'move_only': 'move_only' in attributes,
|
||||
'non_copyable_non_movable': 'non_copyable_non_movable' in attributes,
|
||||
'nullable_is_same_type': 'nullable_is_same_type' in attributes,
|
||||
}
|
||||
return result
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(
|
||||
description=__doc__,
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
parser.add_argument(
|
||||
'--dependency',
|
||||
type=str,
|
||||
action='append',
|
||||
default=[],
|
||||
help=('A path to another JSON typemap to merge into the output. '
|
||||
'This may be repeated to merge multiple typemaps.'))
|
||||
parser.add_argument(
|
||||
'--cpp-typemap-config',
|
||||
type=str,
|
||||
action='store',
|
||||
dest='cpp_config_path',
|
||||
help=('A path to a single JSON-formatted typemap config as emitted by'
|
||||
'GN when processing a mojom_cpp_typemap build rule.'))
|
||||
parser.add_argument('--output',
|
||||
type=str,
|
||||
required=True,
|
||||
help='The path to which to write the generated JSON.')
|
||||
params, typemap_params = parser.parse_known_args()
|
||||
typemaps = ParseTypemapArgs(typemap_params)
|
||||
if params.cpp_config_path:
|
||||
typemaps.update(LoadCppTypemapConfig(params.cpp_config_path))
|
||||
missing = [path for path in params.dependency if not os.path.exists(path)]
|
||||
if missing:
|
||||
raise IOError('Missing dependencies: %s' % ', '.join(missing))
|
||||
for path in params.dependency:
|
||||
typemaps.update(ReadTypemap(path))
|
||||
|
||||
WriteFile(json.dumps({'c++': typemaps}, indent=2), params.output)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
1941
utils/ipc/mojo/public/tools/bindings/mojom.gni
Normal file
1941
utils/ipc/mojo/public/tools/bindings/mojom.gni
Normal file
File diff suppressed because it is too large
Load diff
390
utils/ipc/mojo/public/tools/bindings/mojom_bindings_generator.py
Executable file
390
utils/ipc/mojo/public/tools/bindings/mojom_bindings_generator.py
Executable file
|
|
@ -0,0 +1,390 @@
|
|||
#!/usr/bin/env python
|
||||
# Copyright 2013 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.
|
||||
|
||||
"""The frontend for the Mojo bindings system."""
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import argparse
|
||||
|
||||
import hashlib
|
||||
import importlib
|
||||
import json
|
||||
import os
|
||||
import pprint
|
||||
import re
|
||||
import struct
|
||||
import sys
|
||||
|
||||
# Disable lint check for finding modules:
|
||||
# pylint: disable=F0401
|
||||
|
||||
def _GetDirAbove(dirname):
|
||||
"""Returns the directory "above" this file containing |dirname| (which must
|
||||
also be "above" this file)."""
|
||||
path = os.path.abspath(__file__)
|
||||
while True:
|
||||
path, tail = os.path.split(path)
|
||||
assert tail
|
||||
if tail == dirname:
|
||||
return path
|
||||
|
||||
|
||||
sys.path.insert(
|
||||
0,
|
||||
os.path.join(
|
||||
os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "mojom"))
|
||||
|
||||
from mojom.error import Error
|
||||
import mojom.fileutil as fileutil
|
||||
from mojom.generate.module import Module
|
||||
from mojom.generate import template_expander
|
||||
from mojom.generate import translate
|
||||
from mojom.generate.generator import WriteFile
|
||||
|
||||
sys.path.append(
|
||||
os.path.join(_GetDirAbove("mojo"), "tools", "diagnosis"))
|
||||
import crbug_1001171
|
||||
|
||||
|
||||
_BUILTIN_GENERATORS = {
|
||||
"c++": "mojom_cpp_generator",
|
||||
"javascript": "mojom_js_generator",
|
||||
"java": "mojom_java_generator",
|
||||
"mojolpm": "mojom_mojolpm_generator",
|
||||
"typescript": "mojom_ts_generator",
|
||||
}
|
||||
|
||||
|
||||
def LoadGenerators(generators_string):
|
||||
if not generators_string:
|
||||
return [] # No generators.
|
||||
|
||||
generators = {}
|
||||
for generator_name in [s.strip() for s in generators_string.split(",")]:
|
||||
language = generator_name.lower()
|
||||
if language not in _BUILTIN_GENERATORS:
|
||||
print("Unknown generator name %s" % generator_name)
|
||||
sys.exit(1)
|
||||
generator_module = importlib.import_module(
|
||||
"generators.%s" % _BUILTIN_GENERATORS[language])
|
||||
generators[language] = generator_module
|
||||
return generators
|
||||
|
||||
|
||||
def MakeImportStackMessage(imported_filename_stack):
|
||||
"""Make a (human-readable) message listing a chain of imports. (Returned
|
||||
string begins with a newline (if nonempty) and does not end with one.)"""
|
||||
return ''.join(
|
||||
reversed(["\n %s was imported by %s" % (a, b) for (a, b) in \
|
||||
zip(imported_filename_stack[1:], imported_filename_stack)]))
|
||||
|
||||
|
||||
class RelativePath(object):
|
||||
"""Represents a path relative to the source tree or generated output dir."""
|
||||
|
||||
def __init__(self, path, source_root, output_dir):
|
||||
self.path = path
|
||||
if path.startswith(source_root):
|
||||
self.root = source_root
|
||||
elif path.startswith(output_dir):
|
||||
self.root = output_dir
|
||||
else:
|
||||
raise Exception("Invalid input path %s" % path)
|
||||
|
||||
def relative_path(self):
|
||||
return os.path.relpath(
|
||||
os.path.abspath(self.path), os.path.abspath(self.root))
|
||||
|
||||
|
||||
def _GetModulePath(path, output_dir):
|
||||
return os.path.join(output_dir, path.relative_path() + '-module')
|
||||
|
||||
|
||||
def ScrambleMethodOrdinals(interfaces, salt):
|
||||
already_generated = set()
|
||||
for interface in interfaces:
|
||||
i = 0
|
||||
already_generated.clear()
|
||||
for method in interface.methods:
|
||||
if method.explicit_ordinal is not None:
|
||||
continue
|
||||
while True:
|
||||
i = i + 1
|
||||
if i == 1000000:
|
||||
raise Exception("Could not generate %d method ordinals for %s" %
|
||||
(len(interface.methods), interface.mojom_name))
|
||||
# Generate a scrambled method.ordinal value. The algorithm doesn't have
|
||||
# to be very strong, cryptographically. It just needs to be non-trivial
|
||||
# to guess the results without the secret salt, in order to make it
|
||||
# harder for a compromised process to send fake Mojo messages.
|
||||
sha256 = hashlib.sha256(salt)
|
||||
sha256.update(interface.mojom_name.encode('utf-8'))
|
||||
sha256.update(str(i).encode('utf-8'))
|
||||
# Take the first 4 bytes as a little-endian uint32.
|
||||
ordinal = struct.unpack('<L', sha256.digest()[:4])[0]
|
||||
# Trim to 31 bits, so it always fits into a Java (signed) int.
|
||||
ordinal = ordinal & 0x7fffffff
|
||||
if ordinal in already_generated:
|
||||
continue
|
||||
already_generated.add(ordinal)
|
||||
method.ordinal = ordinal
|
||||
method.ordinal_comment = (
|
||||
'The %s value is based on sha256(salt + "%s%d").' %
|
||||
(ordinal, interface.mojom_name, i))
|
||||
break
|
||||
|
||||
|
||||
def ReadFileContents(filename):
|
||||
with open(filename, 'rb') as f:
|
||||
return f.read()
|
||||
|
||||
|
||||
class MojomProcessor(object):
|
||||
"""Takes parsed mojom modules and generates language bindings from them.
|
||||
|
||||
Attributes:
|
||||
_processed_files: {Dict[str, mojom.generate.module.Module]} Mapping from
|
||||
relative mojom filename paths to the module AST for that mojom file.
|
||||
"""
|
||||
def __init__(self, should_generate):
|
||||
self._should_generate = should_generate
|
||||
self._processed_files = {}
|
||||
self._typemap = {}
|
||||
|
||||
def LoadTypemaps(self, typemaps):
|
||||
# Support some very simple single-line comments in typemap JSON.
|
||||
comment_expr = r"^\s*//.*$"
|
||||
def no_comments(line):
|
||||
return not re.match(comment_expr, line)
|
||||
for filename in typemaps:
|
||||
with open(filename) as f:
|
||||
typemaps = json.loads("".join(filter(no_comments, f.readlines())))
|
||||
for language, typemap in typemaps.items():
|
||||
language_map = self._typemap.get(language, {})
|
||||
language_map.update(typemap)
|
||||
self._typemap[language] = language_map
|
||||
if 'c++' in self._typemap:
|
||||
self._typemap['mojolpm'] = self._typemap['c++']
|
||||
|
||||
def _GenerateModule(self, args, remaining_args, generator_modules,
|
||||
rel_filename, imported_filename_stack):
|
||||
# Return the already-generated module.
|
||||
if rel_filename.path in self._processed_files:
|
||||
return self._processed_files[rel_filename.path]
|
||||
|
||||
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)
|
||||
|
||||
module_path = _GetModulePath(rel_filename, args.output_dir)
|
||||
with open(module_path, 'rb') as f:
|
||||
module = Module.Load(f)
|
||||
|
||||
if args.scrambled_message_id_salt_paths:
|
||||
salt = b''.join(
|
||||
map(ReadFileContents, args.scrambled_message_id_salt_paths))
|
||||
ScrambleMethodOrdinals(module.interfaces, salt)
|
||||
|
||||
if self._should_generate(rel_filename.path):
|
||||
for language, generator_module in generator_modules.items():
|
||||
generator = generator_module.Generator(
|
||||
module, args.output_dir, typemap=self._typemap.get(language, {}),
|
||||
variant=args.variant, bytecode_path=args.bytecode_path,
|
||||
for_blink=args.for_blink,
|
||||
js_bindings_mode=args.js_bindings_mode,
|
||||
js_generate_struct_deserializers=\
|
||||
args.js_generate_struct_deserializers,
|
||||
export_attribute=args.export_attribute,
|
||||
export_header=args.export_header,
|
||||
generate_non_variant_code=args.generate_non_variant_code,
|
||||
support_lazy_serialization=args.support_lazy_serialization,
|
||||
disallow_native_types=args.disallow_native_types,
|
||||
disallow_interfaces=args.disallow_interfaces,
|
||||
generate_message_ids=args.generate_message_ids,
|
||||
generate_fuzzing=args.generate_fuzzing,
|
||||
enable_kythe_annotations=args.enable_kythe_annotations,
|
||||
extra_cpp_template_paths=args.extra_cpp_template_paths,
|
||||
generate_extra_cpp_only=args.generate_extra_cpp_only)
|
||||
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[rel_filename.path] = module
|
||||
return module
|
||||
|
||||
|
||||
def _Generate(args, remaining_args):
|
||||
if args.variant == "none":
|
||||
args.variant = None
|
||||
|
||||
for idx, import_dir in enumerate(args.import_directories):
|
||||
tokens = import_dir.split(":")
|
||||
if len(tokens) >= 2:
|
||||
args.import_directories[idx] = RelativePath(tokens[0], tokens[1],
|
||||
args.output_dir)
|
||||
else:
|
||||
args.import_directories[idx] = RelativePath(tokens[0], args.depth,
|
||||
args.output_dir)
|
||||
generator_modules = LoadGenerators(args.generators_string)
|
||||
|
||||
fileutil.EnsureDirectoryExists(args.output_dir)
|
||||
|
||||
processor = MojomProcessor(lambda filename: filename in args.filename)
|
||||
processor.LoadTypemaps(set(args.typemaps))
|
||||
|
||||
if args.filelist:
|
||||
with open(args.filelist) as f:
|
||||
args.filename.extend(f.read().split())
|
||||
|
||||
for filename in args.filename:
|
||||
processor._GenerateModule(
|
||||
args, remaining_args, generator_modules,
|
||||
RelativePath(filename, args.depth, args.output_dir), [])
|
||||
|
||||
return 0
|
||||
|
||||
|
||||
def _Precompile(args, _):
|
||||
generator_modules = LoadGenerators(",".join(_BUILTIN_GENERATORS.keys()))
|
||||
|
||||
template_expander.PrecompileTemplates(generator_modules, args.output_dir)
|
||||
return 0
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Generate bindings from mojom files.")
|
||||
parser.add_argument("--use_bundled_pylibs", action="store_true",
|
||||
help="use Python modules bundled in the SDK")
|
||||
parser.add_argument(
|
||||
"-o",
|
||||
"--output_dir",
|
||||
dest="output_dir",
|
||||
default=".",
|
||||
help="output directory for generated files")
|
||||
|
||||
subparsers = parser.add_subparsers()
|
||||
|
||||
generate_parser = subparsers.add_parser(
|
||||
"generate", description="Generate bindings from mojom files.")
|
||||
generate_parser.add_argument("filename", nargs="*",
|
||||
help="mojom input file")
|
||||
generate_parser.add_argument("--filelist", help="mojom input file list")
|
||||
generate_parser.add_argument("-d", "--depth", dest="depth", default=".",
|
||||
help="depth from source root")
|
||||
generate_parser.add_argument("-g",
|
||||
"--generators",
|
||||
dest="generators_string",
|
||||
metavar="GENERATORS",
|
||||
default="c++,javascript,java,mojolpm",
|
||||
help="comma-separated list of generators")
|
||||
generate_parser.add_argument(
|
||||
"--gen_dir", dest="gen_directories", action="append", metavar="directory",
|
||||
default=[], help="add a directory to be searched for the syntax trees.")
|
||||
generate_parser.add_argument(
|
||||
"-I", dest="import_directories", action="append", metavar="directory",
|
||||
default=[],
|
||||
help="add a directory to be searched for import files. The depth from "
|
||||
"source root can be specified for each import by appending it after "
|
||||
"a colon")
|
||||
generate_parser.add_argument("--typemap", action="append", metavar="TYPEMAP",
|
||||
default=[], dest="typemaps",
|
||||
help="apply TYPEMAP to generated output")
|
||||
generate_parser.add_argument("--variant", dest="variant", default=None,
|
||||
help="output a named variant of the bindings")
|
||||
generate_parser.add_argument(
|
||||
"--bytecode_path", required=True, help=(
|
||||
"the path from which to load template bytecode; to generate template "
|
||||
"bytecode, run %s precompile BYTECODE_PATH" % os.path.basename(
|
||||
sys.argv[0])))
|
||||
generate_parser.add_argument("--for_blink", action="store_true",
|
||||
help="Use WTF types as generated types for mojo "
|
||||
"string/array/map.")
|
||||
generate_parser.add_argument(
|
||||
"--js_bindings_mode", choices=["new", "old"], default="old",
|
||||
help="This option only affects the JavaScript bindings. The value could "
|
||||
"be \"new\" to generate new-style lite JS bindings in addition to the "
|
||||
"old, or \"old\" to only generate old bindings.")
|
||||
generate_parser.add_argument(
|
||||
"--js_generate_struct_deserializers", action="store_true",
|
||||
help="Generate javascript deserialize methods for structs in "
|
||||
"mojom-lite.js file")
|
||||
generate_parser.add_argument(
|
||||
"--export_attribute", default="",
|
||||
help="Optional attribute to specify on class declaration to export it "
|
||||
"for the component build.")
|
||||
generate_parser.add_argument(
|
||||
"--export_header", default="",
|
||||
help="Optional header to include in the generated headers to support the "
|
||||
"component build.")
|
||||
generate_parser.add_argument(
|
||||
"--generate_non_variant_code", action="store_true",
|
||||
help="Generate code that is shared by different variants.")
|
||||
generate_parser.add_argument(
|
||||
"--scrambled_message_id_salt_path",
|
||||
dest="scrambled_message_id_salt_paths",
|
||||
help="If non-empty, the path to a file whose contents should be used as"
|
||||
"a salt for generating scrambled message IDs. If this switch is specified"
|
||||
"more than once, the contents of all salt files are concatenated to form"
|
||||
"the salt value.", default=[], action="append")
|
||||
generate_parser.add_argument(
|
||||
"--support_lazy_serialization",
|
||||
help="If set, generated bindings will serialize lazily when possible.",
|
||||
action="store_true")
|
||||
generate_parser.add_argument(
|
||||
"--extra_cpp_template_paths",
|
||||
dest="extra_cpp_template_paths",
|
||||
action="append",
|
||||
metavar="path_to_template",
|
||||
default=[],
|
||||
help="Provide a path to a new template (.tmpl) that is used to generate "
|
||||
"additional C++ source/header files ")
|
||||
generate_parser.add_argument(
|
||||
"--generate_extra_cpp_only",
|
||||
help="If set and extra_cpp_template_paths provided, will only generate"
|
||||
"extra_cpp_template related C++ bindings",
|
||||
action="store_true")
|
||||
generate_parser.add_argument(
|
||||
"--disallow_native_types",
|
||||
help="Disallows the [Native] attribute to be specified on structs or "
|
||||
"enums within the mojom file.", action="store_true")
|
||||
generate_parser.add_argument(
|
||||
"--disallow_interfaces",
|
||||
help="Disallows interface definitions within the mojom file. It is an "
|
||||
"error to specify this flag when processing a mojom file which defines "
|
||||
"any interface.", action="store_true")
|
||||
generate_parser.add_argument(
|
||||
"--generate_message_ids",
|
||||
help="Generates only the message IDs header for C++ bindings. Note that "
|
||||
"this flag only matters if --generate_non_variant_code is also "
|
||||
"specified.", action="store_true")
|
||||
generate_parser.add_argument(
|
||||
"--generate_fuzzing",
|
||||
action="store_true",
|
||||
help="Generates additional bindings for fuzzing in JS.")
|
||||
generate_parser.add_argument(
|
||||
"--enable_kythe_annotations",
|
||||
action="store_true",
|
||||
help="Adds annotations for kythe metadata generation.")
|
||||
|
||||
generate_parser.set_defaults(func=_Generate)
|
||||
|
||||
precompile_parser = subparsers.add_parser("precompile",
|
||||
description="Precompile templates for the mojom bindings generator.")
|
||||
precompile_parser.set_defaults(func=_Precompile)
|
||||
|
||||
args, remaining_args = parser.parse_known_args()
|
||||
return args.func(args, remaining_args)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
with crbug_1001171.DumpStateOnLookupError():
|
||||
sys.exit(main())
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
# 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.
|
||||
|
||||
import unittest
|
||||
|
||||
from mojom_bindings_generator import MakeImportStackMessage
|
||||
from mojom_bindings_generator import ScrambleMethodOrdinals
|
||||
|
||||
|
||||
class FakeIface(object):
|
||||
def __init__(self):
|
||||
self.mojom_name = None
|
||||
self.methods = None
|
||||
|
||||
|
||||
class FakeMethod(object):
|
||||
def __init__(self, explicit_ordinal=None):
|
||||
self.explicit_ordinal = explicit_ordinal
|
||||
self.ordinal = explicit_ordinal
|
||||
self.ordinal_comment = None
|
||||
|
||||
|
||||
class MojoBindingsGeneratorTest(unittest.TestCase):
|
||||
"""Tests mojo_bindings_generator."""
|
||||
|
||||
def testMakeImportStackMessage(self):
|
||||
"""Tests MakeImportStackMessage()."""
|
||||
self.assertEqual(MakeImportStackMessage(["x"]), "")
|
||||
self.assertEqual(MakeImportStackMessage(["x", "y"]),
|
||||
"\n y was imported by x")
|
||||
self.assertEqual(MakeImportStackMessage(["x", "y", "z"]),
|
||||
"\n z was imported by y\n y was imported by x")
|
||||
|
||||
def testScrambleMethodOrdinals(self):
|
||||
"""Tests ScrambleMethodOrdinals()."""
|
||||
interface = FakeIface()
|
||||
interface.mojom_name = 'RendererConfiguration'
|
||||
interface.methods = [
|
||||
FakeMethod(),
|
||||
FakeMethod(),
|
||||
FakeMethod(),
|
||||
FakeMethod(explicit_ordinal=42)
|
||||
]
|
||||
ScrambleMethodOrdinals([interface], "foo".encode('utf-8'))
|
||||
# These next three values are hard-coded. If the generation algorithm
|
||||
# changes from being based on sha256(seed + interface.name + str(i)) then
|
||||
# these numbers will obviously need to change too.
|
||||
#
|
||||
# Note that hashlib.sha256('fooRendererConfiguration1').digest()[:4] is
|
||||
# '\xa5\xbc\xf9\xca' and that hex(1257880741) = '0x4af9bca5'. The
|
||||
# difference in 0x4a vs 0xca is because we only take 31 bits.
|
||||
self.assertEqual(interface.methods[0].ordinal, 1257880741)
|
||||
self.assertEqual(interface.methods[1].ordinal, 631133653)
|
||||
self.assertEqual(interface.methods[2].ordinal, 549336076)
|
||||
|
||||
# Explicit method ordinals should not be scrambled.
|
||||
self.assertEqual(interface.methods[3].ordinal, 42)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
119
utils/ipc/mojo/public/tools/bindings/mojom_types_downgrader.py
Executable file
119
utils/ipc/mojo/public/tools/bindings/mojom_types_downgrader.py
Executable file
|
|
@ -0,0 +1,119 @@
|
|||
#!/usr/bin/env python
|
||||
# Copyright 2020 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.
|
||||
"""Downgrades *.mojom files to the old mojo types for remotes and receivers."""
|
||||
|
||||
import argparse
|
||||
import fnmatch
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import sys
|
||||
import tempfile
|
||||
|
||||
# List of patterns and replacements to match and use against the contents of a
|
||||
# mojo file. Each replacement string will be used with Python string's format()
|
||||
# function, so the '{}' substring is used to mark where the mojo type should go.
|
||||
_MOJO_REPLACEMENTS = {
|
||||
r'pending_remote': r'{}',
|
||||
r'pending_receiver': r'{}&',
|
||||
r'pending_associated_remote': r'associated {}',
|
||||
r'pending_associated_receiver': r'associated {}&',
|
||||
}
|
||||
|
||||
# Pre-compiled regular expression that matches against any of the replacements.
|
||||
_REGEXP_PATTERN = re.compile(
|
||||
r'|'.join(
|
||||
['{}\s*<\s*(.*?)\s*>'.format(k) for k in _MOJO_REPLACEMENTS.keys()]),
|
||||
flags=re.DOTALL)
|
||||
|
||||
|
||||
def ReplaceFunction(match_object):
|
||||
"""Returns the right replacement for the string matched against the regexp."""
|
||||
for index, (match, repl) in enumerate(_MOJO_REPLACEMENTS.items(), 1):
|
||||
if match_object.group(0).startswith(match):
|
||||
return repl.format(match_object.group(index))
|
||||
|
||||
|
||||
def DowngradeFile(path, output_dir=None):
|
||||
"""Downgrades the mojom file specified by |path| to the old mojo types.
|
||||
|
||||
Optionally pass |output_dir| to place the result under a separate output
|
||||
directory, preserving the relative path to the file included in |path|.
|
||||
"""
|
||||
# Use a temporary file to dump the new contents after replacing the patterns.
|
||||
with open(path) as src_mojo_file:
|
||||
with tempfile.NamedTemporaryFile(mode='w', delete=False) as tmp_mojo_file:
|
||||
tmp_contents = _REGEXP_PATTERN.sub(ReplaceFunction, src_mojo_file.read())
|
||||
tmp_mojo_file.write(tmp_contents)
|
||||
|
||||
# Files should be placed in the desired output directory
|
||||
if output_dir:
|
||||
output_filepath = os.path.join(output_dir, os.path.basename(path))
|
||||
if not os.path.exists(output_dir):
|
||||
os.makedirs(output_dir)
|
||||
else:
|
||||
output_filepath = path
|
||||
|
||||
# Write the new contents preserving the original file's attributes.
|
||||
shutil.copystat(path, tmp_mojo_file.name)
|
||||
shutil.move(tmp_mojo_file.name, output_filepath)
|
||||
|
||||
# Make sure to "touch" the new file so that access, modify and change times
|
||||
# are always newer than the source file's, otherwise Modify time will be kept
|
||||
# as per the call to shutil.copystat(), causing unnecessary generations of the
|
||||
# output file in subsequent builds due to ninja considering it dirty.
|
||||
os.utime(output_filepath, None)
|
||||
|
||||
|
||||
def DowngradeDirectory(path, output_dir=None):
|
||||
"""Downgrades mojom files inside directory |path| to the old mojo types.
|
||||
|
||||
Optionally pass |output_dir| to place the result under a separate output
|
||||
directory, preserving the relative path to the file included in |path|.
|
||||
"""
|
||||
# We don't have recursive glob.glob() nor pathlib.Path.rglob() in Python 2.7
|
||||
mojom_filepaths = []
|
||||
for dir_path, _, filenames in os.walk(path):
|
||||
for filename in fnmatch.filter(filenames, "*mojom"):
|
||||
mojom_filepaths.append(os.path.join(dir_path, filename))
|
||||
|
||||
for path in mojom_filepaths:
|
||||
absolute_dirpath = os.path.dirname(os.path.abspath(path))
|
||||
if output_dir:
|
||||
dest_dirpath = output_dir + absolute_dirpath
|
||||
else:
|
||||
dest_dirpath = absolute_dirpath
|
||||
DowngradeFile(path, dest_dirpath)
|
||||
|
||||
|
||||
def DowngradePath(src_path, output_dir=None):
|
||||
"""Downgrades the mojom files pointed by |src_path| to the old mojo types.
|
||||
|
||||
Optionally pass |output_dir| to place the result under a separate output
|
||||
directory, preserving the relative path to the file included in |path|.
|
||||
"""
|
||||
if os.path.isdir(src_path):
|
||||
DowngradeDirectory(src_path, output_dir)
|
||||
elif os.path.isfile(src_path):
|
||||
DowngradeFile(src_path, output_dir)
|
||||
else:
|
||||
print(">>> {} not pointing to a valid file or directory".format(src_path))
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Downgrade *.mojom files to use the old mojo types.")
|
||||
parser.add_argument(
|
||||
"srcpath", help="path to the file or directory to apply the conversion")
|
||||
parser.add_argument(
|
||||
"--outdir", help="the directory to place the converted file(s) under")
|
||||
args = parser.parse_args()
|
||||
|
||||
DowngradePath(args.srcpath, args.outdir)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
57
utils/ipc/mojo/public/tools/bindings/validate_typemap_config.py
Executable file
57
utils/ipc/mojo/public/tools/bindings/validate_typemap_config.py
Executable file
|
|
@ -0,0 +1,57 @@
|
|||
#!/usr/bin/env python
|
||||
# Copyright 2020 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 argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
|
||||
def CheckCppTypemapConfigs(target_name, config_filename, out_filename):
|
||||
_SUPPORTED_CONFIG_KEYS = set([
|
||||
'types', 'traits_headers', 'traits_private_headers', 'traits_sources',
|
||||
'traits_deps', 'traits_public_deps'
|
||||
])
|
||||
_SUPPORTED_TYPE_KEYS = set([
|
||||
'mojom', 'cpp', 'copyable_pass_by_value', 'force_serialize', 'hashable',
|
||||
'move_only', 'nullable_is_same_type'
|
||||
])
|
||||
with open(config_filename, 'r') as f:
|
||||
for config in json.load(f):
|
||||
for key in config.keys():
|
||||
if key not in _SUPPORTED_CONFIG_KEYS:
|
||||
raise ValueError('Invalid typemap property "%s" when processing %s' %
|
||||
(key, target_name))
|
||||
|
||||
types = config.get('types')
|
||||
if not types:
|
||||
raise ValueError('Typemap for %s must specify at least one type to map'
|
||||
% target_name)
|
||||
|
||||
for entry in types:
|
||||
for key in entry.keys():
|
||||
if key not in _SUPPORTED_TYPE_KEYS:
|
||||
raise IOError(
|
||||
'Invalid type property "%s" in typemap for "%s" on target %s' %
|
||||
(key, entry.get('mojom', '(unknown)'), target_name))
|
||||
|
||||
with open(out_filename, 'w') as f:
|
||||
f.truncate(0)
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
_, args = parser.parse_known_args()
|
||||
if len(args) != 3:
|
||||
print('Usage: validate_typemap_config.py target_name config_filename '
|
||||
'stamp_filename')
|
||||
sys.exit(1)
|
||||
|
||||
CheckCppTypemapConfigs(args[0], args[1], args[2])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
14
utils/ipc/mojo/public/tools/mojom/README.md
Normal file
14
utils/ipc/mojo/public/tools/mojom/README.md
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
# The Mojom Parser
|
||||
|
||||
The Mojom format is an interface definition language (IDL) for describing
|
||||
interprocess communication (IPC) messages and data types for use with the
|
||||
low-level cross-platform
|
||||
[Mojo IPC library](https://chromium.googlesource.com/chromium/src/+/master/mojo/public/c/system/README.md).
|
||||
|
||||
This directory consists of a `mojom` Python module, its tests, and supporting
|
||||
command-line tools. The Python module implements the parser used by the
|
||||
command-line tools and exposes an API to help external bindings generators emit
|
||||
useful code from the parser's outputs.
|
||||
|
||||
TODO(https://crbug.com/1060464): Fill out this documentation once the library
|
||||
and tools have stabilized.
|
||||
170
utils/ipc/mojo/public/tools/mojom/check_stable_mojom_compatibility.py
Executable file
170
utils/ipc/mojo/public/tools/mojom/check_stable_mojom_compatibility.py
Executable file
|
|
@ -0,0 +1,170 @@
|
|||
#!/usr/bin/env python
|
||||
# Copyright 2020 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.
|
||||
"""Verifies backward-compatibility of mojom type changes.
|
||||
|
||||
Given a set of pre- and post-diff mojom file contents, and a root directory
|
||||
for a project, this tool verifies that any changes to [Stable] mojom types are
|
||||
backward-compatible with the previous version.
|
||||
|
||||
This can be used e.g. by a presubmit check to prevent developers from making
|
||||
breaking changes to stable mojoms."""
|
||||
|
||||
import argparse
|
||||
import errno
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import os.path
|
||||
import shutil
|
||||
import six
|
||||
import sys
|
||||
import tempfile
|
||||
|
||||
from mojom.generate import module
|
||||
from mojom.generate import translate
|
||||
from mojom.parse import parser
|
||||
|
||||
|
||||
class ParseError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def _ValidateDelta(root, delta):
|
||||
"""Parses all modified mojoms (including all transitive mojom dependencies,
|
||||
even if unmodified) to perform backward-compatibility checks on any types
|
||||
marked with the [Stable] attribute.
|
||||
|
||||
Note that unlike the normal build-time parser in mojom_parser.py, this does
|
||||
not produce or rely on cached module translations, but instead parses the full
|
||||
transitive closure of a mojom's input dependencies all at once.
|
||||
"""
|
||||
|
||||
# First build a map of all files covered by the delta
|
||||
affected_files = set()
|
||||
old_files = {}
|
||||
new_files = {}
|
||||
for change in delta:
|
||||
# TODO(crbug.com/953884): Use pathlib once we're migrated fully to Python 3.
|
||||
filename = change['filename'].replace('\\', '/')
|
||||
affected_files.add(filename)
|
||||
if change['old']:
|
||||
old_files[filename] = change['old']
|
||||
if change['new']:
|
||||
new_files[filename] = change['new']
|
||||
|
||||
# Parse and translate all mojoms relevant to the delta, including transitive
|
||||
# imports that weren't modified.
|
||||
unmodified_modules = {}
|
||||
|
||||
def parseMojom(mojom, file_overrides, override_modules):
|
||||
if mojom in unmodified_modules or mojom in override_modules:
|
||||
return
|
||||
|
||||
contents = file_overrides.get(mojom)
|
||||
if contents:
|
||||
modules = override_modules
|
||||
else:
|
||||
modules = unmodified_modules
|
||||
with io.open(os.path.join(root, mojom), encoding='utf-8') as f:
|
||||
contents = f.read()
|
||||
|
||||
try:
|
||||
ast = parser.Parse(contents, mojom)
|
||||
except Exception as e:
|
||||
six.reraise(
|
||||
ParseError,
|
||||
'encountered exception {0} while parsing {1}'.format(e, mojom),
|
||||
sys.exc_info()[2])
|
||||
for imp in ast.import_list:
|
||||
parseMojom(imp.import_filename, file_overrides, override_modules)
|
||||
|
||||
# Now that the transitive set of dependencies has been imported and parsed
|
||||
# above, translate each mojom AST into a Module so that all types are fully
|
||||
# defined and can be inspected.
|
||||
all_modules = {}
|
||||
all_modules.update(unmodified_modules)
|
||||
all_modules.update(override_modules)
|
||||
modules[mojom] = translate.OrderedModule(ast, mojom, all_modules)
|
||||
|
||||
old_modules = {}
|
||||
for mojom in old_files.keys():
|
||||
parseMojom(mojom, old_files, old_modules)
|
||||
new_modules = {}
|
||||
for mojom in new_files.keys():
|
||||
parseMojom(mojom, new_files, new_modules)
|
||||
|
||||
# At this point we have a complete set of translated Modules from both the
|
||||
# pre- and post-diff mojom contents. Now we can analyze backward-compatibility
|
||||
# of the deltas.
|
||||
#
|
||||
# Note that for backward-compatibility checks we only care about types which
|
||||
# were marked [Stable] before the diff. Types newly marked as [Stable] are not
|
||||
# checked.
|
||||
def collectTypes(modules):
|
||||
types = {}
|
||||
for m in modules.values():
|
||||
for kinds in (m.enums, m.structs, m.unions, m.interfaces):
|
||||
for kind in kinds:
|
||||
types[kind.qualified_name] = kind
|
||||
return types
|
||||
|
||||
old_types = collectTypes(old_modules)
|
||||
new_types = collectTypes(new_modules)
|
||||
|
||||
# Collect any renamed types so they can be compared accordingly.
|
||||
renamed_types = {}
|
||||
for name, kind in new_types.items():
|
||||
old_name = kind.attributes and kind.attributes.get('RenamedFrom')
|
||||
if old_name:
|
||||
renamed_types[old_name] = name
|
||||
|
||||
for qualified_name, kind in old_types.items():
|
||||
if not kind.stable:
|
||||
continue
|
||||
|
||||
new_name = renamed_types.get(qualified_name, qualified_name)
|
||||
if new_name not in new_types:
|
||||
raise Exception(
|
||||
'Stable type %s appears to be deleted by this change. If it was '
|
||||
'renamed, please add a [RenamedFrom] attribute to the new type. This '
|
||||
'can be deleted by a subsequent change.' % qualified_name)
|
||||
|
||||
if not new_types[new_name].IsBackwardCompatible(kind):
|
||||
raise Exception('Stable type %s appears to have changed in a way which '
|
||||
'breaks backward-compatibility. Please fix!\n\nIf you '
|
||||
'believe this assessment to be incorrect, please file a '
|
||||
'Chromium bug against the "Internals>Mojo>Bindings" '
|
||||
'component.' % qualified_name)
|
||||
|
||||
|
||||
def Run(command_line, delta=None):
|
||||
"""Runs the tool with the given command_line. Normally this will read the
|
||||
change description from stdin as a JSON-encoded list, but tests may pass a
|
||||
delta directly for convenience."""
|
||||
arg_parser = argparse.ArgumentParser(
|
||||
description='Verifies backward-compatibility of mojom type changes.',
|
||||
epilog="""
|
||||
This tool reads a change description from stdin and verifies that all modified
|
||||
[Stable] mojom types will retain backward-compatibility. The change description
|
||||
must be a JSON-encoded list of objects, each with a "filename" key (path to a
|
||||
changed mojom file, relative to ROOT); an "old" key whose value is a string of
|
||||
the full file contents before the change, or null if the file is being added;
|
||||
and a "new" key whose value is a string of the full file contents after the
|
||||
change, or null if the file is being deleted.""")
|
||||
arg_parser.add_argument(
|
||||
'--src-root',
|
||||
required=True,
|
||||
action='store',
|
||||
metavar='ROOT',
|
||||
help='The root of the source tree in which the checked mojoms live.')
|
||||
|
||||
args, _ = arg_parser.parse_known_args(command_line)
|
||||
if not delta:
|
||||
delta = json.load(sys.stdin)
|
||||
_ValidateDelta(args.src_root, delta)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
Run(sys.argv[1:])
|
||||
260
utils/ipc/mojo/public/tools/mojom/check_stable_mojom_compatibility_unittest.py
Executable file
260
utils/ipc/mojo/public/tools/mojom/check_stable_mojom_compatibility_unittest.py
Executable file
|
|
@ -0,0 +1,260 @@
|
|||
#!/usr/bin/env python
|
||||
# Copyright 2020 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 json
|
||||
import os
|
||||
import os.path
|
||||
import shutil
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
import check_stable_mojom_compatibility
|
||||
|
||||
from mojom.generate import module
|
||||
|
||||
|
||||
class Change(object):
|
||||
"""Helper to clearly define a mojom file delta to be analyzed."""
|
||||
|
||||
def __init__(self, filename, old=None, new=None):
|
||||
"""If old is None, this is a file addition. If new is None, this is a file
|
||||
deletion. Otherwise it's a file change."""
|
||||
self.filename = filename
|
||||
self.old = old
|
||||
self.new = new
|
||||
|
||||
|
||||
class UnchangedFile(Change):
|
||||
def __init__(self, filename, contents):
|
||||
super(UnchangedFile, self).__init__(filename, old=contents, new=contents)
|
||||
|
||||
|
||||
class CheckStableMojomCompatibilityTest(unittest.TestCase):
|
||||
"""Tests covering the behavior of the compatibility checking tool. Note that
|
||||
details of different compatibility checks and relevant failure modes are NOT
|
||||
covered by these tests. Those are instead covered by unittests in
|
||||
version_compatibility_unittest.py. Additionally, the tests which ensure a
|
||||
given set of [Stable] mojom definitions are indeed plausibly stable (i.e. they
|
||||
have no unstable dependencies) are covered by stable_attribute_unittest.py.
|
||||
|
||||
These tests cover higher-level concerns of the compatibility checking tool,
|
||||
like file or symbol, renames, changes spread over multiple files, etc."""
|
||||
|
||||
def verifyBackwardCompatibility(self, changes):
|
||||
"""Helper for implementing assertBackwardCompatible and
|
||||
assertNotBackwardCompatible"""
|
||||
|
||||
temp_dir = tempfile.mkdtemp()
|
||||
for change in changes:
|
||||
if change.old:
|
||||
# Populate the old file on disk in our temporary fake source root
|
||||
file_path = os.path.join(temp_dir, change.filename)
|
||||
dir_path = os.path.dirname(file_path)
|
||||
if not os.path.exists(dir_path):
|
||||
os.makedirs(dir_path)
|
||||
with open(file_path, 'w') as f:
|
||||
f.write(change.old)
|
||||
|
||||
delta = []
|
||||
for change in changes:
|
||||
if change.old != change.new:
|
||||
delta.append({
|
||||
'filename': change.filename,
|
||||
'old': change.old,
|
||||
'new': change.new
|
||||
})
|
||||
|
||||
try:
|
||||
check_stable_mojom_compatibility.Run(['--src-root', temp_dir],
|
||||
delta=delta)
|
||||
finally:
|
||||
shutil.rmtree(temp_dir)
|
||||
|
||||
def assertBackwardCompatible(self, changes):
|
||||
self.verifyBackwardCompatibility(changes)
|
||||
|
||||
def assertNotBackwardCompatible(self, changes):
|
||||
try:
|
||||
self.verifyBackwardCompatibility(changes)
|
||||
except Exception:
|
||||
return
|
||||
|
||||
raise Exception('Change unexpectedly passed a backward-compatibility check')
|
||||
|
||||
def testBasicCompatibility(self):
|
||||
"""Minimal smoke test to verify acceptance of a simple valid change."""
|
||||
self.assertBackwardCompatible([
|
||||
Change('foo/foo.mojom',
|
||||
old='[Stable] struct S {};',
|
||||
new='[Stable] struct S { [MinVersion=1] int32 x; };')
|
||||
])
|
||||
|
||||
def testBasicIncompatibility(self):
|
||||
"""Minimal smoke test to verify rejection of a simple invalid change."""
|
||||
self.assertNotBackwardCompatible([
|
||||
Change('foo/foo.mojom',
|
||||
old='[Stable] struct S {};',
|
||||
new='[Stable] struct S { int32 x; };')
|
||||
])
|
||||
|
||||
def testIgnoreIfNotStable(self):
|
||||
"""We don't care about types not marked [Stable]"""
|
||||
self.assertBackwardCompatible([
|
||||
Change('foo/foo.mojom',
|
||||
old='struct S {};',
|
||||
new='struct S { int32 x; };')
|
||||
])
|
||||
|
||||
def testRename(self):
|
||||
"""We can do checks for renamed types."""
|
||||
self.assertBackwardCompatible([
|
||||
Change('foo/foo.mojom',
|
||||
old='[Stable] struct S {};',
|
||||
new='[Stable, RenamedFrom="S"] struct T {};')
|
||||
])
|
||||
self.assertNotBackwardCompatible([
|
||||
Change('foo/foo.mojom',
|
||||
old='[Stable] struct S {};',
|
||||
new='[Stable, RenamedFrom="S"] struct T { int32 x; };')
|
||||
])
|
||||
self.assertBackwardCompatible([
|
||||
Change('foo/foo.mojom',
|
||||
old='[Stable] struct S {};',
|
||||
new="""\
|
||||
[Stable, RenamedFrom="S"]
|
||||
struct T { [MinVersion=1] int32 x; };
|
||||
""")
|
||||
])
|
||||
|
||||
def testNewlyStable(self):
|
||||
"""We don't care about types newly marked as [Stable]."""
|
||||
self.assertBackwardCompatible([
|
||||
Change('foo/foo.mojom',
|
||||
old='struct S {};',
|
||||
new='[Stable] struct S { int32 x; };')
|
||||
])
|
||||
|
||||
def testFileRename(self):
|
||||
"""Make sure we can still do compatibility checks after a file rename."""
|
||||
self.assertBackwardCompatible([
|
||||
Change('foo/foo.mojom', old='[Stable] struct S {};', new=None),
|
||||
Change('bar/bar.mojom',
|
||||
old=None,
|
||||
new='[Stable] struct S { [MinVersion=1] int32 x; };')
|
||||
])
|
||||
self.assertNotBackwardCompatible([
|
||||
Change('foo/foo.mojom', old='[Stable] struct S {};', new=None),
|
||||
Change('bar/bar.mojom', old=None, new='[Stable] struct S { int32 x; };')
|
||||
])
|
||||
|
||||
def testWithImport(self):
|
||||
"""Ensure that cross-module dependencies do not break the compatibility
|
||||
checking tool."""
|
||||
self.assertBackwardCompatible([
|
||||
Change('foo/foo.mojom',
|
||||
old="""\
|
||||
module foo;
|
||||
[Stable] struct S {};
|
||||
""",
|
||||
new="""\
|
||||
module foo;
|
||||
[Stable] struct S { [MinVersion=2] int32 x; };
|
||||
"""),
|
||||
Change('bar/bar.mojom',
|
||||
old="""\
|
||||
module bar;
|
||||
import "foo/foo.mojom";
|
||||
[Stable] struct T { foo.S s; };
|
||||
""",
|
||||
new="""\
|
||||
module bar;
|
||||
import "foo/foo.mojom";
|
||||
[Stable] struct T { foo.S s; [MinVersion=1] int32 y; };
|
||||
""")
|
||||
])
|
||||
|
||||
def testWithMovedDefinition(self):
|
||||
"""If a definition moves from one file to another, we should still be able
|
||||
to check compatibility accurately."""
|
||||
self.assertBackwardCompatible([
|
||||
Change('foo/foo.mojom',
|
||||
old="""\
|
||||
module foo;
|
||||
[Stable] struct S {};
|
||||
""",
|
||||
new="""\
|
||||
module foo;
|
||||
"""),
|
||||
Change('bar/bar.mojom',
|
||||
old="""\
|
||||
module bar;
|
||||
import "foo/foo.mojom";
|
||||
[Stable] struct T { foo.S s; };
|
||||
""",
|
||||
new="""\
|
||||
module bar;
|
||||
import "foo/foo.mojom";
|
||||
[Stable, RenamedFrom="foo.S"] struct S {
|
||||
[MinVersion=2] int32 x;
|
||||
};
|
||||
[Stable] struct T { S s; [MinVersion=1] int32 y; };
|
||||
""")
|
||||
])
|
||||
|
||||
self.assertNotBackwardCompatible([
|
||||
Change('foo/foo.mojom',
|
||||
old="""\
|
||||
module foo;
|
||||
[Stable] struct S {};
|
||||
""",
|
||||
new="""\
|
||||
module foo;
|
||||
"""),
|
||||
Change('bar/bar.mojom',
|
||||
old="""\
|
||||
module bar;
|
||||
import "foo/foo.mojom";
|
||||
[Stable] struct T { foo.S s; };
|
||||
""",
|
||||
new="""\
|
||||
module bar;
|
||||
import "foo/foo.mojom";
|
||||
[Stable, RenamedFrom="foo.S"] struct S { int32 x; };
|
||||
[Stable] struct T { S s; [MinVersion=1] int32 y; };
|
||||
""")
|
||||
])
|
||||
|
||||
def testWithUnmodifiedImport(self):
|
||||
"""Unchanged files in the filesystem are still parsed by the compatibility
|
||||
checking tool if they're imported by a changed file."""
|
||||
self.assertBackwardCompatible([
|
||||
UnchangedFile('foo/foo.mojom', 'module foo; [Stable] struct S {};'),
|
||||
Change('bar/bar.mojom',
|
||||
old="""\
|
||||
module bar;
|
||||
import "foo/foo.mojom";
|
||||
[Stable] struct T { foo.S s; };
|
||||
""",
|
||||
new="""\
|
||||
module bar;
|
||||
import "foo/foo.mojom";
|
||||
[Stable] struct T { foo.S s; [MinVersion=1] int32 x; };
|
||||
""")
|
||||
])
|
||||
|
||||
self.assertNotBackwardCompatible([
|
||||
UnchangedFile('foo/foo.mojom', 'module foo; [Stable] struct S {};'),
|
||||
Change('bar/bar.mojom',
|
||||
old="""\
|
||||
module bar;
|
||||
import "foo/foo.mojom";
|
||||
[Stable] struct T { foo.S s; };
|
||||
""",
|
||||
new="""\
|
||||
module bar;
|
||||
import "foo/foo.mojom";
|
||||
[Stable] struct T { foo.S s; int32 x; };
|
||||
""")
|
||||
])
|
||||
90
utils/ipc/mojo/public/tools/mojom/const_unittest.py
Normal file
90
utils/ipc/mojo/public/tools/mojom/const_unittest.py
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
# Copyright 2020 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.
|
||||
|
||||
from mojom_parser_test_case import MojomParserTestCase
|
||||
from mojom.generate import module as mojom
|
||||
|
||||
|
||||
class ConstTest(MojomParserTestCase):
|
||||
"""Tests constant parsing behavior."""
|
||||
|
||||
def testLiteralInt(self):
|
||||
a_mojom = 'a.mojom'
|
||||
self.WriteFile(a_mojom, 'const int32 k = 42;')
|
||||
self.ParseMojoms([a_mojom])
|
||||
a = self.LoadModule(a_mojom)
|
||||
self.assertEqual(1, len(a.constants))
|
||||
self.assertEqual('k', a.constants[0].mojom_name)
|
||||
self.assertEqual('42', a.constants[0].value)
|
||||
|
||||
def testLiteralFloat(self):
|
||||
a_mojom = 'a.mojom'
|
||||
self.WriteFile(a_mojom, 'const float k = 42.5;')
|
||||
self.ParseMojoms([a_mojom])
|
||||
a = self.LoadModule(a_mojom)
|
||||
self.assertEqual(1, len(a.constants))
|
||||
self.assertEqual('k', a.constants[0].mojom_name)
|
||||
self.assertEqual('42.5', a.constants[0].value)
|
||||
|
||||
def testLiteralString(self):
|
||||
a_mojom = 'a.mojom'
|
||||
self.WriteFile(a_mojom, 'const string k = "woot";')
|
||||
self.ParseMojoms([a_mojom])
|
||||
a = self.LoadModule(a_mojom)
|
||||
self.assertEqual(1, len(a.constants))
|
||||
self.assertEqual('k', a.constants[0].mojom_name)
|
||||
self.assertEqual('"woot"', a.constants[0].value)
|
||||
|
||||
def testEnumConstant(self):
|
||||
a_mojom = 'a.mojom'
|
||||
self.WriteFile(a_mojom, 'module a; enum E { kA = 41, kB };')
|
||||
b_mojom = 'b.mojom'
|
||||
self.WriteFile(
|
||||
b_mojom, """\
|
||||
import "a.mojom";
|
||||
const a.E kE1 = a.E.kB;
|
||||
|
||||
// We also allow value names to be unqualified, implying scope from the
|
||||
// constant's type.
|
||||
const a.E kE2 = kB;
|
||||
""")
|
||||
self.ParseMojoms([a_mojom, b_mojom])
|
||||
a = self.LoadModule(a_mojom)
|
||||
b = self.LoadModule(b_mojom)
|
||||
self.assertEqual(1, len(a.enums))
|
||||
self.assertEqual('E', a.enums[0].mojom_name)
|
||||
self.assertEqual(2, len(b.constants))
|
||||
self.assertEqual('kE1', b.constants[0].mojom_name)
|
||||
self.assertEqual(a.enums[0], b.constants[0].kind)
|
||||
self.assertEqual(a.enums[0].fields[1], b.constants[0].value.field)
|
||||
self.assertEqual(42, b.constants[0].value.field.numeric_value)
|
||||
self.assertEqual('kE2', b.constants[1].mojom_name)
|
||||
self.assertEqual(a.enums[0].fields[1], b.constants[1].value.field)
|
||||
self.assertEqual(42, b.constants[1].value.field.numeric_value)
|
||||
|
||||
def testConstantReference(self):
|
||||
a_mojom = 'a.mojom'
|
||||
self.WriteFile(a_mojom, 'const int32 kA = 42; const int32 kB = kA;')
|
||||
self.ParseMojoms([a_mojom])
|
||||
a = self.LoadModule(a_mojom)
|
||||
self.assertEqual(2, len(a.constants))
|
||||
self.assertEqual('kA', a.constants[0].mojom_name)
|
||||
self.assertEqual('42', a.constants[0].value)
|
||||
self.assertEqual('kB', a.constants[1].mojom_name)
|
||||
self.assertEqual('42', a.constants[1].value)
|
||||
|
||||
def testImportedConstantReference(self):
|
||||
a_mojom = 'a.mojom'
|
||||
self.WriteFile(a_mojom, 'const int32 kA = 42;')
|
||||
b_mojom = 'b.mojom'
|
||||
self.WriteFile(b_mojom, 'import "a.mojom"; const int32 kB = kA;')
|
||||
self.ParseMojoms([a_mojom, b_mojom])
|
||||
a = self.LoadModule(a_mojom)
|
||||
b = self.LoadModule(b_mojom)
|
||||
self.assertEqual(1, len(a.constants))
|
||||
self.assertEqual(1, len(b.constants))
|
||||
self.assertEqual('kA', a.constants[0].mojom_name)
|
||||
self.assertEqual('42', a.constants[0].value)
|
||||
self.assertEqual('kB', b.constants[0].mojom_name)
|
||||
self.assertEqual('42', b.constants[0].value)
|
||||
92
utils/ipc/mojo/public/tools/mojom/enum_unittest.py
Normal file
92
utils/ipc/mojo/public/tools/mojom/enum_unittest.py
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
# Copyright 2020 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.
|
||||
|
||||
from mojom_parser_test_case import MojomParserTestCase
|
||||
|
||||
|
||||
class EnumTest(MojomParserTestCase):
|
||||
"""Tests enum parsing behavior."""
|
||||
|
||||
def testExplicitValues(self):
|
||||
"""Verifies basic parsing of assigned integral values."""
|
||||
types = self.ExtractTypes('enum E { kFoo=0, kBar=2, kBaz };')
|
||||
self.assertEqual('kFoo', types['E'].fields[0].mojom_name)
|
||||
self.assertEqual(0, types['E'].fields[0].numeric_value)
|
||||
self.assertEqual('kBar', types['E'].fields[1].mojom_name)
|
||||
self.assertEqual(2, types['E'].fields[1].numeric_value)
|
||||
self.assertEqual('kBaz', types['E'].fields[2].mojom_name)
|
||||
self.assertEqual(3, types['E'].fields[2].numeric_value)
|
||||
|
||||
def testImplicitValues(self):
|
||||
"""Verifies basic automatic assignment of integral values at parse time."""
|
||||
types = self.ExtractTypes('enum E { kFoo, kBar, kBaz };')
|
||||
self.assertEqual('kFoo', types['E'].fields[0].mojom_name)
|
||||
self.assertEqual(0, types['E'].fields[0].numeric_value)
|
||||
self.assertEqual('kBar', types['E'].fields[1].mojom_name)
|
||||
self.assertEqual(1, types['E'].fields[1].numeric_value)
|
||||
self.assertEqual('kBaz', types['E'].fields[2].mojom_name)
|
||||
self.assertEqual(2, types['E'].fields[2].numeric_value)
|
||||
|
||||
def testSameEnumReference(self):
|
||||
"""Verifies that an enum value can be assigned from the value of another
|
||||
field within the same enum."""
|
||||
types = self.ExtractTypes('enum E { kA, kB, kFirst=kA };')
|
||||
self.assertEqual('kA', types['E'].fields[0].mojom_name)
|
||||
self.assertEqual(0, types['E'].fields[0].numeric_value)
|
||||
self.assertEqual('kB', types['E'].fields[1].mojom_name)
|
||||
self.assertEqual(1, types['E'].fields[1].numeric_value)
|
||||
self.assertEqual('kFirst', types['E'].fields[2].mojom_name)
|
||||
self.assertEqual(0, types['E'].fields[2].numeric_value)
|
||||
|
||||
def testSameModuleOtherEnumReference(self):
|
||||
"""Verifies that an enum value can be assigned from the value of a field
|
||||
in another enum within the same module."""
|
||||
types = self.ExtractTypes('enum E { kA, kB }; enum F { kA = E.kB };')
|
||||
self.assertEqual(1, types['F'].fields[0].numeric_value)
|
||||
|
||||
def testImportedEnumReference(self):
|
||||
"""Verifies that an enum value can be assigned from the value of a field
|
||||
in another enum within a different module."""
|
||||
a_mojom = 'a.mojom'
|
||||
self.WriteFile(a_mojom, 'module a; enum E { kFoo=42, kBar };')
|
||||
b_mojom = 'b.mojom'
|
||||
self.WriteFile(b_mojom,
|
||||
'module b; import "a.mojom"; enum F { kFoo = a.E.kBar };')
|
||||
self.ParseMojoms([a_mojom, b_mojom])
|
||||
b = self.LoadModule(b_mojom)
|
||||
|
||||
self.assertEqual('F', b.enums[0].mojom_name)
|
||||
self.assertEqual('kFoo', b.enums[0].fields[0].mojom_name)
|
||||
self.assertEqual(43, b.enums[0].fields[0].numeric_value)
|
||||
|
||||
def testConstantReference(self):
|
||||
"""Verifies that an enum value can be assigned from the value of an
|
||||
integral constant within the same module."""
|
||||
types = self.ExtractTypes('const int32 kFoo = 42; enum E { kA = kFoo };')
|
||||
self.assertEqual(42, types['E'].fields[0].numeric_value)
|
||||
|
||||
def testInvalidConstantReference(self):
|
||||
"""Verifies that enum values cannot be assigned from the value of
|
||||
non-integral constants."""
|
||||
with self.assertRaisesRegexp(ValueError, 'not an integer'):
|
||||
self.ExtractTypes('const float kFoo = 1.0; enum E { kA = kFoo };')
|
||||
with self.assertRaisesRegexp(ValueError, 'not an integer'):
|
||||
self.ExtractTypes('const double kFoo = 1.0; enum E { kA = kFoo };')
|
||||
with self.assertRaisesRegexp(ValueError, 'not an integer'):
|
||||
self.ExtractTypes('const string kFoo = "lol"; enum E { kA = kFoo };')
|
||||
|
||||
def testImportedConstantReference(self):
|
||||
"""Verifies that an enum value can be assigned from the value of an integral
|
||||
constant within an imported module."""
|
||||
a_mojom = 'a.mojom'
|
||||
self.WriteFile(a_mojom, 'module a; const int32 kFoo = 37;')
|
||||
b_mojom = 'b.mojom'
|
||||
self.WriteFile(b_mojom,
|
||||
'module b; import "a.mojom"; enum F { kFoo = a.kFoo };')
|
||||
self.ParseMojoms([a_mojom, b_mojom])
|
||||
b = self.LoadModule(b_mojom)
|
||||
|
||||
self.assertEqual('F', b.enums[0].mojom_name)
|
||||
self.assertEqual('kFoo', b.enums[0].fields[0].mojom_name)
|
||||
self.assertEqual(37, b.enums[0].fields[0].numeric_value)
|
||||
43
utils/ipc/mojo/public/tools/mojom/mojom/BUILD.gn
Normal file
43
utils/ipc/mojo/public/tools/mojom/mojom/BUILD.gn
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
# Copyright 2020 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.
|
||||
|
||||
group("mojom") {
|
||||
data = [
|
||||
"__init__.py",
|
||||
"error.py",
|
||||
"fileutil.py",
|
||||
"generate/__init__.py",
|
||||
"generate/constant_resolver.py",
|
||||
"generate/generator.py",
|
||||
"generate/module.py",
|
||||
"generate/pack.py",
|
||||
"generate/template_expander.py",
|
||||
"generate/translate.py",
|
||||
"parse/__init__.py",
|
||||
"parse/ast.py",
|
||||
"parse/conditional_features.py",
|
||||
"parse/lexer.py",
|
||||
"parse/parser.py",
|
||||
|
||||
# Third-party module dependencies
|
||||
"//third_party/jinja2/",
|
||||
"//third_party/ply/",
|
||||
]
|
||||
}
|
||||
|
||||
group("tests") {
|
||||
data = [
|
||||
"fileutil_unittest.py",
|
||||
"generate/generator_unittest.py",
|
||||
"generate/module_unittest.py",
|
||||
"generate/pack_unittest.py",
|
||||
"generate/translate_unittest.py",
|
||||
"parse/ast_unittest.py",
|
||||
"parse/conditional_features_unittest.py",
|
||||
"parse/lexer_unittest.py",
|
||||
"parse/parser_unittest.py",
|
||||
]
|
||||
|
||||
public_deps = [ ":mojom" ]
|
||||
}
|
||||
0
utils/ipc/mojo/public/tools/mojom/mojom/__init__.py
Normal file
0
utils/ipc/mojo/public/tools/mojom/mojom/__init__.py
Normal file
28
utils/ipc/mojo/public/tools/mojom/mojom/error.py
Normal file
28
utils/ipc/mojo/public/tools/mojom/mojom/error.py
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
# 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.
|
||||
|
||||
|
||||
class Error(Exception):
|
||||
"""Base class for Mojo IDL bindings parser/generator errors."""
|
||||
|
||||
def __init__(self, filename, message, lineno=None, addenda=None, **kwargs):
|
||||
"""|filename| is the (primary) file which caused the error, |message| is the
|
||||
error message, |lineno| is the 1-based line number (or |None| if not
|
||||
applicable/available), and |addenda| is a list of additional lines to append
|
||||
to the final error message."""
|
||||
Exception.__init__(self, **kwargs)
|
||||
self.filename = filename
|
||||
self.message = message
|
||||
self.lineno = lineno
|
||||
self.addenda = addenda
|
||||
|
||||
def __str__(self):
|
||||
if self.lineno:
|
||||
s = "%s:%d: Error: %s" % (self.filename, self.lineno, self.message)
|
||||
else:
|
||||
s = "%s: Error: %s" % (self.filename, self.message)
|
||||
return "\n".join([s] + self.addenda) if self.addenda else s
|
||||
|
||||
def __repr__(self):
|
||||
return str(self)
|
||||
45
utils/ipc/mojo/public/tools/mojom/mojom/fileutil.py
Normal file
45
utils/ipc/mojo/public/tools/mojom/mojom/fileutil.py
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
# Copyright 2015 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 imp
|
||||
import os.path
|
||||
import sys
|
||||
|
||||
|
||||
def _GetDirAbove(dirname):
|
||||
"""Returns the directory "above" this file containing |dirname| (which must
|
||||
also be "above" this file)."""
|
||||
path = os.path.abspath(__file__)
|
||||
while True:
|
||||
path, tail = os.path.split(path)
|
||||
if not tail:
|
||||
return None
|
||||
if tail == dirname:
|
||||
return path
|
||||
|
||||
|
||||
def EnsureDirectoryExists(path, always_try_to_create=False):
|
||||
"""A wrapper for os.makedirs that does not error if the directory already
|
||||
exists. A different process could be racing to create this directory."""
|
||||
|
||||
if not os.path.exists(path) or always_try_to_create:
|
||||
try:
|
||||
os.makedirs(path)
|
||||
except OSError as e:
|
||||
# There may have been a race to create this directory.
|
||||
if e.errno != errno.EEXIST:
|
||||
raise
|
||||
|
||||
|
||||
def AddLocalRepoThirdPartyDirToModulePath():
|
||||
"""Helper function to find the top-level directory of this script's repository
|
||||
assuming the script falls somewhere within a 'mojo' directory, and insert the
|
||||
top-level 'third_party' directory early in the module search path. Used to
|
||||
ensure that third-party dependencies provided within the repository itself
|
||||
(e.g. Chromium sources include snapshots of jinja2 and ply) are preferred over
|
||||
locally installed system library packages."""
|
||||
toplevel_dir = _GetDirAbove('mojo')
|
||||
if toplevel_dir:
|
||||
sys.path.insert(1, os.path.join(toplevel_dir, 'third_party'))
|
||||
40
utils/ipc/mojo/public/tools/mojom/mojom/fileutil_unittest.py
Normal file
40
utils/ipc/mojo/public/tools/mojom/mojom/fileutil_unittest.py
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
# Copyright 2015 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 imp
|
||||
import os.path
|
||||
import shutil
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from mojom import fileutil
|
||||
|
||||
|
||||
class FileUtilTest(unittest.TestCase):
|
||||
def testEnsureDirectoryExists(self):
|
||||
"""Test that EnsureDirectoryExists fuctions correctly."""
|
||||
|
||||
temp_dir = tempfile.mkdtemp()
|
||||
try:
|
||||
self.assertTrue(os.path.exists(temp_dir))
|
||||
|
||||
# Directory does not exist, yet.
|
||||
full = os.path.join(temp_dir, "foo", "bar")
|
||||
self.assertFalse(os.path.exists(full))
|
||||
|
||||
# Create the directory.
|
||||
fileutil.EnsureDirectoryExists(full)
|
||||
self.assertTrue(os.path.exists(full))
|
||||
|
||||
# Trying to create it again does not cause an error.
|
||||
fileutil.EnsureDirectoryExists(full)
|
||||
self.assertTrue(os.path.exists(full))
|
||||
|
||||
# Bypass check for directory existence to tickle error handling that
|
||||
# occurs in response to a race.
|
||||
fileutil.EnsureDirectoryExists(full, always_try_to_create=True)
|
||||
self.assertTrue(os.path.exists(full))
|
||||
finally:
|
||||
shutil.rmtree(temp_dir)
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
# Copyright 2015 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.
|
||||
"""Resolves the values used for constants and enums."""
|
||||
|
||||
from itertools import ifilter
|
||||
|
||||
from mojom.generate import module as mojom
|
||||
|
||||
|
||||
def ResolveConstants(module, expression_to_text):
|
||||
in_progress = set()
|
||||
computed = set()
|
||||
|
||||
def GetResolvedValue(named_value):
|
||||
assert isinstance(named_value, (mojom.EnumValue, mojom.ConstantValue))
|
||||
if isinstance(named_value, mojom.EnumValue):
|
||||
field = next(
|
||||
ifilter(lambda field: field.name == named_value.name,
|
||||
named_value.enum.fields), None)
|
||||
if not field:
|
||||
raise RuntimeError(
|
||||
'Unable to get computed value for field %s of enum %s' %
|
||||
(named_value.name, named_value.enum.name))
|
||||
if field not in computed:
|
||||
ResolveEnum(named_value.enum)
|
||||
return field.resolved_value
|
||||
else:
|
||||
ResolveConstant(named_value.constant)
|
||||
named_value.resolved_value = named_value.constant.resolved_value
|
||||
return named_value.resolved_value
|
||||
|
||||
def ResolveConstant(constant):
|
||||
if constant in computed:
|
||||
return
|
||||
if constant in in_progress:
|
||||
raise RuntimeError('Circular dependency for constant: %s' % constant.name)
|
||||
in_progress.add(constant)
|
||||
if isinstance(constant.value, (mojom.EnumValue, mojom.ConstantValue)):
|
||||
resolved_value = GetResolvedValue(constant.value)
|
||||
else:
|
||||
resolved_value = expression_to_text(constant.value)
|
||||
constant.resolved_value = resolved_value
|
||||
in_progress.remove(constant)
|
||||
computed.add(constant)
|
||||
|
||||
def ResolveEnum(enum):
|
||||
def ResolveEnumField(enum, field, default_value):
|
||||
if field in computed:
|
||||
return
|
||||
if field in in_progress:
|
||||
raise RuntimeError('Circular dependency for enum: %s' % enum.name)
|
||||
in_progress.add(field)
|
||||
if field.value:
|
||||
if isinstance(field.value, mojom.EnumValue):
|
||||
resolved_value = GetResolvedValue(field.value)
|
||||
elif isinstance(field.value, str):
|
||||
resolved_value = int(field.value, 0)
|
||||
else:
|
||||
raise RuntimeError('Unexpected value: %s' % field.value)
|
||||
else:
|
||||
resolved_value = default_value
|
||||
field.resolved_value = resolved_value
|
||||
in_progress.remove(field)
|
||||
computed.add(field)
|
||||
|
||||
current_value = 0
|
||||
for field in enum.fields:
|
||||
ResolveEnumField(enum, field, current_value)
|
||||
current_value = field.resolved_value + 1
|
||||
|
||||
for constant in module.constants:
|
||||
ResolveConstant(constant)
|
||||
|
||||
for enum in module.enums:
|
||||
ResolveEnum(enum)
|
||||
|
||||
for struct in module.structs:
|
||||
for constant in struct.constants:
|
||||
ResolveConstant(constant)
|
||||
for enum in struct.enums:
|
||||
ResolveEnum(enum)
|
||||
for field in struct.fields:
|
||||
if isinstance(field.default, (mojom.ConstantValue, mojom.EnumValue)):
|
||||
field.default.resolved_value = GetResolvedValue(field.default)
|
||||
|
||||
for interface in module.interfaces:
|
||||
for constant in interface.constants:
|
||||
ResolveConstant(constant)
|
||||
for enum in interface.enums:
|
||||
ResolveEnum(enum)
|
||||
|
||||
return module
|
||||
325
utils/ipc/mojo/public/tools/mojom/mojom/generate/generator.py
Normal file
325
utils/ipc/mojo/public/tools/mojom/mojom/generate/generator.py
Normal file
|
|
@ -0,0 +1,325 @@
|
|||
# Copyright 2013 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.
|
||||
"""Code shared by the various language-specific code generators."""
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
from functools import partial
|
||||
import os.path
|
||||
import re
|
||||
|
||||
from mojom import fileutil
|
||||
from mojom.generate import module as mojom
|
||||
from mojom.generate import pack
|
||||
|
||||
|
||||
def ExpectedArraySize(kind):
|
||||
if mojom.IsArrayKind(kind):
|
||||
return kind.length
|
||||
return None
|
||||
|
||||
|
||||
def SplitCamelCase(identifier):
|
||||
"""Splits a camel-cased |identifier| and returns a list of lower-cased
|
||||
strings.
|
||||
"""
|
||||
# Add underscores after uppercase letters when appropriate. An uppercase
|
||||
# letter is considered the end of a word if it is followed by an upper and a
|
||||
# lower. E.g. URLLoaderFactory -> URL_LoaderFactory
|
||||
identifier = re.sub('([A-Z][0-9]*)(?=[A-Z][0-9]*[a-z])', r'\1_', identifier)
|
||||
# Add underscores after lowercase letters when appropriate. A lowercase letter
|
||||
# is considered the end of a word if it is followed by an upper.
|
||||
# E.g. URLLoaderFactory -> URLLoader_Factory
|
||||
identifier = re.sub('([a-z][0-9]*)(?=[A-Z])', r'\1_', identifier)
|
||||
return [x.lower() for x in identifier.split('_')]
|
||||
|
||||
|
||||
def ToCamel(identifier, lower_initial=False, digits_split=False, delimiter='_'):
|
||||
"""Splits |identifier| using |delimiter|, makes the first character of each
|
||||
word uppercased (but makes the first character of the first word lowercased
|
||||
if |lower_initial| is set to True), and joins the words. Please note that for
|
||||
each word, all the characters except the first one are untouched.
|
||||
"""
|
||||
result = ''
|
||||
capitalize_next = True
|
||||
for i in range(len(identifier)):
|
||||
if identifier[i] == delimiter:
|
||||
capitalize_next = True
|
||||
elif digits_split and identifier[i].isdigit():
|
||||
capitalize_next = True
|
||||
result += identifier[i]
|
||||
elif capitalize_next:
|
||||
capitalize_next = False
|
||||
result += identifier[i].upper()
|
||||
else:
|
||||
result += identifier[i]
|
||||
|
||||
if lower_initial and result:
|
||||
result = result[0].lower() + result[1:]
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def _ToSnakeCase(identifier, upper=False):
|
||||
"""Splits camel-cased |identifier| into lower case words, removes the first
|
||||
word if it's "k" and joins them using "_" e.g. for "URLLoaderFactory", returns
|
||||
"URL_LOADER_FACTORY" if upper, otherwise "url_loader_factory".
|
||||
"""
|
||||
words = SplitCamelCase(identifier)
|
||||
if words[0] == 'k' and len(words) > 1:
|
||||
words = words[1:]
|
||||
|
||||
# Variables cannot start with a digit
|
||||
if (words[0][0].isdigit()):
|
||||
words[0] = '_' + words[0]
|
||||
|
||||
|
||||
if upper:
|
||||
words = map(lambda x: x.upper(), words)
|
||||
|
||||
return '_'.join(words)
|
||||
|
||||
|
||||
def ToUpperSnakeCase(identifier):
|
||||
"""Splits camel-cased |identifier| into lower case words, removes the first
|
||||
word if it's "k" and joins them using "_" e.g. for "URLLoaderFactory", returns
|
||||
"URL_LOADER_FACTORY".
|
||||
"""
|
||||
return _ToSnakeCase(identifier, upper=True)
|
||||
|
||||
|
||||
def ToLowerSnakeCase(identifier):
|
||||
"""Splits camel-cased |identifier| into lower case words, removes the first
|
||||
word if it's "k" and joins them using "_" e.g. for "URLLoaderFactory", returns
|
||||
"url_loader_factory".
|
||||
"""
|
||||
return _ToSnakeCase(identifier, upper=False)
|
||||
|
||||
|
||||
class Stylizer(object):
|
||||
"""Stylizers specify naming rules to map mojom names to names in generated
|
||||
code. For example, if you would like method_name in mojom to be mapped to
|
||||
MethodName in the generated code, you need to define a subclass of Stylizer
|
||||
and override StylizeMethod to do the conversion."""
|
||||
|
||||
def StylizeConstant(self, mojom_name):
|
||||
return mojom_name
|
||||
|
||||
def StylizeField(self, mojom_name):
|
||||
return mojom_name
|
||||
|
||||
def StylizeStruct(self, mojom_name):
|
||||
return mojom_name
|
||||
|
||||
def StylizeUnion(self, mojom_name):
|
||||
return mojom_name
|
||||
|
||||
def StylizeParameter(self, mojom_name):
|
||||
return mojom_name
|
||||
|
||||
def StylizeMethod(self, mojom_name):
|
||||
return mojom_name
|
||||
|
||||
def StylizeInterface(self, mojom_name):
|
||||
return mojom_name
|
||||
|
||||
def StylizeEnumField(self, mojom_name):
|
||||
return mojom_name
|
||||
|
||||
def StylizeEnum(self, mojom_name):
|
||||
return mojom_name
|
||||
|
||||
def StylizeModule(self, mojom_namespace):
|
||||
return mojom_namespace
|
||||
|
||||
|
||||
def WriteFile(contents, full_path):
|
||||
# If |contents| is same with the file content, we skip updating.
|
||||
if os.path.isfile(full_path):
|
||||
with open(full_path, 'rb') as destination_file:
|
||||
if destination_file.read() == contents:
|
||||
return
|
||||
|
||||
# Make sure the containing directory exists.
|
||||
full_dir = os.path.dirname(full_path)
|
||||
fileutil.EnsureDirectoryExists(full_dir)
|
||||
|
||||
# Dump the data to disk.
|
||||
with open(full_path, "wb") as f:
|
||||
if not isinstance(contents, bytes):
|
||||
f.write(contents.encode('utf-8'))
|
||||
else:
|
||||
f.write(contents)
|
||||
|
||||
|
||||
def AddComputedData(module):
|
||||
"""Adds computed data to the given module. The data is computed once and
|
||||
used repeatedly in the generation process."""
|
||||
|
||||
def _AddStructComputedData(exported, struct):
|
||||
struct.packed = pack.PackedStruct(struct)
|
||||
struct.bytes = pack.GetByteLayout(struct.packed)
|
||||
struct.versions = pack.GetVersionInfo(struct.packed)
|
||||
struct.exported = exported
|
||||
|
||||
def _AddInterfaceComputedData(interface):
|
||||
interface.version = 0
|
||||
for method in interface.methods:
|
||||
# this field is never scrambled
|
||||
method.sequential_ordinal = method.ordinal
|
||||
|
||||
if method.min_version is not None:
|
||||
interface.version = max(interface.version, method.min_version)
|
||||
|
||||
method.param_struct = _GetStructFromMethod(method)
|
||||
if interface.stable:
|
||||
method.param_struct.attributes[mojom.ATTRIBUTE_STABLE] = True
|
||||
if method.explicit_ordinal is None:
|
||||
raise Exception(
|
||||
'Stable interfaces must declare explicit method ordinals. The '
|
||||
'method %s on stable interface %s does not declare an explicit '
|
||||
'ordinal.' % (method.mojom_name, interface.qualified_name))
|
||||
interface.version = max(interface.version,
|
||||
method.param_struct.versions[-1].version)
|
||||
|
||||
if method.response_parameters is not None:
|
||||
method.response_param_struct = _GetResponseStructFromMethod(method)
|
||||
if interface.stable:
|
||||
method.response_param_struct.attributes[mojom.ATTRIBUTE_STABLE] = True
|
||||
interface.version = max(
|
||||
interface.version,
|
||||
method.response_param_struct.versions[-1].version)
|
||||
else:
|
||||
method.response_param_struct = None
|
||||
|
||||
def _GetStructFromMethod(method):
|
||||
"""Converts a method's parameters into the fields of a struct."""
|
||||
params_class = "%s_%s_Params" % (method.interface.mojom_name,
|
||||
method.mojom_name)
|
||||
struct = mojom.Struct(params_class,
|
||||
module=method.interface.module,
|
||||
attributes={})
|
||||
for param in method.parameters:
|
||||
struct.AddField(
|
||||
param.mojom_name,
|
||||
param.kind,
|
||||
param.ordinal,
|
||||
attributes=param.attributes)
|
||||
_AddStructComputedData(False, struct)
|
||||
return struct
|
||||
|
||||
def _GetResponseStructFromMethod(method):
|
||||
"""Converts a method's response_parameters into the fields of a struct."""
|
||||
params_class = "%s_%s_ResponseParams" % (method.interface.mojom_name,
|
||||
method.mojom_name)
|
||||
struct = mojom.Struct(params_class,
|
||||
module=method.interface.module,
|
||||
attributes={})
|
||||
for param in method.response_parameters:
|
||||
struct.AddField(
|
||||
param.mojom_name,
|
||||
param.kind,
|
||||
param.ordinal,
|
||||
attributes=param.attributes)
|
||||
_AddStructComputedData(False, struct)
|
||||
return struct
|
||||
|
||||
for struct in module.structs:
|
||||
_AddStructComputedData(True, struct)
|
||||
for interface in module.interfaces:
|
||||
_AddInterfaceComputedData(interface)
|
||||
|
||||
|
||||
class Generator(object):
|
||||
# Pass |output_dir| to emit files to disk. Omit |output_dir| to echo all
|
||||
# files to stdout.
|
||||
def __init__(self,
|
||||
module,
|
||||
output_dir=None,
|
||||
typemap=None,
|
||||
variant=None,
|
||||
bytecode_path=None,
|
||||
for_blink=False,
|
||||
js_bindings_mode="new",
|
||||
js_generate_struct_deserializers=False,
|
||||
export_attribute=None,
|
||||
export_header=None,
|
||||
generate_non_variant_code=False,
|
||||
support_lazy_serialization=False,
|
||||
disallow_native_types=False,
|
||||
disallow_interfaces=False,
|
||||
generate_message_ids=False,
|
||||
generate_fuzzing=False,
|
||||
enable_kythe_annotations=False,
|
||||
extra_cpp_template_paths=None,
|
||||
generate_extra_cpp_only=False):
|
||||
self.module = module
|
||||
self.output_dir = output_dir
|
||||
self.typemap = typemap or {}
|
||||
self.variant = variant
|
||||
self.bytecode_path = bytecode_path
|
||||
self.for_blink = for_blink
|
||||
self.js_bindings_mode = js_bindings_mode
|
||||
self.js_generate_struct_deserializers = js_generate_struct_deserializers
|
||||
self.export_attribute = export_attribute
|
||||
self.export_header = export_header
|
||||
self.generate_non_variant_code = generate_non_variant_code
|
||||
self.support_lazy_serialization = support_lazy_serialization
|
||||
self.disallow_native_types = disallow_native_types
|
||||
self.disallow_interfaces = disallow_interfaces
|
||||
self.generate_message_ids = generate_message_ids
|
||||
self.generate_fuzzing = generate_fuzzing
|
||||
self.enable_kythe_annotations = enable_kythe_annotations
|
||||
self.extra_cpp_template_paths = extra_cpp_template_paths
|
||||
self.generate_extra_cpp_only = generate_extra_cpp_only
|
||||
|
||||
def Write(self, contents, filename):
|
||||
if self.output_dir is None:
|
||||
print(contents)
|
||||
return
|
||||
full_path = os.path.join(self.output_dir, filename)
|
||||
WriteFile(contents, full_path)
|
||||
|
||||
def OptimizeEmpty(self, contents):
|
||||
# Look for .cc files that contain no actual code. There are many of these
|
||||
# and they collectively take a while to compile.
|
||||
lines = contents.splitlines()
|
||||
|
||||
for line in lines:
|
||||
if line.startswith('#') or line.startswith('//'):
|
||||
continue
|
||||
if re.match(r'namespace .* {', line) or re.match(r'}.*//.*namespace',
|
||||
line):
|
||||
continue
|
||||
if line.strip():
|
||||
# There is some actual code - return the unmodified contents.
|
||||
return contents
|
||||
|
||||
# If we reach here then we have a .cc file with no actual code. The
|
||||
# includes are therefore unneeded and can be removed.
|
||||
new_lines = [line for line in lines if not line.startswith('#include')]
|
||||
if len(new_lines) < len(lines):
|
||||
new_lines.append('')
|
||||
new_lines.append('// Includes removed due to no code being generated.')
|
||||
return '\n'.join(new_lines)
|
||||
|
||||
def WriteWithComment(self, contents, filename):
|
||||
generator_name = "mojom_bindings_generator.py"
|
||||
comment = r"// %s is auto generated by %s, do not edit" % (filename,
|
||||
generator_name)
|
||||
contents = comment + '\n' + '\n' + contents;
|
||||
if filename.endswith('.cc'):
|
||||
contents = self.OptimizeEmpty(contents)
|
||||
self.Write(contents, filename)
|
||||
|
||||
def GenerateFiles(self, args):
|
||||
raise NotImplementedError("Subclasses must override/implement this method")
|
||||
|
||||
def GetJinjaParameters(self):
|
||||
"""Returns default constructor parameters for the jinja environment."""
|
||||
return {}
|
||||
|
||||
def GetGlobals(self):
|
||||
"""Returns global mappings for the template generation."""
|
||||
return {}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
# 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.
|
||||
|
||||
import imp
|
||||
import os.path
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
|
||||
def _GetDirAbove(dirname):
|
||||
"""Returns the directory "above" this file containing |dirname| (which must
|
||||
also be "above" this file)."""
|
||||
path = os.path.abspath(__file__)
|
||||
while True:
|
||||
path, tail = os.path.split(path)
|
||||
assert tail
|
||||
if tail == dirname:
|
||||
return path
|
||||
|
||||
|
||||
try:
|
||||
imp.find_module("mojom")
|
||||
except ImportError:
|
||||
sys.path.append(os.path.join(_GetDirAbove("pylib"), "pylib"))
|
||||
from mojom.generate import generator
|
||||
|
||||
|
||||
class StringManipulationTest(unittest.TestCase):
|
||||
"""generator contains some string utilities, this tests only those."""
|
||||
|
||||
def testSplitCamelCase(self):
|
||||
self.assertEquals(["camel", "case"], generator.SplitCamelCase("CamelCase"))
|
||||
self.assertEquals(["url", "loader", "factory"],
|
||||
generator.SplitCamelCase('URLLoaderFactory'))
|
||||
self.assertEquals(["get99", "entries"],
|
||||
generator.SplitCamelCase('Get99Entries'))
|
||||
self.assertEquals(["get99entries"],
|
||||
generator.SplitCamelCase('Get99entries'))
|
||||
|
||||
def testToCamel(self):
|
||||
self.assertEquals("CamelCase", generator.ToCamel("camel_case"))
|
||||
self.assertEquals("CAMELCASE", generator.ToCamel("CAMEL_CASE"))
|
||||
self.assertEquals("camelCase",
|
||||
generator.ToCamel("camel_case", lower_initial=True))
|
||||
self.assertEquals("CamelCase", generator.ToCamel(
|
||||
"camel case", delimiter=' '))
|
||||
self.assertEquals("CaMelCaSe", generator.ToCamel("caMel_caSe"))
|
||||
self.assertEquals("L2Tp", generator.ToCamel("l2tp", digits_split=True))
|
||||
self.assertEquals("l2tp", generator.ToCamel("l2tp", lower_initial=True))
|
||||
|
||||
def testToSnakeCase(self):
|
||||
self.assertEquals("snake_case", generator.ToLowerSnakeCase("SnakeCase"))
|
||||
self.assertEquals("snake_case", generator.ToLowerSnakeCase("snakeCase"))
|
||||
self.assertEquals("snake_case", generator.ToLowerSnakeCase("SnakeCASE"))
|
||||
self.assertEquals("snake_d3d11_case",
|
||||
generator.ToLowerSnakeCase("SnakeD3D11Case"))
|
||||
self.assertEquals("snake_d3d11_case",
|
||||
generator.ToLowerSnakeCase("SnakeD3d11Case"))
|
||||
self.assertEquals("snake_d3d11_case",
|
||||
generator.ToLowerSnakeCase("snakeD3d11Case"))
|
||||
self.assertEquals("SNAKE_CASE", generator.ToUpperSnakeCase("SnakeCase"))
|
||||
self.assertEquals("SNAKE_CASE", generator.ToUpperSnakeCase("snakeCase"))
|
||||
self.assertEquals("SNAKE_CASE", generator.ToUpperSnakeCase("SnakeCASE"))
|
||||
self.assertEquals("SNAKE_D3D11_CASE",
|
||||
generator.ToUpperSnakeCase("SnakeD3D11Case"))
|
||||
self.assertEquals("SNAKE_D3D11_CASE",
|
||||
generator.ToUpperSnakeCase("SnakeD3d11Case"))
|
||||
self.assertEquals("SNAKE_D3D11_CASE",
|
||||
generator.ToUpperSnakeCase("snakeD3d11Case"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
1635
utils/ipc/mojo/public/tools/mojom/mojom/generate/module.py
Normal file
1635
utils/ipc/mojo/public/tools/mojom/mojom/generate/module.py
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -0,0 +1,31 @@
|
|||
# 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.
|
||||
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from mojom.generate import module as mojom
|
||||
|
||||
|
||||
class ModuleTest(unittest.TestCase):
|
||||
def testNonInterfaceAsInterfaceRequest(self):
|
||||
"""Tests that a non-interface cannot be used for interface requests."""
|
||||
module = mojom.Module('test_module', 'test_namespace')
|
||||
struct = mojom.Struct('TestStruct', module=module)
|
||||
with self.assertRaises(Exception) as e:
|
||||
mojom.InterfaceRequest(struct)
|
||||
self.assertEquals(
|
||||
e.exception.__str__(),
|
||||
'Interface request requires \'x:TestStruct\' to be an interface.')
|
||||
|
||||
def testNonInterfaceAsAssociatedInterface(self):
|
||||
"""Tests that a non-interface type cannot be used for associated interfaces.
|
||||
"""
|
||||
module = mojom.Module('test_module', 'test_namespace')
|
||||
struct = mojom.Struct('TestStruct', module=module)
|
||||
with self.assertRaises(Exception) as e:
|
||||
mojom.AssociatedInterface(struct)
|
||||
self.assertEquals(
|
||||
e.exception.__str__(),
|
||||
'Associated interface requires \'x:TestStruct\' to be an interface.')
|
||||
258
utils/ipc/mojo/public/tools/mojom/mojom/generate/pack.py
Normal file
258
utils/ipc/mojo/public/tools/mojom/mojom/generate/pack.py
Normal file
|
|
@ -0,0 +1,258 @@
|
|||
# Copyright 2013 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.
|
||||
|
||||
from mojom.generate import module as mojom
|
||||
|
||||
# This module provides a mechanism for determining the packed order and offsets
|
||||
# of a mojom.Struct.
|
||||
#
|
||||
# ps = pack.PackedStruct(struct)
|
||||
# ps.packed_fields will access a list of PackedField objects, each of which
|
||||
# will have an offset, a size and a bit (for mojom.BOOLs).
|
||||
|
||||
# Size of struct header in bytes: num_bytes [4B] + version [4B].
|
||||
HEADER_SIZE = 8
|
||||
|
||||
|
||||
class PackedField(object):
|
||||
kind_to_size = {
|
||||
mojom.BOOL: 1,
|
||||
mojom.INT8: 1,
|
||||
mojom.UINT8: 1,
|
||||
mojom.INT16: 2,
|
||||
mojom.UINT16: 2,
|
||||
mojom.INT32: 4,
|
||||
mojom.UINT32: 4,
|
||||
mojom.FLOAT: 4,
|
||||
mojom.HANDLE: 4,
|
||||
mojom.MSGPIPE: 4,
|
||||
mojom.SHAREDBUFFER: 4,
|
||||
mojom.PLATFORMHANDLE: 4,
|
||||
mojom.DCPIPE: 4,
|
||||
mojom.DPPIPE: 4,
|
||||
mojom.NULLABLE_HANDLE: 4,
|
||||
mojom.NULLABLE_MSGPIPE: 4,
|
||||
mojom.NULLABLE_SHAREDBUFFER: 4,
|
||||
mojom.NULLABLE_PLATFORMHANDLE: 4,
|
||||
mojom.NULLABLE_DCPIPE: 4,
|
||||
mojom.NULLABLE_DPPIPE: 4,
|
||||
mojom.INT64: 8,
|
||||
mojom.UINT64: 8,
|
||||
mojom.DOUBLE: 8,
|
||||
mojom.STRING: 8,
|
||||
mojom.NULLABLE_STRING: 8
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def GetSizeForKind(cls, kind):
|
||||
if isinstance(kind, (mojom.Array, mojom.Map, mojom.Struct, mojom.Interface,
|
||||
mojom.AssociatedInterface, mojom.PendingRemote,
|
||||
mojom.PendingAssociatedRemote)):
|
||||
return 8
|
||||
if isinstance(kind, mojom.Union):
|
||||
return 16
|
||||
if isinstance(kind, (mojom.InterfaceRequest, mojom.PendingReceiver)):
|
||||
kind = mojom.MSGPIPE
|
||||
if isinstance(
|
||||
kind,
|
||||
(mojom.AssociatedInterfaceRequest, mojom.PendingAssociatedReceiver)):
|
||||
return 4
|
||||
if isinstance(kind, mojom.Enum):
|
||||
# TODO(mpcomplete): what about big enums?
|
||||
return cls.kind_to_size[mojom.INT32]
|
||||
if not kind in cls.kind_to_size:
|
||||
raise Exception("Undefined type: %s. Did you forget to import the file "
|
||||
"containing the definition?" % kind.spec)
|
||||
return cls.kind_to_size[kind]
|
||||
|
||||
@classmethod
|
||||
def GetAlignmentForKind(cls, kind):
|
||||
if isinstance(kind, (mojom.Interface, mojom.AssociatedInterface,
|
||||
mojom.PendingRemote, mojom.PendingAssociatedRemote)):
|
||||
return 4
|
||||
if isinstance(kind, mojom.Union):
|
||||
return 8
|
||||
return cls.GetSizeForKind(kind)
|
||||
|
||||
def __init__(self, field, index, ordinal):
|
||||
"""
|
||||
Args:
|
||||
field: the original field.
|
||||
index: the position of the original field in the struct.
|
||||
ordinal: the ordinal of the field for serialization.
|
||||
"""
|
||||
self.field = field
|
||||
self.index = index
|
||||
self.ordinal = ordinal
|
||||
self.size = self.GetSizeForKind(field.kind)
|
||||
self.alignment = self.GetAlignmentForKind(field.kind)
|
||||
self.offset = None
|
||||
self.bit = None
|
||||
self.min_version = None
|
||||
|
||||
|
||||
def GetPad(offset, alignment):
|
||||
"""Returns the pad necessary to reserve space so that |offset + pad| equals to
|
||||
some multiple of |alignment|."""
|
||||
return (alignment - (offset % alignment)) % alignment
|
||||
|
||||
|
||||
def GetFieldOffset(field, last_field):
|
||||
"""Returns a 2-tuple of the field offset and bit (for BOOLs)."""
|
||||
if (field.field.kind == mojom.BOOL and last_field.field.kind == mojom.BOOL
|
||||
and last_field.bit < 7):
|
||||
return (last_field.offset, last_field.bit + 1)
|
||||
|
||||
offset = last_field.offset + last_field.size
|
||||
pad = GetPad(offset, field.alignment)
|
||||
return (offset + pad, 0)
|
||||
|
||||
|
||||
def GetPayloadSizeUpToField(field):
|
||||
"""Returns the payload size (not including struct header) if |field| is the
|
||||
last field.
|
||||
"""
|
||||
if not field:
|
||||
return 0
|
||||
offset = field.offset + field.size
|
||||
pad = GetPad(offset, 8)
|
||||
return offset + pad
|
||||
|
||||
|
||||
class PackedStruct(object):
|
||||
def __init__(self, struct):
|
||||
self.struct = struct
|
||||
# |packed_fields| contains all the fields, in increasing offset order.
|
||||
self.packed_fields = []
|
||||
# |packed_fields_in_ordinal_order| refers to the same fields as
|
||||
# |packed_fields|, but in ordinal order.
|
||||
self.packed_fields_in_ordinal_order = []
|
||||
|
||||
# No fields.
|
||||
if (len(struct.fields) == 0):
|
||||
return
|
||||
|
||||
# Start by sorting by ordinal.
|
||||
src_fields = self.packed_fields_in_ordinal_order
|
||||
ordinal = 0
|
||||
for index, field in enumerate(struct.fields):
|
||||
if field.ordinal is not None:
|
||||
ordinal = field.ordinal
|
||||
src_fields.append(PackedField(field, index, ordinal))
|
||||
ordinal += 1
|
||||
src_fields.sort(key=lambda field: field.ordinal)
|
||||
|
||||
# Set |min_version| for each field.
|
||||
next_min_version = 0
|
||||
for packed_field in src_fields:
|
||||
if packed_field.field.min_version is None:
|
||||
assert next_min_version == 0
|
||||
else:
|
||||
assert packed_field.field.min_version >= next_min_version
|
||||
next_min_version = packed_field.field.min_version
|
||||
packed_field.min_version = next_min_version
|
||||
|
||||
if (packed_field.min_version != 0
|
||||
and mojom.IsReferenceKind(packed_field.field.kind)
|
||||
and not packed_field.field.kind.is_nullable):
|
||||
raise Exception("Non-nullable fields are only allowed in version 0 of "
|
||||
"a struct. %s.%s is defined with [MinVersion=%d]." %
|
||||
(self.struct.name, packed_field.field.name,
|
||||
packed_field.min_version))
|
||||
|
||||
src_field = src_fields[0]
|
||||
src_field.offset = 0
|
||||
src_field.bit = 0
|
||||
dst_fields = self.packed_fields
|
||||
dst_fields.append(src_field)
|
||||
|
||||
# Then find first slot that each field will fit.
|
||||
for src_field in src_fields[1:]:
|
||||
last_field = dst_fields[0]
|
||||
for i in range(1, len(dst_fields)):
|
||||
next_field = dst_fields[i]
|
||||
offset, bit = GetFieldOffset(src_field, last_field)
|
||||
if offset + src_field.size <= next_field.offset:
|
||||
# Found hole.
|
||||
src_field.offset = offset
|
||||
src_field.bit = bit
|
||||
dst_fields.insert(i, src_field)
|
||||
break
|
||||
last_field = next_field
|
||||
if src_field.offset is None:
|
||||
# Add to end
|
||||
src_field.offset, src_field.bit = GetFieldOffset(src_field, last_field)
|
||||
dst_fields.append(src_field)
|
||||
|
||||
|
||||
class ByteInfo(object):
|
||||
def __init__(self):
|
||||
self.is_padding = False
|
||||
self.packed_fields = []
|
||||
|
||||
|
||||
def GetByteLayout(packed_struct):
|
||||
total_payload_size = GetPayloadSizeUpToField(
|
||||
packed_struct.packed_fields[-1] if packed_struct.packed_fields else None)
|
||||
byte_info = [ByteInfo() for i in range(total_payload_size)]
|
||||
|
||||
limit_of_previous_field = 0
|
||||
for packed_field in packed_struct.packed_fields:
|
||||
for i in range(limit_of_previous_field, packed_field.offset):
|
||||
byte_info[i].is_padding = True
|
||||
byte_info[packed_field.offset].packed_fields.append(packed_field)
|
||||
limit_of_previous_field = packed_field.offset + packed_field.size
|
||||
|
||||
for i in range(limit_of_previous_field, len(byte_info)):
|
||||
byte_info[i].is_padding = True
|
||||
|
||||
for byte in byte_info:
|
||||
# A given byte cannot both be padding and have a fields packed into it.
|
||||
assert not (byte.is_padding and byte.packed_fields)
|
||||
|
||||
return byte_info
|
||||
|
||||
|
||||
class VersionInfo(object):
|
||||
def __init__(self, version, num_fields, num_bytes):
|
||||
self.version = version
|
||||
self.num_fields = num_fields
|
||||
self.num_bytes = num_bytes
|
||||
|
||||
|
||||
def GetVersionInfo(packed_struct):
|
||||
"""Get version information for a struct.
|
||||
|
||||
Args:
|
||||
packed_struct: A PackedStruct instance.
|
||||
|
||||
Returns:
|
||||
A non-empty list of VersionInfo instances, sorted by version in increasing
|
||||
order.
|
||||
Note: The version numbers may not be consecutive.
|
||||
"""
|
||||
versions = []
|
||||
last_version = 0
|
||||
last_num_fields = 0
|
||||
last_payload_size = 0
|
||||
|
||||
for packed_field in packed_struct.packed_fields_in_ordinal_order:
|
||||
if packed_field.min_version != last_version:
|
||||
versions.append(
|
||||
VersionInfo(last_version, last_num_fields,
|
||||
last_payload_size + HEADER_SIZE))
|
||||
last_version = packed_field.min_version
|
||||
|
||||
last_num_fields += 1
|
||||
# The fields are iterated in ordinal order here. However, the size of a
|
||||
# version is determined by the last field of that version in pack order,
|
||||
# instead of ordinal order. Therefore, we need to calculate the max value.
|
||||
last_payload_size = max(
|
||||
GetPayloadSizeUpToField(packed_field), last_payload_size)
|
||||
|
||||
assert len(versions) == 0 or last_num_fields != versions[-1].num_fields
|
||||
versions.append(
|
||||
VersionInfo(last_version, last_num_fields,
|
||||
last_payload_size + HEADER_SIZE))
|
||||
return versions
|
||||
|
|
@ -0,0 +1,225 @@
|
|||
# Copyright 2013 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 sys
|
||||
import unittest
|
||||
|
||||
from mojom.generate import module as mojom
|
||||
from mojom.generate import pack
|
||||
|
||||
|
||||
class PackTest(unittest.TestCase):
|
||||
def testOrdinalOrder(self):
|
||||
struct = mojom.Struct('test')
|
||||
struct.AddField('testfield1', mojom.INT32, 2)
|
||||
struct.AddField('testfield2', mojom.INT32, 1)
|
||||
ps = pack.PackedStruct(struct)
|
||||
|
||||
self.assertEqual(2, len(ps.packed_fields))
|
||||
self.assertEqual('testfield2', ps.packed_fields[0].field.mojom_name)
|
||||
self.assertEqual('testfield1', ps.packed_fields[1].field.mojom_name)
|
||||
|
||||
def testZeroFields(self):
|
||||
struct = mojom.Struct('test')
|
||||
ps = pack.PackedStruct(struct)
|
||||
self.assertEqual(0, len(ps.packed_fields))
|
||||
|
||||
def testOneField(self):
|
||||
struct = mojom.Struct('test')
|
||||
struct.AddField('testfield1', mojom.INT8)
|
||||
ps = pack.PackedStruct(struct)
|
||||
self.assertEqual(1, len(ps.packed_fields))
|
||||
|
||||
def _CheckPackSequence(self, kinds, fields, offsets):
|
||||
"""Checks the pack order and offsets of a sequence of mojom.Kinds.
|
||||
|
||||
Args:
|
||||
kinds: A sequence of mojom.Kinds that specify the fields that are to be
|
||||
created.
|
||||
fields: The expected order of the resulting fields, with the integer "1"
|
||||
first.
|
||||
offsets: The expected order of offsets, with the integer "0" first.
|
||||
"""
|
||||
struct = mojom.Struct('test')
|
||||
index = 1
|
||||
for kind in kinds:
|
||||
struct.AddField('%d' % index, kind)
|
||||
index += 1
|
||||
ps = pack.PackedStruct(struct)
|
||||
num_fields = len(ps.packed_fields)
|
||||
self.assertEqual(len(kinds), num_fields)
|
||||
for i in range(num_fields):
|
||||
self.assertEqual('%d' % fields[i], ps.packed_fields[i].field.mojom_name)
|
||||
self.assertEqual(offsets[i], ps.packed_fields[i].offset)
|
||||
|
||||
def testPaddingPackedInOrder(self):
|
||||
return self._CheckPackSequence((mojom.INT8, mojom.UINT8, mojom.INT32),
|
||||
(1, 2, 3), (0, 1, 4))
|
||||
|
||||
def testPaddingPackedOutOfOrder(self):
|
||||
return self._CheckPackSequence((mojom.INT8, mojom.INT32, mojom.UINT8),
|
||||
(1, 3, 2), (0, 1, 4))
|
||||
|
||||
def testPaddingPackedOverflow(self):
|
||||
kinds = (mojom.INT8, mojom.INT32, mojom.INT16, mojom.INT8, mojom.INT8)
|
||||
# 2 bytes should be packed together first, followed by short, then by int.
|
||||
fields = (1, 4, 3, 2, 5)
|
||||
offsets = (0, 1, 2, 4, 8)
|
||||
return self._CheckPackSequence(kinds, fields, offsets)
|
||||
|
||||
def testNullableTypes(self):
|
||||
kinds = (mojom.STRING.MakeNullableKind(), mojom.HANDLE.MakeNullableKind(),
|
||||
mojom.Struct('test_struct').MakeNullableKind(),
|
||||
mojom.DCPIPE.MakeNullableKind(), mojom.Array().MakeNullableKind(),
|
||||
mojom.DPPIPE.MakeNullableKind(),
|
||||
mojom.Array(length=5).MakeNullableKind(),
|
||||
mojom.MSGPIPE.MakeNullableKind(),
|
||||
mojom.Interface('test_interface').MakeNullableKind(),
|
||||
mojom.SHAREDBUFFER.MakeNullableKind(),
|
||||
mojom.InterfaceRequest().MakeNullableKind())
|
||||
fields = (1, 2, 4, 3, 5, 6, 8, 7, 9, 10, 11)
|
||||
offsets = (0, 8, 12, 16, 24, 32, 36, 40, 48, 56, 60)
|
||||
return self._CheckPackSequence(kinds, fields, offsets)
|
||||
|
||||
def testAllTypes(self):
|
||||
return self._CheckPackSequence(
|
||||
(mojom.BOOL, mojom.INT8, mojom.STRING, mojom.UINT8, mojom.INT16,
|
||||
mojom.DOUBLE, mojom.UINT16, mojom.INT32, mojom.UINT32, mojom.INT64,
|
||||
mojom.FLOAT, mojom.STRING, mojom.HANDLE, mojom.UINT64,
|
||||
mojom.Struct('test'), mojom.Array(), mojom.STRING.MakeNullableKind()),
|
||||
(1, 2, 4, 5, 7, 3, 6, 8, 9, 10, 11, 13, 12, 14, 15, 16, 17, 18),
|
||||
(0, 1, 2, 4, 6, 8, 16, 24, 28, 32, 40, 44, 48, 56, 64, 72, 80, 88))
|
||||
|
||||
def testPaddingPackedOutOfOrderByOrdinal(self):
|
||||
struct = mojom.Struct('test')
|
||||
struct.AddField('testfield1', mojom.INT8)
|
||||
struct.AddField('testfield3', mojom.UINT8, 3)
|
||||
struct.AddField('testfield2', mojom.INT32, 2)
|
||||
ps = pack.PackedStruct(struct)
|
||||
self.assertEqual(3, len(ps.packed_fields))
|
||||
|
||||
# Second byte should be packed in behind first, altering order.
|
||||
self.assertEqual('testfield1', ps.packed_fields[0].field.mojom_name)
|
||||
self.assertEqual('testfield3', ps.packed_fields[1].field.mojom_name)
|
||||
self.assertEqual('testfield2', ps.packed_fields[2].field.mojom_name)
|
||||
|
||||
# Second byte should be packed with first.
|
||||
self.assertEqual(0, ps.packed_fields[0].offset)
|
||||
self.assertEqual(1, ps.packed_fields[1].offset)
|
||||
self.assertEqual(4, ps.packed_fields[2].offset)
|
||||
|
||||
def testBools(self):
|
||||
struct = mojom.Struct('test')
|
||||
struct.AddField('bit0', mojom.BOOL)
|
||||
struct.AddField('bit1', mojom.BOOL)
|
||||
struct.AddField('int', mojom.INT32)
|
||||
struct.AddField('bit2', mojom.BOOL)
|
||||
struct.AddField('bit3', mojom.BOOL)
|
||||
struct.AddField('bit4', mojom.BOOL)
|
||||
struct.AddField('bit5', mojom.BOOL)
|
||||
struct.AddField('bit6', mojom.BOOL)
|
||||
struct.AddField('bit7', mojom.BOOL)
|
||||
struct.AddField('bit8', mojom.BOOL)
|
||||
ps = pack.PackedStruct(struct)
|
||||
self.assertEqual(10, len(ps.packed_fields))
|
||||
|
||||
# First 8 bits packed together.
|
||||
for i in range(8):
|
||||
pf = ps.packed_fields[i]
|
||||
self.assertEqual(0, pf.offset)
|
||||
self.assertEqual("bit%d" % i, pf.field.mojom_name)
|
||||
self.assertEqual(i, pf.bit)
|
||||
|
||||
# Ninth bit goes into second byte.
|
||||
self.assertEqual("bit8", ps.packed_fields[8].field.mojom_name)
|
||||
self.assertEqual(1, ps.packed_fields[8].offset)
|
||||
self.assertEqual(0, ps.packed_fields[8].bit)
|
||||
|
||||
# int comes last.
|
||||
self.assertEqual("int", ps.packed_fields[9].field.mojom_name)
|
||||
self.assertEqual(4, ps.packed_fields[9].offset)
|
||||
|
||||
def testMinVersion(self):
|
||||
"""Tests that |min_version| is properly set for packed fields."""
|
||||
struct = mojom.Struct('test')
|
||||
struct.AddField('field_2', mojom.BOOL, 2)
|
||||
struct.AddField('field_0', mojom.INT32, 0)
|
||||
struct.AddField('field_1', mojom.INT64, 1)
|
||||
ps = pack.PackedStruct(struct)
|
||||
|
||||
self.assertEqual('field_0', ps.packed_fields[0].field.mojom_name)
|
||||
self.assertEqual('field_2', ps.packed_fields[1].field.mojom_name)
|
||||
self.assertEqual('field_1', ps.packed_fields[2].field.mojom_name)
|
||||
|
||||
self.assertEqual(0, ps.packed_fields[0].min_version)
|
||||
self.assertEqual(0, ps.packed_fields[1].min_version)
|
||||
self.assertEqual(0, ps.packed_fields[2].min_version)
|
||||
|
||||
struct.fields[0].attributes = {'MinVersion': 1}
|
||||
ps = pack.PackedStruct(struct)
|
||||
|
||||
self.assertEqual(0, ps.packed_fields[0].min_version)
|
||||
self.assertEqual(1, ps.packed_fields[1].min_version)
|
||||
self.assertEqual(0, ps.packed_fields[2].min_version)
|
||||
|
||||
def testGetVersionInfoEmptyStruct(self):
|
||||
"""Tests that pack.GetVersionInfo() never returns an empty list, even for
|
||||
empty structs.
|
||||
"""
|
||||
struct = mojom.Struct('test')
|
||||
ps = pack.PackedStruct(struct)
|
||||
|
||||
versions = pack.GetVersionInfo(ps)
|
||||
self.assertEqual(1, len(versions))
|
||||
self.assertEqual(0, versions[0].version)
|
||||
self.assertEqual(0, versions[0].num_fields)
|
||||
self.assertEqual(8, versions[0].num_bytes)
|
||||
|
||||
def testGetVersionInfoComplexOrder(self):
|
||||
"""Tests pack.GetVersionInfo() using a struct whose definition order,
|
||||
ordinal order and pack order for fields are all different.
|
||||
"""
|
||||
struct = mojom.Struct('test')
|
||||
struct.AddField(
|
||||
'field_3', mojom.BOOL, ordinal=3, attributes={'MinVersion': 3})
|
||||
struct.AddField('field_0', mojom.INT32, ordinal=0)
|
||||
struct.AddField(
|
||||
'field_1', mojom.INT64, ordinal=1, attributes={'MinVersion': 2})
|
||||
struct.AddField(
|
||||
'field_2', mojom.INT64, ordinal=2, attributes={'MinVersion': 3})
|
||||
ps = pack.PackedStruct(struct)
|
||||
|
||||
versions = pack.GetVersionInfo(ps)
|
||||
self.assertEqual(3, len(versions))
|
||||
|
||||
self.assertEqual(0, versions[0].version)
|
||||
self.assertEqual(1, versions[0].num_fields)
|
||||
self.assertEqual(16, versions[0].num_bytes)
|
||||
|
||||
self.assertEqual(2, versions[1].version)
|
||||
self.assertEqual(2, versions[1].num_fields)
|
||||
self.assertEqual(24, versions[1].num_bytes)
|
||||
|
||||
self.assertEqual(3, versions[2].version)
|
||||
self.assertEqual(4, versions[2].num_fields)
|
||||
self.assertEqual(32, versions[2].num_bytes)
|
||||
|
||||
def testInterfaceAlignment(self):
|
||||
"""Tests that interfaces are aligned on 4-byte boundaries, although the size
|
||||
of an interface is 8 bytes.
|
||||
"""
|
||||
kinds = (mojom.INT32, mojom.Interface('test_interface'))
|
||||
fields = (1, 2)
|
||||
offsets = (0, 4)
|
||||
self._CheckPackSequence(kinds, fields, offsets)
|
||||
|
||||
def testAssociatedInterfaceAlignment(self):
|
||||
"""Tests that associated interfaces are aligned on 4-byte boundaries,
|
||||
although the size of an associated interface is 8 bytes.
|
||||
"""
|
||||
kinds = (mojom.INT32,
|
||||
mojom.AssociatedInterface(mojom.Interface('test_interface')))
|
||||
fields = (1, 2)
|
||||
offsets = (0, 4)
|
||||
self._CheckPackSequence(kinds, fields, offsets)
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
# Copyright 2013 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.
|
||||
|
||||
# Based on third_party/WebKit/Source/build/scripts/template_expander.py.
|
||||
|
||||
import os.path
|
||||
import sys
|
||||
|
||||
from mojom import fileutil
|
||||
|
||||
fileutil.AddLocalRepoThirdPartyDirToModulePath()
|
||||
import jinja2
|
||||
|
||||
|
||||
def ApplyTemplate(mojo_generator, path_to_template, params, **kwargs):
|
||||
loader = jinja2.ModuleLoader(
|
||||
os.path.join(mojo_generator.bytecode_path,
|
||||
"%s.zip" % mojo_generator.GetTemplatePrefix()))
|
||||
final_kwargs = dict(mojo_generator.GetJinjaParameters())
|
||||
final_kwargs.update(kwargs)
|
||||
|
||||
jinja_env = jinja2.Environment(
|
||||
loader=loader, keep_trailing_newline=True, **final_kwargs)
|
||||
jinja_env.globals.update(mojo_generator.GetGlobals())
|
||||
jinja_env.filters.update(mojo_generator.GetFilters())
|
||||
template = jinja_env.get_template(path_to_template)
|
||||
return template.render(params)
|
||||
|
||||
|
||||
def UseJinja(path_to_template, **kwargs):
|
||||
def RealDecorator(generator):
|
||||
def GeneratorInternal(*args, **kwargs2):
|
||||
parameters = generator(*args, **kwargs2)
|
||||
return ApplyTemplate(args[0], path_to_template, parameters, **kwargs)
|
||||
|
||||
GeneratorInternal.__name__ = generator.__name__
|
||||
return GeneratorInternal
|
||||
|
||||
return RealDecorator
|
||||
|
||||
|
||||
def ApplyImportedTemplate(mojo_generator, path_to_template, filename, params,
|
||||
**kwargs):
|
||||
loader = jinja2.FileSystemLoader(searchpath=path_to_template)
|
||||
final_kwargs = dict(mojo_generator.GetJinjaParameters())
|
||||
final_kwargs.update(kwargs)
|
||||
|
||||
jinja_env = jinja2.Environment(
|
||||
loader=loader, keep_trailing_newline=True, **final_kwargs)
|
||||
jinja_env.globals.update(mojo_generator.GetGlobals())
|
||||
jinja_env.filters.update(mojo_generator.GetFilters())
|
||||
template = jinja_env.get_template(filename)
|
||||
return template.render(params)
|
||||
|
||||
|
||||
def UseJinjaForImportedTemplate(func):
|
||||
def wrapper(*args, **kwargs):
|
||||
parameters = func(*args, **kwargs)
|
||||
path_to_template = args[1]
|
||||
filename = args[2]
|
||||
return ApplyImportedTemplate(args[0], path_to_template, filename,
|
||||
parameters)
|
||||
|
||||
wrapper.__name__ = func.__name__
|
||||
return wrapper
|
||||
|
||||
|
||||
def PrecompileTemplates(generator_modules, output_dir):
|
||||
for module in generator_modules.values():
|
||||
generator = module.Generator(None)
|
||||
jinja_env = jinja2.Environment(
|
||||
loader=jinja2.FileSystemLoader([
|
||||
os.path.join(
|
||||
os.path.dirname(module.__file__), generator.GetTemplatePrefix())
|
||||
]))
|
||||
jinja_env.filters.update(generator.GetFilters())
|
||||
jinja_env.compile_templates(
|
||||
os.path.join(output_dir, "%s.zip" % generator.GetTemplatePrefix()),
|
||||
extensions=["tmpl"],
|
||||
zip="stored",
|
||||
py_compile=True,
|
||||
ignore_errors=False)
|
||||
854
utils/ipc/mojo/public/tools/mojom/mojom/generate/translate.py
Normal file
854
utils/ipc/mojo/public/tools/mojom/mojom/generate/translate.py
Normal file
|
|
@ -0,0 +1,854 @@
|
|||
# Copyright 2013 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.
|
||||
"""Convert parse tree to AST.
|
||||
|
||||
This module converts the parse tree to the AST we use for code generation. The
|
||||
main entry point is OrderedModule, which gets passed the parser
|
||||
representation of a mojom file. When called it's assumed that all imports have
|
||||
already been parsed and converted to ASTs before.
|
||||
"""
|
||||
|
||||
import itertools
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
from mojom.generate import generator
|
||||
from mojom.generate import module as mojom
|
||||
from mojom.parse import ast
|
||||
|
||||
|
||||
def _IsStrOrUnicode(x):
|
||||
if sys.version_info[0] < 3:
|
||||
return isinstance(x, (unicode, str))
|
||||
return isinstance(x, str)
|
||||
|
||||
|
||||
def _DuplicateName(values):
|
||||
"""Returns the 'mojom_name' of the first entry in |values| whose 'mojom_name'
|
||||
has already been encountered. If there are no duplicates, returns None."""
|
||||
names = set()
|
||||
for value in values:
|
||||
if value.mojom_name in names:
|
||||
return value.mojom_name
|
||||
names.add(value.mojom_name)
|
||||
return None
|
||||
|
||||
|
||||
def _ElemsOfType(elems, elem_type, scope):
|
||||
"""Find all elements of the given type.
|
||||
|
||||
Args:
|
||||
elems: {Sequence[Any]} Sequence of elems.
|
||||
elem_type: {Type[C]} Extract all elems of this type.
|
||||
scope: {str} The name of the surrounding scope (e.g. struct
|
||||
definition). Used in error messages.
|
||||
|
||||
Returns:
|
||||
{List[C]} All elems of matching type.
|
||||
"""
|
||||
assert isinstance(elem_type, type)
|
||||
result = [elem for elem in elems if isinstance(elem, elem_type)]
|
||||
duplicate_name = _DuplicateName(result)
|
||||
if duplicate_name:
|
||||
raise Exception('Names in mojom must be unique within a scope. The name '
|
||||
'"%s" is used more than once within the scope "%s".' %
|
||||
(duplicate_name, scope))
|
||||
return result
|
||||
|
||||
|
||||
def _ProcessElements(scope, elements, operations_by_type):
|
||||
"""Iterates over the given elements, running a function from
|
||||
operations_by_type for any element that matches a key in that dict. The scope
|
||||
is the name of the surrounding scope, such as a filename or struct name, used
|
||||
only in error messages."""
|
||||
names_in_this_scope = set()
|
||||
for element in elements:
|
||||
# pylint: disable=unidiomatic-typecheck
|
||||
element_type = type(element)
|
||||
if element_type in operations_by_type:
|
||||
if element.mojom_name in names_in_this_scope:
|
||||
raise Exception('Names must be unique within a scope. The name "%s" is '
|
||||
'used more than once within the scope "%s".' %
|
||||
(duplicate_name, scope))
|
||||
operations_by_type[element_type](element)
|
||||
|
||||
|
||||
def _MapKind(kind):
|
||||
map_to_kind = {
|
||||
'bool': 'b',
|
||||
'int8': 'i8',
|
||||
'int16': 'i16',
|
||||
'int32': 'i32',
|
||||
'int64': 'i64',
|
||||
'uint8': 'u8',
|
||||
'uint16': 'u16',
|
||||
'uint32': 'u32',
|
||||
'uint64': 'u64',
|
||||
'float': 'f',
|
||||
'double': 'd',
|
||||
'string': 's',
|
||||
'handle': 'h',
|
||||
'handle<data_pipe_consumer>': 'h:d:c',
|
||||
'handle<data_pipe_producer>': 'h:d:p',
|
||||
'handle<message_pipe>': 'h:m',
|
||||
'handle<shared_buffer>': 'h:s',
|
||||
'handle<platform>': 'h:p'
|
||||
}
|
||||
if kind.endswith('?'):
|
||||
base_kind = _MapKind(kind[0:-1])
|
||||
# NOTE: This doesn't rule out enum types. Those will be detected later, when
|
||||
# cross-reference is established.
|
||||
reference_kinds = ('m', 's', 'h', 'a', 'r', 'x', 'asso', 'rmt', 'rcv',
|
||||
'rma', 'rca')
|
||||
if re.split('[^a-z]', base_kind, 1)[0] not in reference_kinds:
|
||||
raise Exception('A type (spec "%s") cannot be made nullable' % base_kind)
|
||||
return '?' + base_kind
|
||||
if kind.endswith('}'):
|
||||
lbracket = kind.rfind('{')
|
||||
value = kind[0:lbracket]
|
||||
return 'm[' + _MapKind(kind[lbracket + 1:-1]) + '][' + _MapKind(value) + ']'
|
||||
if kind.endswith(']'):
|
||||
lbracket = kind.rfind('[')
|
||||
typename = kind[0:lbracket]
|
||||
return 'a' + kind[lbracket + 1:-1] + ':' + _MapKind(typename)
|
||||
if kind.endswith('&'):
|
||||
return 'r:' + _MapKind(kind[0:-1])
|
||||
if kind.startswith('asso<'):
|
||||
assert kind.endswith('>')
|
||||
return 'asso:' + _MapKind(kind[5:-1])
|
||||
if kind.startswith('rmt<'):
|
||||
assert kind.endswith('>')
|
||||
return 'rmt:' + _MapKind(kind[4:-1])
|
||||
if kind.startswith('rcv<'):
|
||||
assert kind.endswith('>')
|
||||
return 'rcv:' + _MapKind(kind[4:-1])
|
||||
if kind.startswith('rma<'):
|
||||
assert kind.endswith('>')
|
||||
return 'rma:' + _MapKind(kind[4:-1])
|
||||
if kind.startswith('rca<'):
|
||||
assert kind.endswith('>')
|
||||
return 'rca:' + _MapKind(kind[4:-1])
|
||||
if kind in map_to_kind:
|
||||
return map_to_kind[kind]
|
||||
return 'x:' + kind
|
||||
|
||||
|
||||
def _AttributeListToDict(attribute_list):
|
||||
if attribute_list is None:
|
||||
return None
|
||||
assert isinstance(attribute_list, ast.AttributeList)
|
||||
# TODO(vtl): Check for duplicate keys here.
|
||||
return dict(
|
||||
[(attribute.key, attribute.value) for attribute in attribute_list])
|
||||
|
||||
|
||||
builtin_values = frozenset([
|
||||
"double.INFINITY", "double.NEGATIVE_INFINITY", "double.NAN",
|
||||
"float.INFINITY", "float.NEGATIVE_INFINITY", "float.NAN"
|
||||
])
|
||||
|
||||
|
||||
def _IsBuiltinValue(value):
|
||||
return value in builtin_values
|
||||
|
||||
|
||||
def _LookupKind(kinds, spec, scope):
|
||||
"""Tries to find which Kind a spec refers to, given the scope in which its
|
||||
referenced. Starts checking from the narrowest scope to most general. For
|
||||
example, given a struct field like
|
||||
Foo.Bar x;
|
||||
Foo.Bar could refer to the type 'Bar' in the 'Foo' namespace, or an inner
|
||||
type 'Bar' in the struct 'Foo' in the current namespace.
|
||||
|
||||
|scope| is a tuple that looks like (namespace, struct/interface), referring
|
||||
to the location where the type is referenced."""
|
||||
if spec.startswith('x:'):
|
||||
mojom_name = spec[2:]
|
||||
for i in range(len(scope), -1, -1):
|
||||
test_spec = 'x:'
|
||||
if i > 0:
|
||||
test_spec += '.'.join(scope[:i]) + '.'
|
||||
test_spec += mojom_name
|
||||
kind = kinds.get(test_spec)
|
||||
if kind:
|
||||
return kind
|
||||
|
||||
return kinds.get(spec)
|
||||
|
||||
|
||||
def _GetScopeForKind(module, kind):
|
||||
"""For a given kind, returns a tuple of progressively more specific names
|
||||
used to qualify the kind. For example if kind is an enum named Bar nested in a
|
||||
struct Foo within module 'foo', this would return ('foo', 'Foo', 'Bar')"""
|
||||
if isinstance(kind, mojom.Enum) and kind.parent_kind:
|
||||
# Enums may be nested in other kinds.
|
||||
return _GetScopeForKind(module, kind.parent_kind) + (kind.mojom_name, )
|
||||
|
||||
module_fragment = (module.mojom_namespace, ) if module.mojom_namespace else ()
|
||||
kind_fragment = (kind.mojom_name, ) if kind else ()
|
||||
return module_fragment + kind_fragment
|
||||
|
||||
|
||||
def _LookupValueInScope(module, kind, identifier):
|
||||
"""Given a kind and an identifier, this attempts to resolve the given
|
||||
identifier to a concrete NamedValue within the scope of the given kind."""
|
||||
scope = _GetScopeForKind(module, kind)
|
||||
for i in reversed(range(len(scope) + 1)):
|
||||
qualified_name = '.'.join(scope[:i] + (identifier, ))
|
||||
value = module.values.get(qualified_name)
|
||||
if value:
|
||||
return value
|
||||
return None
|
||||
|
||||
|
||||
def _LookupValue(module, parent_kind, implied_kind, ast_leaf_node):
|
||||
"""Resolves a leaf node in the form ('IDENTIFIER', 'x') to a constant value
|
||||
identified by 'x' in some mojom definition. parent_kind is used as context
|
||||
when resolving the identifier. If the given leaf node is not an IDENTIFIER
|
||||
(e.g. already a constant value), it is returned as-is.
|
||||
|
||||
If implied_kind is provided, the parsed identifier may also be resolved within
|
||||
its scope as fallback. This can be useful for more concise value references
|
||||
when assigning enum-typed constants or field values."""
|
||||
if not isinstance(ast_leaf_node, tuple) or ast_leaf_node[0] != 'IDENTIFIER':
|
||||
return ast_leaf_node
|
||||
|
||||
# First look for a known user-defined identifier to resolve this within the
|
||||
# enclosing scope.
|
||||
identifier = ast_leaf_node[1]
|
||||
|
||||
value = _LookupValueInScope(module, parent_kind, identifier)
|
||||
if value:
|
||||
return value
|
||||
|
||||
# Next look in the scope of implied_kind, if provided.
|
||||
value = (implied_kind and implied_kind.module and _LookupValueInScope(
|
||||
implied_kind.module, implied_kind, identifier))
|
||||
if value:
|
||||
return value
|
||||
|
||||
# Fall back on defined builtin symbols
|
||||
if _IsBuiltinValue(identifier):
|
||||
return mojom.BuiltinValue(identifier)
|
||||
|
||||
raise ValueError('Unknown identifier %s' % identifier)
|
||||
|
||||
|
||||
def _Kind(kinds, spec, scope):
|
||||
"""Convert a type name into a mojom.Kind object.
|
||||
|
||||
As a side-effect this function adds the result to 'kinds'.
|
||||
|
||||
Args:
|
||||
kinds: {Dict[str, mojom.Kind]} All known kinds up to this point, indexed by
|
||||
their names.
|
||||
spec: {str} A name uniquely identifying a type.
|
||||
scope: {Tuple[str, str]} A tuple that looks like (namespace,
|
||||
struct/interface), referring to the location where the type is
|
||||
referenced.
|
||||
|
||||
Returns:
|
||||
{mojom.Kind} The type corresponding to 'spec'.
|
||||
"""
|
||||
kind = _LookupKind(kinds, spec, scope)
|
||||
if kind:
|
||||
return kind
|
||||
|
||||
if spec.startswith('?'):
|
||||
kind = _Kind(kinds, spec[1:], scope).MakeNullableKind()
|
||||
elif spec.startswith('a:'):
|
||||
kind = mojom.Array(_Kind(kinds, spec[2:], scope))
|
||||
elif spec.startswith('asso:'):
|
||||
inner_kind = _Kind(kinds, spec[5:], scope)
|
||||
if isinstance(inner_kind, mojom.InterfaceRequest):
|
||||
kind = mojom.AssociatedInterfaceRequest(inner_kind)
|
||||
else:
|
||||
kind = mojom.AssociatedInterface(inner_kind)
|
||||
elif spec.startswith('a'):
|
||||
colon = spec.find(':')
|
||||
length = int(spec[1:colon])
|
||||
kind = mojom.Array(_Kind(kinds, spec[colon + 1:], scope), length)
|
||||
elif spec.startswith('r:'):
|
||||
kind = mojom.InterfaceRequest(_Kind(kinds, spec[2:], scope))
|
||||
elif spec.startswith('rmt:'):
|
||||
kind = mojom.PendingRemote(_Kind(kinds, spec[4:], scope))
|
||||
elif spec.startswith('rcv:'):
|
||||
kind = mojom.PendingReceiver(_Kind(kinds, spec[4:], scope))
|
||||
elif spec.startswith('rma:'):
|
||||
kind = mojom.PendingAssociatedRemote(_Kind(kinds, spec[4:], scope))
|
||||
elif spec.startswith('rca:'):
|
||||
kind = mojom.PendingAssociatedReceiver(_Kind(kinds, spec[4:], scope))
|
||||
elif spec.startswith('m['):
|
||||
# Isolate the two types from their brackets.
|
||||
|
||||
# It is not allowed to use map as key, so there shouldn't be nested ']'s
|
||||
# inside the key type spec.
|
||||
key_end = spec.find(']')
|
||||
assert key_end != -1 and key_end < len(spec) - 1
|
||||
assert spec[key_end + 1] == '[' and spec[-1] == ']'
|
||||
|
||||
first_kind = spec[2:key_end]
|
||||
second_kind = spec[key_end + 2:-1]
|
||||
|
||||
kind = mojom.Map(
|
||||
_Kind(kinds, first_kind, scope), _Kind(kinds, second_kind, scope))
|
||||
else:
|
||||
kind = mojom.Kind(spec)
|
||||
|
||||
kinds[spec] = kind
|
||||
return kind
|
||||
|
||||
|
||||
def _Import(module, import_module):
|
||||
# Copy the struct kinds from our imports into the current module.
|
||||
importable_kinds = (mojom.Struct, mojom.Union, mojom.Enum, mojom.Interface)
|
||||
for kind in import_module.kinds.values():
|
||||
if (isinstance(kind, importable_kinds)
|
||||
and kind.module.path == import_module.path):
|
||||
module.kinds[kind.spec] = kind
|
||||
# Ditto for values.
|
||||
for value in import_module.values.values():
|
||||
if value.module.path == import_module.path:
|
||||
module.values[value.GetSpec()] = value
|
||||
|
||||
return import_module
|
||||
|
||||
|
||||
def _Struct(module, parsed_struct):
|
||||
"""
|
||||
Args:
|
||||
module: {mojom.Module} Module currently being constructed.
|
||||
parsed_struct: {ast.Struct} Parsed struct.
|
||||
|
||||
Returns:
|
||||
{mojom.Struct} AST struct.
|
||||
"""
|
||||
struct = mojom.Struct(module=module)
|
||||
struct.mojom_name = parsed_struct.mojom_name
|
||||
struct.native_only = parsed_struct.body is None
|
||||
struct.spec = 'x:' + module.GetNamespacePrefix() + struct.mojom_name
|
||||
module.kinds[struct.spec] = struct
|
||||
struct.enums = []
|
||||
struct.constants = []
|
||||
struct.fields_data = []
|
||||
if not struct.native_only:
|
||||
_ProcessElements(
|
||||
parsed_struct.mojom_name, parsed_struct.body, {
|
||||
ast.Enum:
|
||||
lambda enum: struct.enums.append(_Enum(module, enum, struct)),
|
||||
ast.Const:
|
||||
lambda const: struct.constants.append(
|
||||
_Constant(module, const, struct)),
|
||||
ast.StructField:
|
||||
struct.fields_data.append,
|
||||
})
|
||||
|
||||
struct.attributes = _AttributeListToDict(parsed_struct.attribute_list)
|
||||
|
||||
# Enforce that a [Native] attribute is set to make native-only struct
|
||||
# declarations more explicit.
|
||||
if struct.native_only:
|
||||
if not struct.attributes or not struct.attributes.get('Native', False):
|
||||
raise Exception("Native-only struct declarations must include a " +
|
||||
"Native attribute.")
|
||||
|
||||
if struct.attributes and struct.attributes.get('CustomSerializer', False):
|
||||
struct.custom_serializer = True
|
||||
|
||||
return struct
|
||||
|
||||
|
||||
def _Union(module, parsed_union):
|
||||
"""
|
||||
Args:
|
||||
module: {mojom.Module} Module currently being constructed.
|
||||
parsed_union: {ast.Union} Parsed union.
|
||||
|
||||
Returns:
|
||||
{mojom.Union} AST union.
|
||||
"""
|
||||
union = mojom.Union(module=module)
|
||||
union.mojom_name = parsed_union.mojom_name
|
||||
union.spec = 'x:' + module.GetNamespacePrefix() + union.mojom_name
|
||||
module.kinds[union.spec] = union
|
||||
# Stash fields parsed_union here temporarily.
|
||||
union.fields_data = []
|
||||
_ProcessElements(parsed_union.mojom_name, parsed_union.body,
|
||||
{ast.UnionField: union.fields_data.append})
|
||||
union.attributes = _AttributeListToDict(parsed_union.attribute_list)
|
||||
return union
|
||||
|
||||
|
||||
def _StructField(module, parsed_field, struct):
|
||||
"""
|
||||
Args:
|
||||
module: {mojom.Module} Module currently being constructed.
|
||||
parsed_field: {ast.StructField} Parsed struct field.
|
||||
struct: {mojom.Struct} Struct this field belongs to.
|
||||
|
||||
Returns:
|
||||
{mojom.StructField} AST struct field.
|
||||
"""
|
||||
field = mojom.StructField()
|
||||
field.mojom_name = parsed_field.mojom_name
|
||||
field.kind = _Kind(module.kinds, _MapKind(parsed_field.typename),
|
||||
(module.mojom_namespace, struct.mojom_name))
|
||||
field.ordinal = parsed_field.ordinal.value if parsed_field.ordinal else None
|
||||
field.default = _LookupValue(module, struct, field.kind,
|
||||
parsed_field.default_value)
|
||||
field.attributes = _AttributeListToDict(parsed_field.attribute_list)
|
||||
return field
|
||||
|
||||
|
||||
def _UnionField(module, parsed_field, union):
|
||||
"""
|
||||
Args:
|
||||
module: {mojom.Module} Module currently being constructed.
|
||||
parsed_field: {ast.UnionField} Parsed union field.
|
||||
union: {mojom.Union} Union this fields belong to.
|
||||
|
||||
Returns:
|
||||
{mojom.UnionField} AST union.
|
||||
"""
|
||||
field = mojom.UnionField()
|
||||
field.mojom_name = parsed_field.mojom_name
|
||||
field.kind = _Kind(module.kinds, _MapKind(parsed_field.typename),
|
||||
(module.mojom_namespace, union.mojom_name))
|
||||
field.ordinal = parsed_field.ordinal.value if parsed_field.ordinal else None
|
||||
field.default = None
|
||||
field.attributes = _AttributeListToDict(parsed_field.attribute_list)
|
||||
return field
|
||||
|
||||
|
||||
def _Parameter(module, parsed_param, interface):
|
||||
"""
|
||||
Args:
|
||||
module: {mojom.Module} Module currently being constructed.
|
||||
parsed_param: {ast.Parameter} Parsed parameter.
|
||||
union: {mojom.Interface} Interface this parameter belongs to.
|
||||
|
||||
Returns:
|
||||
{mojom.Parameter} AST parameter.
|
||||
"""
|
||||
parameter = mojom.Parameter()
|
||||
parameter.mojom_name = parsed_param.mojom_name
|
||||
parameter.kind = _Kind(module.kinds, _MapKind(parsed_param.typename),
|
||||
(module.mojom_namespace, interface.mojom_name))
|
||||
parameter.ordinal = (parsed_param.ordinal.value
|
||||
if parsed_param.ordinal else None)
|
||||
parameter.default = None # TODO(tibell): We never have these. Remove field?
|
||||
parameter.attributes = _AttributeListToDict(parsed_param.attribute_list)
|
||||
return parameter
|
||||
|
||||
|
||||
def _Method(module, parsed_method, interface):
|
||||
"""
|
||||
Args:
|
||||
module: {mojom.Module} Module currently being constructed.
|
||||
parsed_method: {ast.Method} Parsed method.
|
||||
interface: {mojom.Interface} Interface this method belongs to.
|
||||
|
||||
Returns:
|
||||
{mojom.Method} AST method.
|
||||
"""
|
||||
method = mojom.Method(
|
||||
interface,
|
||||
parsed_method.mojom_name,
|
||||
ordinal=parsed_method.ordinal.value if parsed_method.ordinal else None)
|
||||
method.parameters = list(
|
||||
map(lambda parameter: _Parameter(module, parameter, interface),
|
||||
parsed_method.parameter_list))
|
||||
if parsed_method.response_parameter_list is not None:
|
||||
method.response_parameters = list(
|
||||
map(lambda parameter: _Parameter(module, parameter, interface),
|
||||
parsed_method.response_parameter_list))
|
||||
method.attributes = _AttributeListToDict(parsed_method.attribute_list)
|
||||
|
||||
# Enforce that only methods with response can have a [Sync] attribute.
|
||||
if method.sync and method.response_parameters is None:
|
||||
raise Exception("Only methods with response can include a [Sync] "
|
||||
"attribute. If no response parameters are needed, you "
|
||||
"could use an empty response parameter list, i.e., "
|
||||
"\"=> ()\".")
|
||||
|
||||
return method
|
||||
|
||||
|
||||
def _Interface(module, parsed_iface):
|
||||
"""
|
||||
Args:
|
||||
module: {mojom.Module} Module currently being constructed.
|
||||
parsed_iface: {ast.Interface} Parsed interface.
|
||||
|
||||
Returns:
|
||||
{mojom.Interface} AST interface.
|
||||
"""
|
||||
interface = mojom.Interface(module=module)
|
||||
interface.mojom_name = parsed_iface.mojom_name
|
||||
interface.spec = 'x:' + module.GetNamespacePrefix() + interface.mojom_name
|
||||
module.kinds[interface.spec] = interface
|
||||
interface.attributes = _AttributeListToDict(parsed_iface.attribute_list)
|
||||
interface.enums = []
|
||||
interface.constants = []
|
||||
interface.methods_data = []
|
||||
_ProcessElements(
|
||||
parsed_iface.mojom_name, parsed_iface.body, {
|
||||
ast.Enum:
|
||||
lambda enum: interface.enums.append(_Enum(module, enum, interface)),
|
||||
ast.Const:
|
||||
lambda const: interface.constants.append(
|
||||
_Constant(module, const, interface)),
|
||||
ast.Method:
|
||||
interface.methods_data.append,
|
||||
})
|
||||
return interface
|
||||
|
||||
|
||||
def _EnumField(module, enum, parsed_field):
|
||||
"""
|
||||
Args:
|
||||
module: {mojom.Module} Module currently being constructed.
|
||||
enum: {mojom.Enum} Enum this field belongs to.
|
||||
parsed_field: {ast.EnumValue} Parsed enum value.
|
||||
|
||||
Returns:
|
||||
{mojom.EnumField} AST enum field.
|
||||
"""
|
||||
field = mojom.EnumField()
|
||||
field.mojom_name = parsed_field.mojom_name
|
||||
field.value = _LookupValue(module, enum, None, parsed_field.value)
|
||||
field.attributes = _AttributeListToDict(parsed_field.attribute_list)
|
||||
value = mojom.EnumValue(module, enum, field)
|
||||
module.values[value.GetSpec()] = value
|
||||
return field
|
||||
|
||||
|
||||
def _ResolveNumericEnumValues(enum):
|
||||
"""
|
||||
Given a reference to a mojom.Enum, resolves and assigns the numeric value of
|
||||
each field, and also computes the min_value and max_value of the enum.
|
||||
"""
|
||||
|
||||
# map of <mojom_name> -> integral value
|
||||
prev_value = -1
|
||||
min_value = None
|
||||
max_value = None
|
||||
for field in enum.fields:
|
||||
# This enum value is +1 the previous enum value (e.g: BEGIN).
|
||||
if field.value is None:
|
||||
prev_value += 1
|
||||
|
||||
# Integral value (e.g: BEGIN = -0x1).
|
||||
elif _IsStrOrUnicode(field.value):
|
||||
prev_value = int(field.value, 0)
|
||||
|
||||
# Reference to a previous enum value (e.g: INIT = BEGIN).
|
||||
elif isinstance(field.value, mojom.EnumValue):
|
||||
prev_value = field.value.field.numeric_value
|
||||
elif isinstance(field.value, mojom.ConstantValue):
|
||||
constant = field.value.constant
|
||||
kind = constant.kind
|
||||
if not mojom.IsIntegralKind(kind) or mojom.IsBoolKind(kind):
|
||||
raise ValueError('Enum values must be integers. %s is not an integer.' %
|
||||
constant.mojom_name)
|
||||
prev_value = int(constant.value, 0)
|
||||
else:
|
||||
raise Exception('Unresolved enum value for %s' % field.value.GetSpec())
|
||||
|
||||
#resolved_enum_values[field.mojom_name] = prev_value
|
||||
field.numeric_value = prev_value
|
||||
if min_value is None or prev_value < min_value:
|
||||
min_value = prev_value
|
||||
if max_value is None or prev_value > max_value:
|
||||
max_value = prev_value
|
||||
|
||||
enum.min_value = min_value
|
||||
enum.max_value = max_value
|
||||
|
||||
|
||||
def _Enum(module, parsed_enum, parent_kind):
|
||||
"""
|
||||
Args:
|
||||
module: {mojom.Module} Module currently being constructed.
|
||||
parsed_enum: {ast.Enum} Parsed enum.
|
||||
|
||||
Returns:
|
||||
{mojom.Enum} AST enum.
|
||||
"""
|
||||
enum = mojom.Enum(module=module)
|
||||
enum.mojom_name = parsed_enum.mojom_name
|
||||
enum.native_only = parsed_enum.enum_value_list is None
|
||||
mojom_name = enum.mojom_name
|
||||
if parent_kind:
|
||||
mojom_name = parent_kind.mojom_name + '.' + mojom_name
|
||||
enum.spec = 'x:%s.%s' % (module.mojom_namespace, mojom_name)
|
||||
enum.parent_kind = parent_kind
|
||||
enum.attributes = _AttributeListToDict(parsed_enum.attribute_list)
|
||||
|
||||
if not enum.native_only:
|
||||
enum.fields = list(
|
||||
map(lambda field: _EnumField(module, enum, field),
|
||||
parsed_enum.enum_value_list))
|
||||
_ResolveNumericEnumValues(enum)
|
||||
|
||||
module.kinds[enum.spec] = enum
|
||||
|
||||
# Enforce that a [Native] attribute is set to make native-only enum
|
||||
# declarations more explicit.
|
||||
if enum.native_only:
|
||||
if not enum.attributes or not enum.attributes.get('Native', False):
|
||||
raise Exception("Native-only enum declarations must include a " +
|
||||
"Native attribute.")
|
||||
|
||||
return enum
|
||||
|
||||
|
||||
def _Constant(module, parsed_const, parent_kind):
|
||||
"""
|
||||
Args:
|
||||
module: {mojom.Module} Module currently being constructed.
|
||||
parsed_const: {ast.Const} Parsed constant.
|
||||
|
||||
Returns:
|
||||
{mojom.Constant} AST constant.
|
||||
"""
|
||||
constant = mojom.Constant()
|
||||
constant.mojom_name = parsed_const.mojom_name
|
||||
if parent_kind:
|
||||
scope = (module.mojom_namespace, parent_kind.mojom_name)
|
||||
else:
|
||||
scope = (module.mojom_namespace, )
|
||||
# TODO(mpcomplete): maybe we should only support POD kinds.
|
||||
constant.kind = _Kind(module.kinds, _MapKind(parsed_const.typename), scope)
|
||||
constant.parent_kind = parent_kind
|
||||
constant.value = _LookupValue(module, parent_kind, constant.kind,
|
||||
parsed_const.value)
|
||||
|
||||
# Iteratively resolve this constant reference to a concrete value
|
||||
while isinstance(constant.value, mojom.ConstantValue):
|
||||
constant.value = constant.value.constant.value
|
||||
|
||||
value = mojom.ConstantValue(module, parent_kind, constant)
|
||||
module.values[value.GetSpec()] = value
|
||||
return constant
|
||||
|
||||
|
||||
def _CollectReferencedKinds(module, all_defined_kinds):
|
||||
"""
|
||||
Takes a {mojom.Module} object and a list of all defined kinds within that
|
||||
module, and enumerates the complete dict of user-defined mojom types
|
||||
(as {mojom.Kind} objects) referenced by the module's own defined kinds (i.e.
|
||||
as types of struct or union or interface parameters. The returned dict is
|
||||
keyed by kind spec.
|
||||
"""
|
||||
|
||||
def extract_referenced_user_kinds(kind):
|
||||
if mojom.IsArrayKind(kind):
|
||||
return extract_referenced_user_kinds(kind.kind)
|
||||
if mojom.IsMapKind(kind):
|
||||
return (extract_referenced_user_kinds(kind.key_kind) +
|
||||
extract_referenced_user_kinds(kind.value_kind))
|
||||
if mojom.IsInterfaceRequestKind(kind) or mojom.IsAssociatedKind(kind):
|
||||
return [kind.kind]
|
||||
if mojom.IsStructKind(kind):
|
||||
return [kind]
|
||||
if (mojom.IsInterfaceKind(kind) or mojom.IsEnumKind(kind)
|
||||
or mojom.IsUnionKind(kind)):
|
||||
return [kind]
|
||||
return []
|
||||
|
||||
def sanitize_kind(kind):
|
||||
"""Removes nullability from a kind"""
|
||||
if kind.spec.startswith('?'):
|
||||
return _Kind(module.kinds, kind.spec[1:], (module.mojom_namespace, ''))
|
||||
return kind
|
||||
|
||||
referenced_user_kinds = {}
|
||||
for defined_kind in all_defined_kinds:
|
||||
if mojom.IsStructKind(defined_kind) or mojom.IsUnionKind(defined_kind):
|
||||
for field in defined_kind.fields:
|
||||
for referenced_kind in extract_referenced_user_kinds(field.kind):
|
||||
sanitized_kind = sanitize_kind(referenced_kind)
|
||||
referenced_user_kinds[sanitized_kind.spec] = sanitized_kind
|
||||
|
||||
# Also scan for references in parameter lists
|
||||
for interface in module.interfaces:
|
||||
for method in interface.methods:
|
||||
for param in itertools.chain(method.parameters or [],
|
||||
method.response_parameters or []):
|
||||
if (mojom.IsStructKind(param.kind) or mojom.IsUnionKind(param.kind)
|
||||
or mojom.IsEnumKind(param.kind)
|
||||
or mojom.IsAnyInterfaceKind(param.kind)):
|
||||
for referenced_kind in extract_referenced_user_kinds(param.kind):
|
||||
sanitized_kind = sanitize_kind(referenced_kind)
|
||||
referenced_user_kinds[sanitized_kind.spec] = sanitized_kind
|
||||
|
||||
return referenced_user_kinds
|
||||
|
||||
|
||||
def _AssignDefaultOrdinals(items):
|
||||
"""Assigns default ordinal values to a sequence of items if necessary."""
|
||||
next_ordinal = 0
|
||||
for item in items:
|
||||
if item.ordinal is not None:
|
||||
next_ordinal = item.ordinal + 1
|
||||
else:
|
||||
item.ordinal = next_ordinal
|
||||
next_ordinal += 1
|
||||
|
||||
|
||||
def _AssertTypeIsStable(kind):
|
||||
"""Raises an error if a type is not stable, meaning it is composed of at least
|
||||
one type that is not marked [Stable]."""
|
||||
|
||||
def assertDependencyIsStable(dependency):
|
||||
if (mojom.IsEnumKind(dependency) or mojom.IsStructKind(dependency)
|
||||
or mojom.IsUnionKind(dependency) or mojom.IsInterfaceKind(dependency)):
|
||||
if not dependency.stable:
|
||||
raise Exception(
|
||||
'%s is marked [Stable] but cannot be stable because it depends on '
|
||||
'%s, which is not marked [Stable].' %
|
||||
(kind.mojom_name, dependency.mojom_name))
|
||||
elif mojom.IsArrayKind(dependency) or mojom.IsAnyInterfaceKind(dependency):
|
||||
assertDependencyIsStable(dependency.kind)
|
||||
elif mojom.IsMapKind(dependency):
|
||||
assertDependencyIsStable(dependency.key_kind)
|
||||
assertDependencyIsStable(dependency.value_kind)
|
||||
|
||||
if mojom.IsStructKind(kind) or mojom.IsUnionKind(kind):
|
||||
for field in kind.fields:
|
||||
assertDependencyIsStable(field.kind)
|
||||
elif mojom.IsInterfaceKind(kind):
|
||||
for method in kind.methods:
|
||||
for param in method.param_struct.fields:
|
||||
assertDependencyIsStable(param.kind)
|
||||
if method.response_param_struct:
|
||||
for response_param in method.response_param_struct.fields:
|
||||
assertDependencyIsStable(response_param.kind)
|
||||
|
||||
|
||||
def _Module(tree, path, imports):
|
||||
"""
|
||||
Args:
|
||||
tree: {ast.Mojom} The parse tree.
|
||||
path: {str} The path to the mojom file.
|
||||
imports: {Dict[str, mojom.Module]} Mapping from filenames, as they appear in
|
||||
the import list, to already processed modules. Used to process imports.
|
||||
|
||||
Returns:
|
||||
{mojom.Module} An AST for the mojom.
|
||||
"""
|
||||
module = mojom.Module(path=path)
|
||||
module.kinds = {}
|
||||
for kind in mojom.PRIMITIVES:
|
||||
module.kinds[kind.spec] = kind
|
||||
|
||||
module.values = {}
|
||||
|
||||
module.mojom_namespace = tree.module.mojom_namespace[1] if tree.module else ''
|
||||
# Imports must come first, because they add to module.kinds which is used
|
||||
# by by the others.
|
||||
module.imports = [
|
||||
_Import(module, imports[imp.import_filename]) for imp in tree.import_list
|
||||
]
|
||||
if tree.module and tree.module.attribute_list:
|
||||
assert isinstance(tree.module.attribute_list, ast.AttributeList)
|
||||
# TODO(vtl): Check for duplicate keys here.
|
||||
module.attributes = dict((attribute.key, attribute.value)
|
||||
for attribute in tree.module.attribute_list)
|
||||
|
||||
filename = os.path.basename(path)
|
||||
# First pass collects kinds.
|
||||
module.constants = []
|
||||
module.enums = []
|
||||
module.structs = []
|
||||
module.unions = []
|
||||
module.interfaces = []
|
||||
_ProcessElements(
|
||||
filename, tree.definition_list, {
|
||||
ast.Const:
|
||||
lambda const: module.constants.append(_Constant(module, const, None)),
|
||||
ast.Enum:
|
||||
lambda enum: module.enums.append(_Enum(module, enum, None)),
|
||||
ast.Struct:
|
||||
lambda struct: module.structs.append(_Struct(module, struct)),
|
||||
ast.Union:
|
||||
lambda union: module.unions.append(_Union(module, union)),
|
||||
ast.Interface:
|
||||
lambda interface: module.interfaces.append(
|
||||
_Interface(module, interface)),
|
||||
})
|
||||
|
||||
# Second pass expands fields and methods. This allows fields and parameters
|
||||
# to refer to kinds defined anywhere in the mojom.
|
||||
all_defined_kinds = {}
|
||||
for struct in module.structs:
|
||||
struct.fields = list(
|
||||
map(lambda field: _StructField(module, field, struct),
|
||||
struct.fields_data))
|
||||
_AssignDefaultOrdinals(struct.fields)
|
||||
del struct.fields_data
|
||||
all_defined_kinds[struct.spec] = struct
|
||||
for enum in struct.enums:
|
||||
all_defined_kinds[enum.spec] = enum
|
||||
|
||||
for union in module.unions:
|
||||
union.fields = list(
|
||||
map(lambda field: _UnionField(module, field, union), union.fields_data))
|
||||
_AssignDefaultOrdinals(union.fields)
|
||||
del union.fields_data
|
||||
all_defined_kinds[union.spec] = union
|
||||
|
||||
for interface in module.interfaces:
|
||||
interface.methods = list(
|
||||
map(lambda method: _Method(module, method, interface),
|
||||
interface.methods_data))
|
||||
_AssignDefaultOrdinals(interface.methods)
|
||||
del interface.methods_data
|
||||
all_defined_kinds[interface.spec] = interface
|
||||
for enum in interface.enums:
|
||||
all_defined_kinds[enum.spec] = enum
|
||||
for enum in module.enums:
|
||||
all_defined_kinds[enum.spec] = enum
|
||||
|
||||
all_referenced_kinds = _CollectReferencedKinds(module,
|
||||
all_defined_kinds.values())
|
||||
imported_kind_specs = set(all_referenced_kinds.keys()).difference(
|
||||
set(all_defined_kinds.keys()))
|
||||
module.imported_kinds = dict(
|
||||
(spec, all_referenced_kinds[spec]) for spec in imported_kind_specs)
|
||||
|
||||
generator.AddComputedData(module)
|
||||
for iface in module.interfaces:
|
||||
for method in iface.methods:
|
||||
if method.param_struct:
|
||||
_AssignDefaultOrdinals(method.param_struct.fields)
|
||||
if method.response_param_struct:
|
||||
_AssignDefaultOrdinals(method.response_param_struct.fields)
|
||||
|
||||
# Ensure that all types marked [Stable] are actually stable. Enums are
|
||||
# automatically OK since they don't depend on other definitions.
|
||||
for kinds in (module.structs, module.unions, module.interfaces):
|
||||
for kind in kinds:
|
||||
if kind.stable:
|
||||
_AssertTypeIsStable(kind)
|
||||
|
||||
return module
|
||||
|
||||
|
||||
def OrderedModule(tree, path, imports):
|
||||
"""Convert parse tree to AST module.
|
||||
|
||||
Args:
|
||||
tree: {ast.Mojom} The parse tree.
|
||||
path: {str} The path to the mojom file.
|
||||
imports: {Dict[str, mojom.Module]} Mapping from filenames, as they appear in
|
||||
the import list, to already processed modules. Used to process imports.
|
||||
|
||||
Returns:
|
||||
{mojom.Module} An AST for the mojom.
|
||||
"""
|
||||
module = _Module(tree, path, imports)
|
||||
return module
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
# 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.
|
||||
|
||||
import imp
|
||||
import os.path
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from mojom.generate import module as mojom
|
||||
from mojom.generate import translate
|
||||
from mojom.parse import ast
|
||||
|
||||
|
||||
class TranslateTest(unittest.TestCase):
|
||||
"""Tests |parser.Parse()|."""
|
||||
|
||||
def testSimpleArray(self):
|
||||
"""Tests a simple int32[]."""
|
||||
# pylint: disable=W0212
|
||||
self.assertEquals(translate._MapKind("int32[]"), "a:i32")
|
||||
|
||||
def testAssociativeArray(self):
|
||||
"""Tests a simple uint8{string}."""
|
||||
# pylint: disable=W0212
|
||||
self.assertEquals(translate._MapKind("uint8{string}"), "m[s][u8]")
|
||||
|
||||
def testLeftToRightAssociativeArray(self):
|
||||
"""Makes sure that parsing is done from right to left on the internal kinds
|
||||
in the presence of an associative array."""
|
||||
# pylint: disable=W0212
|
||||
self.assertEquals(translate._MapKind("uint8[]{string}"), "m[s][a:u8]")
|
||||
|
||||
def testTranslateSimpleUnions(self):
|
||||
"""Makes sure that a simple union is translated correctly."""
|
||||
tree = ast.Mojom(None, ast.ImportList(), [
|
||||
ast.Union(
|
||||
"SomeUnion", None,
|
||||
ast.UnionBody([
|
||||
ast.UnionField("a", None, None, "int32"),
|
||||
ast.UnionField("b", None, None, "string")
|
||||
]))
|
||||
])
|
||||
|
||||
translation = translate.OrderedModule(tree, "mojom_tree", [])
|
||||
self.assertEqual(1, len(translation.unions))
|
||||
|
||||
union = translation.unions[0]
|
||||
self.assertTrue(isinstance(union, mojom.Union))
|
||||
self.assertEqual("SomeUnion", union.mojom_name)
|
||||
self.assertEqual(2, len(union.fields))
|
||||
self.assertEqual("a", union.fields[0].mojom_name)
|
||||
self.assertEqual(mojom.INT32.spec, union.fields[0].kind.spec)
|
||||
self.assertEqual("b", union.fields[1].mojom_name)
|
||||
self.assertEqual(mojom.STRING.spec, union.fields[1].kind.spec)
|
||||
|
||||
def testMapKindRaisesWithDuplicate(self):
|
||||
"""Verifies _MapTreeForType() raises when passed two values with the same
|
||||
name."""
|
||||
methods = [
|
||||
ast.Method('dup', None, None, ast.ParameterList(), None),
|
||||
ast.Method('dup', None, None, ast.ParameterList(), None)
|
||||
]
|
||||
with self.assertRaises(Exception):
|
||||
translate._ElemsOfType(methods, ast.Method, 'scope')
|
||||
|
||||
def testAssociatedKinds(self):
|
||||
"""Tests type spec translation of associated interfaces and requests."""
|
||||
# pylint: disable=W0212
|
||||
self.assertEquals(
|
||||
translate._MapKind("asso<SomeInterface>?"), "?asso:x:SomeInterface")
|
||||
self.assertEquals(
|
||||
translate._MapKind("asso<SomeInterface&>?"), "?asso:r:x:SomeInterface")
|
||||
427
utils/ipc/mojo/public/tools/mojom/mojom/parse/ast.py
Normal file
427
utils/ipc/mojo/public/tools/mojom/mojom/parse/ast.py
Normal file
|
|
@ -0,0 +1,427 @@
|
|||
# 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.
|
||||
"""Node classes for the AST for a Mojo IDL file."""
|
||||
|
||||
# Note: For convenience of testing, you probably want to define __eq__() methods
|
||||
# for all node types; it's okay to be slightly lax (e.g., not compare filename
|
||||
# and lineno). You may also define __repr__() to help with analyzing test
|
||||
# failures, especially for more complex types.
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
|
||||
def _IsStrOrUnicode(x):
|
||||
if sys.version_info[0] < 3:
|
||||
return isinstance(x, (unicode, str))
|
||||
return isinstance(x, str)
|
||||
|
||||
|
||||
class NodeBase(object):
|
||||
"""Base class for nodes in the AST."""
|
||||
|
||||
def __init__(self, filename=None, lineno=None):
|
||||
self.filename = filename
|
||||
self.lineno = lineno
|
||||
|
||||
def __eq__(self, other):
|
||||
# We want strict comparison of the two object's types. Disable pylint's
|
||||
# insistence upon recommending isinstance().
|
||||
# pylint: disable=unidiomatic-typecheck
|
||||
return type(self) == type(other)
|
||||
|
||||
# Make != the inverse of ==. (Subclasses shouldn't have to override this.)
|
||||
def __ne__(self, other):
|
||||
return not self == other
|
||||
|
||||
|
||||
# TODO(vtl): Some of this is complicated enough that it should be tested.
|
||||
class NodeListBase(NodeBase):
|
||||
"""Represents a list of other nodes, all having the same type. (This is meant
|
||||
to be subclassed, with subclasses defining _list_item_type to be the class (or
|
||||
classes, in a tuple) of the members of the list.)"""
|
||||
|
||||
def __init__(self, item_or_items=None, **kwargs):
|
||||
super(NodeListBase, self).__init__(**kwargs)
|
||||
self.items = []
|
||||
if item_or_items is None:
|
||||
pass
|
||||
elif isinstance(item_or_items, list):
|
||||
for item in item_or_items:
|
||||
assert isinstance(item, self._list_item_type)
|
||||
self.Append(item)
|
||||
else:
|
||||
assert isinstance(item_or_items, self._list_item_type)
|
||||
self.Append(item_or_items)
|
||||
|
||||
# Support iteration. For everything else, users should just access |items|
|
||||
# directly. (We intentionally do NOT supply |__len__()| or |__nonzero__()|, so
|
||||
# |bool(NodeListBase())| is true.)
|
||||
def __iter__(self):
|
||||
return self.items.__iter__()
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(NodeListBase, self).__eq__(other) and \
|
||||
self.items == other.items
|
||||
|
||||
# Implement this so that on failure, we get slightly more sensible output.
|
||||
def __repr__(self):
|
||||
return self.__class__.__name__ + "([" + \
|
||||
", ".join([repr(elem) for elem in self.items]) + "])"
|
||||
|
||||
def Insert(self, item):
|
||||
"""Inserts item at the front of the list."""
|
||||
|
||||
assert isinstance(item, self._list_item_type)
|
||||
self.items.insert(0, item)
|
||||
self._UpdateFilenameAndLineno()
|
||||
|
||||
def Append(self, item):
|
||||
"""Appends item to the end of the list."""
|
||||
|
||||
assert isinstance(item, self._list_item_type)
|
||||
self.items.append(item)
|
||||
self._UpdateFilenameAndLineno()
|
||||
|
||||
def _UpdateFilenameAndLineno(self):
|
||||
if self.items:
|
||||
self.filename = self.items[0].filename
|
||||
self.lineno = self.items[0].lineno
|
||||
|
||||
|
||||
class Definition(NodeBase):
|
||||
"""Represents a definition of anything that has a global name (e.g., enums,
|
||||
enum values, consts, structs, struct fields, interfaces). (This does not
|
||||
include parameter definitions.) This class is meant to be subclassed."""
|
||||
|
||||
def __init__(self, mojom_name, **kwargs):
|
||||
assert _IsStrOrUnicode(mojom_name)
|
||||
NodeBase.__init__(self, **kwargs)
|
||||
self.mojom_name = mojom_name
|
||||
|
||||
|
||||
################################################################################
|
||||
|
||||
|
||||
class Attribute(NodeBase):
|
||||
"""Represents an attribute."""
|
||||
|
||||
def __init__(self, key, value, **kwargs):
|
||||
assert _IsStrOrUnicode(key)
|
||||
super(Attribute, self).__init__(**kwargs)
|
||||
self.key = key
|
||||
self.value = value
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(Attribute, self).__eq__(other) and \
|
||||
self.key == other.key and \
|
||||
self.value == other.value
|
||||
|
||||
|
||||
class AttributeList(NodeListBase):
|
||||
"""Represents a list attributes."""
|
||||
|
||||
_list_item_type = Attribute
|
||||
|
||||
|
||||
class Const(Definition):
|
||||
"""Represents a const definition."""
|
||||
|
||||
def __init__(self, mojom_name, attribute_list, typename, value, **kwargs):
|
||||
assert attribute_list is None or isinstance(attribute_list, AttributeList)
|
||||
# The typename is currently passed through as a string.
|
||||
assert _IsStrOrUnicode(typename)
|
||||
# The value is either a literal (currently passed through as a string) or a
|
||||
# "wrapped identifier".
|
||||
assert _IsStrOrUnicode or isinstance(value, tuple)
|
||||
super(Const, self).__init__(mojom_name, **kwargs)
|
||||
self.attribute_list = attribute_list
|
||||
self.typename = typename
|
||||
self.value = value
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(Const, self).__eq__(other) and \
|
||||
self.attribute_list == other.attribute_list and \
|
||||
self.typename == other.typename and \
|
||||
self.value == other.value
|
||||
|
||||
|
||||
class Enum(Definition):
|
||||
"""Represents an enum definition."""
|
||||
|
||||
def __init__(self, mojom_name, attribute_list, enum_value_list, **kwargs):
|
||||
assert attribute_list is None or isinstance(attribute_list, AttributeList)
|
||||
assert enum_value_list is None or isinstance(enum_value_list, EnumValueList)
|
||||
super(Enum, self).__init__(mojom_name, **kwargs)
|
||||
self.attribute_list = attribute_list
|
||||
self.enum_value_list = enum_value_list
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(Enum, self).__eq__(other) and \
|
||||
self.attribute_list == other.attribute_list and \
|
||||
self.enum_value_list == other.enum_value_list
|
||||
|
||||
|
||||
class EnumValue(Definition):
|
||||
"""Represents a definition of an enum value."""
|
||||
|
||||
def __init__(self, mojom_name, attribute_list, value, **kwargs):
|
||||
# The optional value is either an int (which is current a string) or a
|
||||
# "wrapped identifier".
|
||||
assert attribute_list is None or isinstance(attribute_list, AttributeList)
|
||||
assert value is None or _IsStrOrUnicode(value) or isinstance(value, tuple)
|
||||
super(EnumValue, self).__init__(mojom_name, **kwargs)
|
||||
self.attribute_list = attribute_list
|
||||
self.value = value
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(EnumValue, self).__eq__(other) and \
|
||||
self.attribute_list == other.attribute_list and \
|
||||
self.value == other.value
|
||||
|
||||
|
||||
class EnumValueList(NodeListBase):
|
||||
"""Represents a list of enum value definitions (i.e., the "body" of an enum
|
||||
definition)."""
|
||||
|
||||
_list_item_type = EnumValue
|
||||
|
||||
|
||||
class Import(NodeBase):
|
||||
"""Represents an import statement."""
|
||||
|
||||
def __init__(self, attribute_list, import_filename, **kwargs):
|
||||
assert attribute_list is None or isinstance(attribute_list, AttributeList)
|
||||
assert _IsStrOrUnicode(import_filename)
|
||||
super(Import, self).__init__(**kwargs)
|
||||
self.attribute_list = attribute_list
|
||||
self.import_filename = import_filename
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(Import, self).__eq__(other) and \
|
||||
self.attribute_list == other.attribute_list and \
|
||||
self.import_filename == other.import_filename
|
||||
|
||||
|
||||
class ImportList(NodeListBase):
|
||||
"""Represents a list (i.e., sequence) of import statements."""
|
||||
|
||||
_list_item_type = Import
|
||||
|
||||
|
||||
class Interface(Definition):
|
||||
"""Represents an interface definition."""
|
||||
|
||||
def __init__(self, mojom_name, attribute_list, body, **kwargs):
|
||||
assert attribute_list is None or isinstance(attribute_list, AttributeList)
|
||||
assert isinstance(body, InterfaceBody)
|
||||
super(Interface, self).__init__(mojom_name, **kwargs)
|
||||
self.attribute_list = attribute_list
|
||||
self.body = body
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(Interface, self).__eq__(other) and \
|
||||
self.attribute_list == other.attribute_list and \
|
||||
self.body == other.body
|
||||
|
||||
|
||||
class Method(Definition):
|
||||
"""Represents a method definition."""
|
||||
|
||||
def __init__(self, mojom_name, attribute_list, ordinal, parameter_list,
|
||||
response_parameter_list, **kwargs):
|
||||
assert attribute_list is None or isinstance(attribute_list, AttributeList)
|
||||
assert ordinal is None or isinstance(ordinal, Ordinal)
|
||||
assert isinstance(parameter_list, ParameterList)
|
||||
assert response_parameter_list is None or \
|
||||
isinstance(response_parameter_list, ParameterList)
|
||||
super(Method, self).__init__(mojom_name, **kwargs)
|
||||
self.attribute_list = attribute_list
|
||||
self.ordinal = ordinal
|
||||
self.parameter_list = parameter_list
|
||||
self.response_parameter_list = response_parameter_list
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(Method, self).__eq__(other) and \
|
||||
self.attribute_list == other.attribute_list and \
|
||||
self.ordinal == other.ordinal and \
|
||||
self.parameter_list == other.parameter_list and \
|
||||
self.response_parameter_list == other.response_parameter_list
|
||||
|
||||
|
||||
# This needs to be declared after |Method|.
|
||||
class InterfaceBody(NodeListBase):
|
||||
"""Represents the body of (i.e., list of definitions inside) an interface."""
|
||||
|
||||
_list_item_type = (Const, Enum, Method)
|
||||
|
||||
|
||||
class Module(NodeBase):
|
||||
"""Represents a module statement."""
|
||||
|
||||
def __init__(self, mojom_namespace, attribute_list, **kwargs):
|
||||
# |mojom_namespace| is either none or a "wrapped identifier".
|
||||
assert mojom_namespace is None or isinstance(mojom_namespace, tuple)
|
||||
assert attribute_list is None or isinstance(attribute_list, AttributeList)
|
||||
super(Module, self).__init__(**kwargs)
|
||||
self.mojom_namespace = mojom_namespace
|
||||
self.attribute_list = attribute_list
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(Module, self).__eq__(other) and \
|
||||
self.mojom_namespace == other.mojom_namespace and \
|
||||
self.attribute_list == other.attribute_list
|
||||
|
||||
|
||||
class Mojom(NodeBase):
|
||||
"""Represents an entire .mojom file. (This is the root node.)"""
|
||||
|
||||
def __init__(self, module, import_list, definition_list, **kwargs):
|
||||
assert module is None or isinstance(module, Module)
|
||||
assert isinstance(import_list, ImportList)
|
||||
assert isinstance(definition_list, list)
|
||||
super(Mojom, self).__init__(**kwargs)
|
||||
self.module = module
|
||||
self.import_list = import_list
|
||||
self.definition_list = definition_list
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(Mojom, self).__eq__(other) and \
|
||||
self.module == other.module and \
|
||||
self.import_list == other.import_list and \
|
||||
self.definition_list == other.definition_list
|
||||
|
||||
def __repr__(self):
|
||||
return "%s(%r, %r, %r)" % (self.__class__.__name__, self.module,
|
||||
self.import_list, self.definition_list)
|
||||
|
||||
|
||||
class Ordinal(NodeBase):
|
||||
"""Represents an ordinal value labeling, e.g., a struct field."""
|
||||
|
||||
def __init__(self, value, **kwargs):
|
||||
assert isinstance(value, int)
|
||||
super(Ordinal, self).__init__(**kwargs)
|
||||
self.value = value
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(Ordinal, self).__eq__(other) and \
|
||||
self.value == other.value
|
||||
|
||||
|
||||
class Parameter(NodeBase):
|
||||
"""Represents a method request or response parameter."""
|
||||
|
||||
def __init__(self, mojom_name, attribute_list, ordinal, typename, **kwargs):
|
||||
assert _IsStrOrUnicode(mojom_name)
|
||||
assert attribute_list is None or isinstance(attribute_list, AttributeList)
|
||||
assert ordinal is None or isinstance(ordinal, Ordinal)
|
||||
assert _IsStrOrUnicode(typename)
|
||||
super(Parameter, self).__init__(**kwargs)
|
||||
self.mojom_name = mojom_name
|
||||
self.attribute_list = attribute_list
|
||||
self.ordinal = ordinal
|
||||
self.typename = typename
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(Parameter, self).__eq__(other) and \
|
||||
self.mojom_name == other.mojom_name and \
|
||||
self.attribute_list == other.attribute_list and \
|
||||
self.ordinal == other.ordinal and \
|
||||
self.typename == other.typename
|
||||
|
||||
|
||||
class ParameterList(NodeListBase):
|
||||
"""Represents a list of (method request or response) parameters."""
|
||||
|
||||
_list_item_type = Parameter
|
||||
|
||||
|
||||
class Struct(Definition):
|
||||
"""Represents a struct definition."""
|
||||
|
||||
def __init__(self, mojom_name, attribute_list, body, **kwargs):
|
||||
assert attribute_list is None or isinstance(attribute_list, AttributeList)
|
||||
assert isinstance(body, StructBody) or body is None
|
||||
super(Struct, self).__init__(mojom_name, **kwargs)
|
||||
self.attribute_list = attribute_list
|
||||
self.body = body
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(Struct, self).__eq__(other) and \
|
||||
self.attribute_list == other.attribute_list and \
|
||||
self.body == other.body
|
||||
|
||||
|
||||
class StructField(Definition):
|
||||
"""Represents a struct field definition."""
|
||||
|
||||
def __init__(self, mojom_name, attribute_list, ordinal, typename,
|
||||
default_value, **kwargs):
|
||||
assert _IsStrOrUnicode(mojom_name)
|
||||
assert attribute_list is None or isinstance(attribute_list, AttributeList)
|
||||
assert ordinal is None or isinstance(ordinal, Ordinal)
|
||||
assert _IsStrOrUnicode(typename)
|
||||
# The optional default value is currently either a value as a string or a
|
||||
# "wrapped identifier".
|
||||
assert default_value is None or _IsStrOrUnicode(default_value) or \
|
||||
isinstance(default_value, tuple)
|
||||
super(StructField, self).__init__(mojom_name, **kwargs)
|
||||
self.attribute_list = attribute_list
|
||||
self.ordinal = ordinal
|
||||
self.typename = typename
|
||||
self.default_value = default_value
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(StructField, self).__eq__(other) and \
|
||||
self.attribute_list == other.attribute_list and \
|
||||
self.ordinal == other.ordinal and \
|
||||
self.typename == other.typename and \
|
||||
self.default_value == other.default_value
|
||||
|
||||
|
||||
# This needs to be declared after |StructField|.
|
||||
class StructBody(NodeListBase):
|
||||
"""Represents the body of (i.e., list of definitions inside) a struct."""
|
||||
|
||||
_list_item_type = (Const, Enum, StructField)
|
||||
|
||||
|
||||
class Union(Definition):
|
||||
"""Represents a union definition."""
|
||||
|
||||
def __init__(self, mojom_name, attribute_list, body, **kwargs):
|
||||
assert attribute_list is None or isinstance(attribute_list, AttributeList)
|
||||
assert isinstance(body, UnionBody)
|
||||
super(Union, self).__init__(mojom_name, **kwargs)
|
||||
self.attribute_list = attribute_list
|
||||
self.body = body
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(Union, self).__eq__(other) and \
|
||||
self.attribute_list == other.attribute_list and \
|
||||
self.body == other.body
|
||||
|
||||
|
||||
class UnionField(Definition):
|
||||
def __init__(self, mojom_name, attribute_list, ordinal, typename, **kwargs):
|
||||
assert _IsStrOrUnicode(mojom_name)
|
||||
assert attribute_list is None or isinstance(attribute_list, AttributeList)
|
||||
assert ordinal is None or isinstance(ordinal, Ordinal)
|
||||
assert _IsStrOrUnicode(typename)
|
||||
super(UnionField, self).__init__(mojom_name, **kwargs)
|
||||
self.attribute_list = attribute_list
|
||||
self.ordinal = ordinal
|
||||
self.typename = typename
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(UnionField, self).__eq__(other) and \
|
||||
self.attribute_list == other.attribute_list and \
|
||||
self.ordinal == other.ordinal and \
|
||||
self.typename == other.typename
|
||||
|
||||
|
||||
class UnionBody(NodeListBase):
|
||||
|
||||
_list_item_type = UnionField
|
||||
121
utils/ipc/mojo/public/tools/mojom/mojom/parse/ast_unittest.py
Normal file
121
utils/ipc/mojo/public/tools/mojom/mojom/parse/ast_unittest.py
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
# 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.
|
||||
|
||||
import imp
|
||||
import os.path
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from mojom.parse import ast
|
||||
|
||||
|
||||
class _TestNode(ast.NodeBase):
|
||||
"""Node type for tests."""
|
||||
|
||||
def __init__(self, value, **kwargs):
|
||||
super(_TestNode, self).__init__(**kwargs)
|
||||
self.value = value
|
||||
|
||||
def __eq__(self, other):
|
||||
return super(_TestNode, self).__eq__(other) and self.value == other.value
|
||||
|
||||
|
||||
class _TestNodeList(ast.NodeListBase):
|
||||
"""Node list type for tests."""
|
||||
|
||||
_list_item_type = _TestNode
|
||||
|
||||
|
||||
class ASTTest(unittest.TestCase):
|
||||
"""Tests various AST classes."""
|
||||
|
||||
def testNodeBase(self):
|
||||
# Test |__eq__()|; this is only used for testing, where we want to do
|
||||
# comparison by value and ignore filenames/line numbers (for convenience).
|
||||
node1 = ast.NodeBase(filename="hello.mojom", lineno=123)
|
||||
node2 = ast.NodeBase()
|
||||
self.assertEquals(node1, node2)
|
||||
self.assertEquals(node2, node1)
|
||||
|
||||
# Check that |__ne__()| just defers to |__eq__()| properly.
|
||||
self.assertFalse(node1 != node2)
|
||||
self.assertFalse(node2 != node1)
|
||||
|
||||
# Check that |filename| and |lineno| are set properly (and are None by
|
||||
# default).
|
||||
self.assertEquals(node1.filename, "hello.mojom")
|
||||
self.assertEquals(node1.lineno, 123)
|
||||
self.assertIsNone(node2.filename)
|
||||
self.assertIsNone(node2.lineno)
|
||||
|
||||
# |NodeBase|'s |__eq__()| should compare types (and a subclass's |__eq__()|
|
||||
# should first defer to its superclass's).
|
||||
node3 = _TestNode(123)
|
||||
self.assertNotEqual(node1, node3)
|
||||
self.assertNotEqual(node3, node1)
|
||||
# Also test |__eq__()| directly.
|
||||
self.assertFalse(node1 == node3)
|
||||
self.assertFalse(node3 == node1)
|
||||
|
||||
node4 = _TestNode(123, filename="world.mojom", lineno=123)
|
||||
self.assertEquals(node4, node3)
|
||||
node5 = _TestNode(456)
|
||||
self.assertNotEquals(node5, node4)
|
||||
|
||||
def testNodeListBase(self):
|
||||
node1 = _TestNode(1, filename="foo.mojom", lineno=1)
|
||||
# Equal to, but not the same as, |node1|:
|
||||
node1b = _TestNode(1, filename="foo.mojom", lineno=1)
|
||||
node2 = _TestNode(2, filename="foo.mojom", lineno=2)
|
||||
|
||||
nodelist1 = _TestNodeList() # Contains: (empty).
|
||||
self.assertEquals(nodelist1, nodelist1)
|
||||
self.assertEquals(nodelist1.items, [])
|
||||
self.assertIsNone(nodelist1.filename)
|
||||
self.assertIsNone(nodelist1.lineno)
|
||||
|
||||
nodelist2 = _TestNodeList(node1) # Contains: 1.
|
||||
self.assertEquals(nodelist2, nodelist2)
|
||||
self.assertEquals(nodelist2.items, [node1])
|
||||
self.assertNotEqual(nodelist2, nodelist1)
|
||||
self.assertEquals(nodelist2.filename, "foo.mojom")
|
||||
self.assertEquals(nodelist2.lineno, 1)
|
||||
|
||||
nodelist3 = _TestNodeList([node2]) # Contains: 2.
|
||||
self.assertEquals(nodelist3.items, [node2])
|
||||
self.assertNotEqual(nodelist3, nodelist1)
|
||||
self.assertNotEqual(nodelist3, nodelist2)
|
||||
self.assertEquals(nodelist3.filename, "foo.mojom")
|
||||
self.assertEquals(nodelist3.lineno, 2)
|
||||
|
||||
nodelist1.Append(node1b) # Contains: 1.
|
||||
self.assertEquals(nodelist1.items, [node1])
|
||||
self.assertEquals(nodelist1, nodelist2)
|
||||
self.assertNotEqual(nodelist1, nodelist3)
|
||||
self.assertEquals(nodelist1.filename, "foo.mojom")
|
||||
self.assertEquals(nodelist1.lineno, 1)
|
||||
|
||||
nodelist1.Append(node2) # Contains: 1, 2.
|
||||
self.assertEquals(nodelist1.items, [node1, node2])
|
||||
self.assertNotEqual(nodelist1, nodelist2)
|
||||
self.assertNotEqual(nodelist1, nodelist3)
|
||||
self.assertEquals(nodelist1.lineno, 1)
|
||||
|
||||
nodelist2.Append(node2) # Contains: 1, 2.
|
||||
self.assertEquals(nodelist2.items, [node1, node2])
|
||||
self.assertEquals(nodelist2, nodelist1)
|
||||
self.assertNotEqual(nodelist2, nodelist3)
|
||||
self.assertEquals(nodelist2.lineno, 1)
|
||||
|
||||
nodelist3.Insert(node1) # Contains: 1, 2.
|
||||
self.assertEquals(nodelist3.items, [node1, node2])
|
||||
self.assertEquals(nodelist3, nodelist1)
|
||||
self.assertEquals(nodelist3, nodelist2)
|
||||
self.assertEquals(nodelist3.lineno, 1)
|
||||
|
||||
# Test iteration:
|
||||
i = 1
|
||||
for item in nodelist1:
|
||||
self.assertEquals(item.value, i)
|
||||
i += 1
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
# Copyright 2018 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.
|
||||
"""Helpers for processing conditionally enabled features in a mojom."""
|
||||
|
||||
from mojom.error import Error
|
||||
from mojom.parse import ast
|
||||
|
||||
|
||||
class EnableIfError(Error):
|
||||
""" Class for errors from ."""
|
||||
|
||||
def __init__(self, filename, message, lineno=None):
|
||||
Error.__init__(self, filename, message, lineno=lineno, addenda=None)
|
||||
|
||||
|
||||
def _IsEnabled(definition, enabled_features):
|
||||
"""Returns true if a definition is enabled.
|
||||
|
||||
A definition is enabled if it has no EnableIf attribute, or if the value of
|
||||
the EnableIf attribute is in enabled_features.
|
||||
"""
|
||||
if not hasattr(definition, "attribute_list"):
|
||||
return True
|
||||
if not definition.attribute_list:
|
||||
return True
|
||||
|
||||
already_defined = False
|
||||
for a in definition.attribute_list:
|
||||
if a.key == 'EnableIf':
|
||||
if already_defined:
|
||||
raise EnableIfError(
|
||||
definition.filename,
|
||||
"EnableIf attribute may only be defined once per field.",
|
||||
definition.lineno)
|
||||
already_defined = True
|
||||
|
||||
for attribute in definition.attribute_list:
|
||||
if attribute.key == 'EnableIf' and attribute.value not in enabled_features:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def _FilterDisabledFromNodeList(node_list, enabled_features):
|
||||
if not node_list:
|
||||
return
|
||||
assert isinstance(node_list, ast.NodeListBase)
|
||||
node_list.items = [
|
||||
item for item in node_list.items if _IsEnabled(item, enabled_features)
|
||||
]
|
||||
for item in node_list.items:
|
||||
_FilterDefinition(item, enabled_features)
|
||||
|
||||
|
||||
def _FilterDefinition(definition, enabled_features):
|
||||
"""Filters definitions with a body."""
|
||||
if isinstance(definition, ast.Enum):
|
||||
_FilterDisabledFromNodeList(definition.enum_value_list, enabled_features)
|
||||
elif isinstance(definition, ast.Interface):
|
||||
_FilterDisabledFromNodeList(definition.body, enabled_features)
|
||||
elif isinstance(definition, ast.Method):
|
||||
_FilterDisabledFromNodeList(definition.parameter_list, enabled_features)
|
||||
_FilterDisabledFromNodeList(definition.response_parameter_list,
|
||||
enabled_features)
|
||||
elif isinstance(definition, ast.Struct):
|
||||
_FilterDisabledFromNodeList(definition.body, enabled_features)
|
||||
elif isinstance(definition, ast.Union):
|
||||
_FilterDisabledFromNodeList(definition.body, enabled_features)
|
||||
|
||||
|
||||
def RemoveDisabledDefinitions(mojom, enabled_features):
|
||||
"""Removes conditionally disabled definitions from a Mojom node."""
|
||||
mojom.import_list = ast.ImportList([
|
||||
imported_file for imported_file in mojom.import_list
|
||||
if _IsEnabled(imported_file, enabled_features)
|
||||
])
|
||||
mojom.definition_list = [
|
||||
definition for definition in mojom.definition_list
|
||||
if _IsEnabled(definition, enabled_features)
|
||||
]
|
||||
for definition in mojom.definition_list:
|
||||
_FilterDefinition(definition, enabled_features)
|
||||
|
|
@ -0,0 +1,233 @@
|
|||
# Copyright 2018 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 imp
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
|
||||
def _GetDirAbove(dirname):
|
||||
"""Returns the directory "above" this file containing |dirname| (which must
|
||||
also be "above" this file)."""
|
||||
path = os.path.abspath(__file__)
|
||||
while True:
|
||||
path, tail = os.path.split(path)
|
||||
assert tail
|
||||
if tail == dirname:
|
||||
return path
|
||||
|
||||
|
||||
try:
|
||||
imp.find_module('mojom')
|
||||
except ImportError:
|
||||
sys.path.append(os.path.join(_GetDirAbove('pylib'), 'pylib'))
|
||||
import mojom.parse.ast as ast
|
||||
import mojom.parse.conditional_features as conditional_features
|
||||
import mojom.parse.parser as parser
|
||||
|
||||
ENABLED_FEATURES = frozenset({'red', 'green', 'blue'})
|
||||
|
||||
|
||||
class ConditionalFeaturesTest(unittest.TestCase):
|
||||
"""Tests |mojom.parse.conditional_features|."""
|
||||
|
||||
def parseAndAssertEqual(self, source, expected_source):
|
||||
definition = parser.Parse(source, "my_file.mojom")
|
||||
conditional_features.RemoveDisabledDefinitions(definition, ENABLED_FEATURES)
|
||||
expected = parser.Parse(expected_source, "my_file.mojom")
|
||||
self.assertEquals(definition, expected)
|
||||
|
||||
def testFilterConst(self):
|
||||
"""Test that Consts are correctly filtered."""
|
||||
const_source = """
|
||||
[EnableIf=blue]
|
||||
const int kMyConst1 = 1;
|
||||
[EnableIf=orange]
|
||||
const double kMyConst2 = 2;
|
||||
const int kMyConst3 = 3;
|
||||
"""
|
||||
expected_source = """
|
||||
[EnableIf=blue]
|
||||
const int kMyConst1 = 1;
|
||||
const int kMyConst3 = 3;
|
||||
"""
|
||||
self.parseAndAssertEqual(const_source, expected_source)
|
||||
|
||||
def testFilterEnum(self):
|
||||
"""Test that EnumValues are correctly filtered from an Enum."""
|
||||
enum_source = """
|
||||
enum MyEnum {
|
||||
[EnableIf=purple]
|
||||
VALUE1,
|
||||
[EnableIf=blue]
|
||||
VALUE2,
|
||||
VALUE3,
|
||||
};
|
||||
"""
|
||||
expected_source = """
|
||||
enum MyEnum {
|
||||
[EnableIf=blue]
|
||||
VALUE2,
|
||||
VALUE3
|
||||
};
|
||||
"""
|
||||
self.parseAndAssertEqual(enum_source, expected_source)
|
||||
|
||||
def testFilterImport(self):
|
||||
"""Test that imports are correctly filtered from a Mojom."""
|
||||
import_source = """
|
||||
[EnableIf=blue]
|
||||
import "foo.mojom";
|
||||
import "bar.mojom";
|
||||
[EnableIf=purple]
|
||||
import "baz.mojom";
|
||||
"""
|
||||
expected_source = """
|
||||
[EnableIf=blue]
|
||||
import "foo.mojom";
|
||||
import "bar.mojom";
|
||||
"""
|
||||
self.parseAndAssertEqual(import_source, expected_source)
|
||||
|
||||
def testFilterInterface(self):
|
||||
"""Test that definitions are correctly filtered from an Interface."""
|
||||
interface_source = """
|
||||
interface MyInterface {
|
||||
[EnableIf=blue]
|
||||
enum MyEnum {
|
||||
[EnableIf=purple]
|
||||
VALUE1,
|
||||
VALUE2,
|
||||
};
|
||||
[EnableIf=blue]
|
||||
const int32 kMyConst = 123;
|
||||
[EnableIf=purple]
|
||||
MyMethod();
|
||||
};
|
||||
"""
|
||||
expected_source = """
|
||||
interface MyInterface {
|
||||
[EnableIf=blue]
|
||||
enum MyEnum {
|
||||
VALUE2,
|
||||
};
|
||||
[EnableIf=blue]
|
||||
const int32 kMyConst = 123;
|
||||
};
|
||||
"""
|
||||
self.parseAndAssertEqual(interface_source, expected_source)
|
||||
|
||||
def testFilterMethod(self):
|
||||
"""Test that Parameters are correctly filtered from a Method."""
|
||||
method_source = """
|
||||
interface MyInterface {
|
||||
[EnableIf=blue]
|
||||
MyMethod([EnableIf=purple] int32 a) => ([EnableIf=red] int32 b);
|
||||
};
|
||||
"""
|
||||
expected_source = """
|
||||
interface MyInterface {
|
||||
[EnableIf=blue]
|
||||
MyMethod() => ([EnableIf=red] int32 b);
|
||||
};
|
||||
"""
|
||||
self.parseAndAssertEqual(method_source, expected_source)
|
||||
|
||||
def testFilterStruct(self):
|
||||
"""Test that definitions are correctly filtered from a Struct."""
|
||||
struct_source = """
|
||||
struct MyStruct {
|
||||
[EnableIf=blue]
|
||||
enum MyEnum {
|
||||
VALUE1,
|
||||
[EnableIf=purple]
|
||||
VALUE2,
|
||||
};
|
||||
[EnableIf=yellow]
|
||||
const double kMyConst = 1.23;
|
||||
[EnableIf=green]
|
||||
int32 a;
|
||||
double b;
|
||||
[EnableIf=purple]
|
||||
int32 c;
|
||||
[EnableIf=blue]
|
||||
double d;
|
||||
int32 e;
|
||||
[EnableIf=orange]
|
||||
double f;
|
||||
};
|
||||
"""
|
||||
expected_source = """
|
||||
struct MyStruct {
|
||||
[EnableIf=blue]
|
||||
enum MyEnum {
|
||||
VALUE1,
|
||||
};
|
||||
[EnableIf=green]
|
||||
int32 a;
|
||||
double b;
|
||||
[EnableIf=blue]
|
||||
double d;
|
||||
int32 e;
|
||||
};
|
||||
"""
|
||||
self.parseAndAssertEqual(struct_source, expected_source)
|
||||
|
||||
def testFilterUnion(self):
|
||||
"""Test that UnionFields are correctly filtered from a Union."""
|
||||
union_source = """
|
||||
union MyUnion {
|
||||
[EnableIf=yellow]
|
||||
int32 a;
|
||||
[EnableIf=red]
|
||||
bool b;
|
||||
};
|
||||
"""
|
||||
expected_source = """
|
||||
union MyUnion {
|
||||
[EnableIf=red]
|
||||
bool b;
|
||||
};
|
||||
"""
|
||||
self.parseAndAssertEqual(union_source, expected_source)
|
||||
|
||||
def testSameNameFields(self):
|
||||
mojom_source = """
|
||||
enum Foo {
|
||||
[EnableIf=red]
|
||||
VALUE1 = 5,
|
||||
[EnableIf=yellow]
|
||||
VALUE1 = 6,
|
||||
};
|
||||
[EnableIf=red]
|
||||
const double kMyConst = 1.23;
|
||||
[EnableIf=yellow]
|
||||
const double kMyConst = 4.56;
|
||||
"""
|
||||
expected_source = """
|
||||
enum Foo {
|
||||
[EnableIf=red]
|
||||
VALUE1 = 5,
|
||||
};
|
||||
[EnableIf=red]
|
||||
const double kMyConst = 1.23;
|
||||
"""
|
||||
self.parseAndAssertEqual(mojom_source, expected_source)
|
||||
|
||||
def testMultipleEnableIfs(self):
|
||||
source = """
|
||||
enum Foo {
|
||||
[EnableIf=red,EnableIf=yellow]
|
||||
kBarValue = 5,
|
||||
};
|
||||
"""
|
||||
definition = parser.Parse(source, "my_file.mojom")
|
||||
self.assertRaises(conditional_features.EnableIfError,
|
||||
conditional_features.RemoveDisabledDefinitions,
|
||||
definition, ENABLED_FEATURES)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
251
utils/ipc/mojo/public/tools/mojom/mojom/parse/lexer.py
Normal file
251
utils/ipc/mojo/public/tools/mojom/mojom/parse/lexer.py
Normal file
|
|
@ -0,0 +1,251 @@
|
|||
# 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.
|
||||
|
||||
import imp
|
||||
import os.path
|
||||
import sys
|
||||
|
||||
from mojom import fileutil
|
||||
from mojom.error import Error
|
||||
|
||||
fileutil.AddLocalRepoThirdPartyDirToModulePath()
|
||||
from ply.lex import TOKEN
|
||||
|
||||
|
||||
class LexError(Error):
|
||||
"""Class for errors from the lexer."""
|
||||
|
||||
def __init__(self, filename, message, lineno):
|
||||
Error.__init__(self, filename, message, lineno=lineno)
|
||||
|
||||
|
||||
# We have methods which look like they could be functions:
|
||||
# pylint: disable=R0201
|
||||
class Lexer(object):
|
||||
def __init__(self, filename):
|
||||
self.filename = filename
|
||||
|
||||
######################-- PRIVATE --######################
|
||||
|
||||
##
|
||||
## Internal auxiliary methods
|
||||
##
|
||||
def _error(self, msg, token):
|
||||
raise LexError(self.filename, msg, token.lineno)
|
||||
|
||||
##
|
||||
## Reserved keywords
|
||||
##
|
||||
keywords = (
|
||||
'HANDLE',
|
||||
'IMPORT',
|
||||
'MODULE',
|
||||
'STRUCT',
|
||||
'UNION',
|
||||
'INTERFACE',
|
||||
'ENUM',
|
||||
'CONST',
|
||||
'TRUE',
|
||||
'FALSE',
|
||||
'DEFAULT',
|
||||
'ARRAY',
|
||||
'MAP',
|
||||
'ASSOCIATED',
|
||||
'PENDING_REMOTE',
|
||||
'PENDING_RECEIVER',
|
||||
'PENDING_ASSOCIATED_REMOTE',
|
||||
'PENDING_ASSOCIATED_RECEIVER',
|
||||
)
|
||||
|
||||
keyword_map = {}
|
||||
for keyword in keywords:
|
||||
keyword_map[keyword.lower()] = keyword
|
||||
|
||||
##
|
||||
## All the tokens recognized by the lexer
|
||||
##
|
||||
tokens = keywords + (
|
||||
# Identifiers
|
||||
'NAME',
|
||||
|
||||
# Constants
|
||||
'ORDINAL',
|
||||
'INT_CONST_DEC',
|
||||
'INT_CONST_HEX',
|
||||
'FLOAT_CONST',
|
||||
|
||||
# String literals
|
||||
'STRING_LITERAL',
|
||||
|
||||
# Operators
|
||||
'MINUS',
|
||||
'PLUS',
|
||||
'AMP',
|
||||
'QSTN',
|
||||
|
||||
# Assignment
|
||||
'EQUALS',
|
||||
|
||||
# Request / response
|
||||
'RESPONSE',
|
||||
|
||||
# Delimiters
|
||||
'LPAREN',
|
||||
'RPAREN', # ( )
|
||||
'LBRACKET',
|
||||
'RBRACKET', # [ ]
|
||||
'LBRACE',
|
||||
'RBRACE', # { }
|
||||
'LANGLE',
|
||||
'RANGLE', # < >
|
||||
'SEMI', # ;
|
||||
'COMMA',
|
||||
'DOT' # , .
|
||||
)
|
||||
|
||||
##
|
||||
## Regexes for use in tokens
|
||||
##
|
||||
|
||||
# valid C identifiers (K&R2: A.2.3)
|
||||
identifier = r'[a-zA-Z_][0-9a-zA-Z_]*'
|
||||
|
||||
hex_prefix = '0[xX]'
|
||||
hex_digits = '[0-9a-fA-F]+'
|
||||
|
||||
# integer constants (K&R2: A.2.5.1)
|
||||
decimal_constant = '0|([1-9][0-9]*)'
|
||||
hex_constant = hex_prefix + hex_digits
|
||||
# Don't allow octal constants (even invalid octal).
|
||||
octal_constant_disallowed = '0[0-9]+'
|
||||
|
||||
# character constants (K&R2: A.2.5.2)
|
||||
# Note: a-zA-Z and '.-~^_!=&;,' are allowed as escape chars to support #line
|
||||
# directives with Windows paths as filenames (..\..\dir\file)
|
||||
# For the same reason, decimal_escape allows all digit sequences. We want to
|
||||
# parse all correct code, even if it means to sometimes parse incorrect
|
||||
# code.
|
||||
#
|
||||
simple_escape = r"""([a-zA-Z._~!=&\^\-\\?'"])"""
|
||||
decimal_escape = r"""(\d+)"""
|
||||
hex_escape = r"""(x[0-9a-fA-F]+)"""
|
||||
bad_escape = r"""([\\][^a-zA-Z._~^!=&\^\-\\?'"x0-7])"""
|
||||
|
||||
escape_sequence = \
|
||||
r"""(\\("""+simple_escape+'|'+decimal_escape+'|'+hex_escape+'))'
|
||||
|
||||
# string literals (K&R2: A.2.6)
|
||||
string_char = r"""([^"\\\n]|""" + escape_sequence + ')'
|
||||
string_literal = '"' + string_char + '*"'
|
||||
bad_string_literal = '"' + string_char + '*' + bad_escape + string_char + '*"'
|
||||
|
||||
# floating constants (K&R2: A.2.5.3)
|
||||
exponent_part = r"""([eE][-+]?[0-9]+)"""
|
||||
fractional_constant = r"""([0-9]*\.[0-9]+)|([0-9]+\.)"""
|
||||
floating_constant = \
|
||||
'(((('+fractional_constant+')'+ \
|
||||
exponent_part+'?)|([0-9]+'+exponent_part+')))'
|
||||
|
||||
# Ordinals
|
||||
ordinal = r'@[0-9]+'
|
||||
missing_ordinal_value = r'@'
|
||||
# Don't allow ordinal values in octal (even invalid octal, like 09) or
|
||||
# hexadecimal.
|
||||
octal_or_hex_ordinal_disallowed = (
|
||||
r'@((0[0-9]+)|(' + hex_prefix + hex_digits + '))')
|
||||
|
||||
##
|
||||
## Rules for the normal state
|
||||
##
|
||||
t_ignore = ' \t\r'
|
||||
|
||||
# Newlines
|
||||
def t_NEWLINE(self, t):
|
||||
r'\n+'
|
||||
t.lexer.lineno += len(t.value)
|
||||
|
||||
# Operators
|
||||
t_MINUS = r'-'
|
||||
t_PLUS = r'\+'
|
||||
t_AMP = r'&'
|
||||
t_QSTN = r'\?'
|
||||
|
||||
# =
|
||||
t_EQUALS = r'='
|
||||
|
||||
# =>
|
||||
t_RESPONSE = r'=>'
|
||||
|
||||
# Delimiters
|
||||
t_LPAREN = r'\('
|
||||
t_RPAREN = r'\)'
|
||||
t_LBRACKET = r'\['
|
||||
t_RBRACKET = r'\]'
|
||||
t_LBRACE = r'\{'
|
||||
t_RBRACE = r'\}'
|
||||
t_LANGLE = r'<'
|
||||
t_RANGLE = r'>'
|
||||
t_COMMA = r','
|
||||
t_DOT = r'\.'
|
||||
t_SEMI = r';'
|
||||
|
||||
t_STRING_LITERAL = string_literal
|
||||
|
||||
# The following floating and integer constants are defined as
|
||||
# functions to impose a strict order (otherwise, decimal
|
||||
# is placed before the others because its regex is longer,
|
||||
# and this is bad)
|
||||
#
|
||||
@TOKEN(floating_constant)
|
||||
def t_FLOAT_CONST(self, t):
|
||||
return t
|
||||
|
||||
@TOKEN(hex_constant)
|
||||
def t_INT_CONST_HEX(self, t):
|
||||
return t
|
||||
|
||||
@TOKEN(octal_constant_disallowed)
|
||||
def t_OCTAL_CONSTANT_DISALLOWED(self, t):
|
||||
msg = "Octal values not allowed"
|
||||
self._error(msg, t)
|
||||
|
||||
@TOKEN(decimal_constant)
|
||||
def t_INT_CONST_DEC(self, t):
|
||||
return t
|
||||
|
||||
# unmatched string literals are caught by the preprocessor
|
||||
|
||||
@TOKEN(bad_string_literal)
|
||||
def t_BAD_STRING_LITERAL(self, t):
|
||||
msg = "String contains invalid escape code"
|
||||
self._error(msg, t)
|
||||
|
||||
# Handle ordinal-related tokens in the right order:
|
||||
@TOKEN(octal_or_hex_ordinal_disallowed)
|
||||
def t_OCTAL_OR_HEX_ORDINAL_DISALLOWED(self, t):
|
||||
msg = "Octal and hexadecimal ordinal values not allowed"
|
||||
self._error(msg, t)
|
||||
|
||||
@TOKEN(ordinal)
|
||||
def t_ORDINAL(self, t):
|
||||
return t
|
||||
|
||||
@TOKEN(missing_ordinal_value)
|
||||
def t_BAD_ORDINAL(self, t):
|
||||
msg = "Missing ordinal value"
|
||||
self._error(msg, t)
|
||||
|
||||
@TOKEN(identifier)
|
||||
def t_NAME(self, t):
|
||||
t.type = self.keyword_map.get(t.value, "NAME")
|
||||
return t
|
||||
|
||||
# Ignore C and C++ style comments
|
||||
def t_COMMENT(self, t):
|
||||
r'(/\*(.|\n)*?\*/)|(//.*(\n[ \t]*//.*)*)'
|
||||
t.lexer.lineno += t.value.count("\n")
|
||||
|
||||
def t_error(self, t):
|
||||
msg = "Illegal character %s" % repr(t.value[0])
|
||||
self._error(msg, t)
|
||||
198
utils/ipc/mojo/public/tools/mojom/mojom/parse/lexer_unittest.py
Normal file
198
utils/ipc/mojo/public/tools/mojom/mojom/parse/lexer_unittest.py
Normal file
|
|
@ -0,0 +1,198 @@
|
|||
# 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.
|
||||
|
||||
import imp
|
||||
import os.path
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
|
||||
def _GetDirAbove(dirname):
|
||||
"""Returns the directory "above" this file containing |dirname| (which must
|
||||
also be "above" this file)."""
|
||||
path = os.path.abspath(__file__)
|
||||
while True:
|
||||
path, tail = os.path.split(path)
|
||||
assert tail
|
||||
if tail == dirname:
|
||||
return path
|
||||
|
||||
|
||||
sys.path.insert(1, os.path.join(_GetDirAbove("mojo"), "third_party"))
|
||||
from ply import lex
|
||||
|
||||
try:
|
||||
imp.find_module("mojom")
|
||||
except ImportError:
|
||||
sys.path.append(os.path.join(_GetDirAbove("pylib"), "pylib"))
|
||||
import mojom.parse.lexer
|
||||
|
||||
|
||||
# This (monkey-patching LexToken to make comparison value-based) is evil, but
|
||||
# we'll do it anyway. (I'm pretty sure ply's lexer never cares about comparing
|
||||
# for object identity.)
|
||||
def _LexTokenEq(self, other):
|
||||
return self.type == other.type and self.value == other.value and \
|
||||
self.lineno == other.lineno and self.lexpos == other.lexpos
|
||||
|
||||
|
||||
setattr(lex.LexToken, '__eq__', _LexTokenEq)
|
||||
|
||||
|
||||
def _MakeLexToken(token_type, value, lineno=1, lexpos=0):
|
||||
"""Makes a LexToken with the given parameters. (Note that lineno is 1-based,
|
||||
but lexpos is 0-based.)"""
|
||||
rv = lex.LexToken()
|
||||
rv.type, rv.value, rv.lineno, rv.lexpos = token_type, value, lineno, lexpos
|
||||
return rv
|
||||
|
||||
|
||||
def _MakeLexTokenForKeyword(keyword, **kwargs):
|
||||
"""Makes a LexToken for the given keyword."""
|
||||
return _MakeLexToken(keyword.upper(), keyword.lower(), **kwargs)
|
||||
|
||||
|
||||
class LexerTest(unittest.TestCase):
|
||||
"""Tests |mojom.parse.lexer.Lexer|."""
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
unittest.TestCase.__init__(self, *args, **kwargs)
|
||||
# Clone all lexer instances from this one, since making a lexer is slow.
|
||||
self._zygote_lexer = lex.lex(mojom.parse.lexer.Lexer("my_file.mojom"))
|
||||
|
||||
def testValidKeywords(self):
|
||||
"""Tests valid keywords."""
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("handle"), _MakeLexTokenForKeyword("handle"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("import"), _MakeLexTokenForKeyword("import"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("module"), _MakeLexTokenForKeyword("module"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("struct"), _MakeLexTokenForKeyword("struct"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("union"), _MakeLexTokenForKeyword("union"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("interface"),
|
||||
_MakeLexTokenForKeyword("interface"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("enum"), _MakeLexTokenForKeyword("enum"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("const"), _MakeLexTokenForKeyword("const"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("true"), _MakeLexTokenForKeyword("true"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("false"), _MakeLexTokenForKeyword("false"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("default"),
|
||||
_MakeLexTokenForKeyword("default"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("array"), _MakeLexTokenForKeyword("array"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("map"), _MakeLexTokenForKeyword("map"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("associated"),
|
||||
_MakeLexTokenForKeyword("associated"))
|
||||
|
||||
def testValidIdentifiers(self):
|
||||
"""Tests identifiers."""
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("abcd"), _MakeLexToken("NAME", "abcd"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("AbC_d012_"),
|
||||
_MakeLexToken("NAME", "AbC_d012_"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("_0123"), _MakeLexToken("NAME", "_0123"))
|
||||
|
||||
def testInvalidIdentifiers(self):
|
||||
with self.assertRaisesRegexp(
|
||||
mojom.parse.lexer.LexError,
|
||||
r"^my_file\.mojom:1: Error: Illegal character '\$'$"):
|
||||
self._TokensForInput("$abc")
|
||||
with self.assertRaisesRegexp(
|
||||
mojom.parse.lexer.LexError,
|
||||
r"^my_file\.mojom:1: Error: Illegal character '\$'$"):
|
||||
self._TokensForInput("a$bc")
|
||||
|
||||
def testDecimalIntegerConstants(self):
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("0"), _MakeLexToken("INT_CONST_DEC", "0"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("1"), _MakeLexToken("INT_CONST_DEC", "1"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("123"), _MakeLexToken("INT_CONST_DEC", "123"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("10"), _MakeLexToken("INT_CONST_DEC", "10"))
|
||||
|
||||
def testValidTokens(self):
|
||||
"""Tests valid tokens (which aren't tested elsewhere)."""
|
||||
# Keywords tested in |testValidKeywords|.
|
||||
# NAME tested in |testValidIdentifiers|.
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("@123"), _MakeLexToken("ORDINAL", "@123"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("456"), _MakeLexToken("INT_CONST_DEC", "456"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("0x01aB2eF3"),
|
||||
_MakeLexToken("INT_CONST_HEX", "0x01aB2eF3"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("123.456"),
|
||||
_MakeLexToken("FLOAT_CONST", "123.456"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("\"hello\""),
|
||||
_MakeLexToken("STRING_LITERAL", "\"hello\""))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("+"), _MakeLexToken("PLUS", "+"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("-"), _MakeLexToken("MINUS", "-"))
|
||||
self.assertEquals(self._SingleTokenForInput("&"), _MakeLexToken("AMP", "&"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("?"), _MakeLexToken("QSTN", "?"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("="), _MakeLexToken("EQUALS", "="))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("=>"), _MakeLexToken("RESPONSE", "=>"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("("), _MakeLexToken("LPAREN", "("))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput(")"), _MakeLexToken("RPAREN", ")"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("["), _MakeLexToken("LBRACKET", "["))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("]"), _MakeLexToken("RBRACKET", "]"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("{"), _MakeLexToken("LBRACE", "{"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("}"), _MakeLexToken("RBRACE", "}"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput("<"), _MakeLexToken("LANGLE", "<"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput(">"), _MakeLexToken("RANGLE", ">"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput(";"), _MakeLexToken("SEMI", ";"))
|
||||
self.assertEquals(
|
||||
self._SingleTokenForInput(","), _MakeLexToken("COMMA", ","))
|
||||
self.assertEquals(self._SingleTokenForInput("."), _MakeLexToken("DOT", "."))
|
||||
|
||||
def _TokensForInput(self, input_string):
|
||||
"""Gets a list of tokens for the given input string."""
|
||||
lexer = self._zygote_lexer.clone()
|
||||
lexer.input(input_string)
|
||||
rv = []
|
||||
while True:
|
||||
tok = lexer.token()
|
||||
if not tok:
|
||||
return rv
|
||||
rv.append(tok)
|
||||
|
||||
def _SingleTokenForInput(self, input_string):
|
||||
"""Gets the single token for the given input string. (Raises an exception if
|
||||
the input string does not result in exactly one token.)"""
|
||||
toks = self._TokensForInput(input_string)
|
||||
assert len(toks) == 1
|
||||
return toks[0]
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
488
utils/ipc/mojo/public/tools/mojom/mojom/parse/parser.py
Normal file
488
utils/ipc/mojo/public/tools/mojom/mojom/parse/parser.py
Normal file
|
|
@ -0,0 +1,488 @@
|
|||
# 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.
|
||||
"""Generates a syntax tree from a Mojo IDL file."""
|
||||
|
||||
import os.path
|
||||
import sys
|
||||
|
||||
from mojom import fileutil
|
||||
from mojom.error import Error
|
||||
from mojom.parse import ast
|
||||
from mojom.parse.lexer import Lexer
|
||||
|
||||
fileutil.AddLocalRepoThirdPartyDirToModulePath()
|
||||
from ply import lex
|
||||
from ply import yacc
|
||||
|
||||
_MAX_ORDINAL_VALUE = 0xffffffff
|
||||
_MAX_ARRAY_SIZE = 0xffffffff
|
||||
|
||||
|
||||
class ParseError(Error):
|
||||
"""Class for errors from the parser."""
|
||||
|
||||
def __init__(self, filename, message, lineno=None, snippet=None):
|
||||
Error.__init__(
|
||||
self,
|
||||
filename,
|
||||
message,
|
||||
lineno=lineno,
|
||||
addenda=([snippet] if snippet else None))
|
||||
|
||||
|
||||
# We have methods which look like they could be functions:
|
||||
# pylint: disable=R0201
|
||||
class Parser(object):
|
||||
def __init__(self, lexer, source, filename):
|
||||
self.tokens = lexer.tokens
|
||||
self.source = source
|
||||
self.filename = filename
|
||||
|
||||
# Names of functions
|
||||
#
|
||||
# In general, we name functions after the left-hand-side of the rule(s) that
|
||||
# they handle. E.g., |p_foo_bar| for a rule |foo_bar : ...|.
|
||||
#
|
||||
# There may be multiple functions handling rules for the same left-hand-side;
|
||||
# then we name the functions |p_foo_bar_N| (for left-hand-side |foo_bar|),
|
||||
# where N is a number (numbered starting from 1). Note that using multiple
|
||||
# functions is actually more efficient than having single functions handle
|
||||
# multiple rules (and, e.g., distinguishing them by examining |len(p)|).
|
||||
#
|
||||
# It's also possible to have a function handling multiple rules with different
|
||||
# left-hand-sides. We do not do this.
|
||||
#
|
||||
# See http://www.dabeaz.com/ply/ply.html#ply_nn25 for more details.
|
||||
|
||||
# TODO(vtl): Get rid of the braces in the module "statement". (Consider
|
||||
# renaming "module" -> "package".) Then we'll be able to have a single rule
|
||||
# for root (by making module "optional").
|
||||
def p_root_1(self, p):
|
||||
"""root : """
|
||||
p[0] = ast.Mojom(None, ast.ImportList(), [])
|
||||
|
||||
def p_root_2(self, p):
|
||||
"""root : root module"""
|
||||
if p[1].module is not None:
|
||||
raise ParseError(
|
||||
self.filename,
|
||||
"Multiple \"module\" statements not allowed:",
|
||||
p[2].lineno,
|
||||
snippet=self._GetSnippet(p[2].lineno))
|
||||
if p[1].import_list.items or p[1].definition_list:
|
||||
raise ParseError(
|
||||
self.filename,
|
||||
"\"module\" statements must precede imports and definitions:",
|
||||
p[2].lineno,
|
||||
snippet=self._GetSnippet(p[2].lineno))
|
||||
p[0] = p[1]
|
||||
p[0].module = p[2]
|
||||
|
||||
def p_root_3(self, p):
|
||||
"""root : root import"""
|
||||
if p[1].definition_list:
|
||||
raise ParseError(
|
||||
self.filename,
|
||||
"\"import\" statements must precede definitions:",
|
||||
p[2].lineno,
|
||||
snippet=self._GetSnippet(p[2].lineno))
|
||||
p[0] = p[1]
|
||||
p[0].import_list.Append(p[2])
|
||||
|
||||
def p_root_4(self, p):
|
||||
"""root : root definition"""
|
||||
p[0] = p[1]
|
||||
p[0].definition_list.append(p[2])
|
||||
|
||||
def p_import(self, p):
|
||||
"""import : attribute_section IMPORT STRING_LITERAL SEMI"""
|
||||
# 'eval' the literal to strip the quotes.
|
||||
# TODO(vtl): This eval is dubious. We should unquote/unescape ourselves.
|
||||
p[0] = ast.Import(
|
||||
p[1], eval(p[3]), filename=self.filename, lineno=p.lineno(2))
|
||||
|
||||
def p_module(self, p):
|
||||
"""module : attribute_section MODULE identifier_wrapped SEMI"""
|
||||
p[0] = ast.Module(p[3], p[1], filename=self.filename, lineno=p.lineno(2))
|
||||
|
||||
def p_definition(self, p):
|
||||
"""definition : struct
|
||||
| union
|
||||
| interface
|
||||
| enum
|
||||
| const"""
|
||||
p[0] = p[1]
|
||||
|
||||
def p_attribute_section_1(self, p):
|
||||
"""attribute_section : """
|
||||
p[0] = None
|
||||
|
||||
def p_attribute_section_2(self, p):
|
||||
"""attribute_section : LBRACKET attribute_list RBRACKET"""
|
||||
p[0] = p[2]
|
||||
|
||||
def p_attribute_list_1(self, p):
|
||||
"""attribute_list : """
|
||||
p[0] = ast.AttributeList()
|
||||
|
||||
def p_attribute_list_2(self, p):
|
||||
"""attribute_list : nonempty_attribute_list"""
|
||||
p[0] = p[1]
|
||||
|
||||
def p_nonempty_attribute_list_1(self, p):
|
||||
"""nonempty_attribute_list : attribute"""
|
||||
p[0] = ast.AttributeList(p[1])
|
||||
|
||||
def p_nonempty_attribute_list_2(self, p):
|
||||
"""nonempty_attribute_list : nonempty_attribute_list COMMA attribute"""
|
||||
p[0] = p[1]
|
||||
p[0].Append(p[3])
|
||||
|
||||
def p_attribute_1(self, p):
|
||||
"""attribute : NAME EQUALS evaled_literal
|
||||
| NAME EQUALS NAME"""
|
||||
p[0] = ast.Attribute(p[1], p[3], filename=self.filename, lineno=p.lineno(1))
|
||||
|
||||
def p_attribute_2(self, p):
|
||||
"""attribute : NAME"""
|
||||
p[0] = ast.Attribute(p[1], True, filename=self.filename, lineno=p.lineno(1))
|
||||
|
||||
def p_evaled_literal(self, p):
|
||||
"""evaled_literal : literal"""
|
||||
# 'eval' the literal to strip the quotes. Handle keywords "true" and "false"
|
||||
# specially since they cannot directly be evaluated to python boolean
|
||||
# values.
|
||||
if p[1] == "true":
|
||||
p[0] = True
|
||||
elif p[1] == "false":
|
||||
p[0] = False
|
||||
else:
|
||||
p[0] = eval(p[1])
|
||||
|
||||
def p_struct_1(self, p):
|
||||
"""struct : attribute_section STRUCT NAME LBRACE struct_body RBRACE SEMI"""
|
||||
p[0] = ast.Struct(p[3], p[1], p[5])
|
||||
|
||||
def p_struct_2(self, p):
|
||||
"""struct : attribute_section STRUCT NAME SEMI"""
|
||||
p[0] = ast.Struct(p[3], p[1], None)
|
||||
|
||||
def p_struct_body_1(self, p):
|
||||
"""struct_body : """
|
||||
p[0] = ast.StructBody()
|
||||
|
||||
def p_struct_body_2(self, p):
|
||||
"""struct_body : struct_body const
|
||||
| struct_body enum
|
||||
| struct_body struct_field"""
|
||||
p[0] = p[1]
|
||||
p[0].Append(p[2])
|
||||
|
||||
def p_struct_field(self, p):
|
||||
"""struct_field : attribute_section typename NAME ordinal default SEMI"""
|
||||
p[0] = ast.StructField(p[3], p[1], p[4], p[2], p[5])
|
||||
|
||||
def p_union(self, p):
|
||||
"""union : attribute_section UNION NAME LBRACE union_body RBRACE SEMI"""
|
||||
p[0] = ast.Union(p[3], p[1], p[5])
|
||||
|
||||
def p_union_body_1(self, p):
|
||||
"""union_body : """
|
||||
p[0] = ast.UnionBody()
|
||||
|
||||
def p_union_body_2(self, p):
|
||||
"""union_body : union_body union_field"""
|
||||
p[0] = p[1]
|
||||
p[1].Append(p[2])
|
||||
|
||||
def p_union_field(self, p):
|
||||
"""union_field : attribute_section typename NAME ordinal SEMI"""
|
||||
p[0] = ast.UnionField(p[3], p[1], p[4], p[2])
|
||||
|
||||
def p_default_1(self, p):
|
||||
"""default : """
|
||||
p[0] = None
|
||||
|
||||
def p_default_2(self, p):
|
||||
"""default : EQUALS constant"""
|
||||
p[0] = p[2]
|
||||
|
||||
def p_interface(self, p):
|
||||
"""interface : attribute_section INTERFACE NAME LBRACE interface_body \
|
||||
RBRACE SEMI"""
|
||||
p[0] = ast.Interface(p[3], p[1], p[5])
|
||||
|
||||
def p_interface_body_1(self, p):
|
||||
"""interface_body : """
|
||||
p[0] = ast.InterfaceBody()
|
||||
|
||||
def p_interface_body_2(self, p):
|
||||
"""interface_body : interface_body const
|
||||
| interface_body enum
|
||||
| interface_body method"""
|
||||
p[0] = p[1]
|
||||
p[0].Append(p[2])
|
||||
|
||||
def p_response_1(self, p):
|
||||
"""response : """
|
||||
p[0] = None
|
||||
|
||||
def p_response_2(self, p):
|
||||
"""response : RESPONSE LPAREN parameter_list RPAREN"""
|
||||
p[0] = p[3]
|
||||
|
||||
def p_method(self, p):
|
||||
"""method : attribute_section NAME ordinal LPAREN parameter_list RPAREN \
|
||||
response SEMI"""
|
||||
p[0] = ast.Method(p[2], p[1], p[3], p[5], p[7])
|
||||
|
||||
def p_parameter_list_1(self, p):
|
||||
"""parameter_list : """
|
||||
p[0] = ast.ParameterList()
|
||||
|
||||
def p_parameter_list_2(self, p):
|
||||
"""parameter_list : nonempty_parameter_list"""
|
||||
p[0] = p[1]
|
||||
|
||||
def p_nonempty_parameter_list_1(self, p):
|
||||
"""nonempty_parameter_list : parameter"""
|
||||
p[0] = ast.ParameterList(p[1])
|
||||
|
||||
def p_nonempty_parameter_list_2(self, p):
|
||||
"""nonempty_parameter_list : nonempty_parameter_list COMMA parameter"""
|
||||
p[0] = p[1]
|
||||
p[0].Append(p[3])
|
||||
|
||||
def p_parameter(self, p):
|
||||
"""parameter : attribute_section typename NAME ordinal"""
|
||||
p[0] = ast.Parameter(
|
||||
p[3], p[1], p[4], p[2], filename=self.filename, lineno=p.lineno(3))
|
||||
|
||||
def p_typename(self, p):
|
||||
"""typename : nonnullable_typename QSTN
|
||||
| nonnullable_typename"""
|
||||
if len(p) == 2:
|
||||
p[0] = p[1]
|
||||
else:
|
||||
p[0] = p[1] + "?"
|
||||
|
||||
def p_nonnullable_typename(self, p):
|
||||
"""nonnullable_typename : basictypename
|
||||
| array
|
||||
| fixed_array
|
||||
| associative_array
|
||||
| interfacerequest"""
|
||||
p[0] = p[1]
|
||||
|
||||
def p_basictypename(self, p):
|
||||
"""basictypename : remotetype
|
||||
| receivertype
|
||||
| associatedremotetype
|
||||
| associatedreceivertype
|
||||
| identifier
|
||||
| ASSOCIATED identifier
|
||||
| handletype"""
|
||||
if len(p) == 2:
|
||||
p[0] = p[1]
|
||||
else:
|
||||
p[0] = "asso<" + p[2] + ">"
|
||||
|
||||
def p_remotetype(self, p):
|
||||
"""remotetype : PENDING_REMOTE LANGLE identifier RANGLE"""
|
||||
p[0] = "rmt<%s>" % p[3]
|
||||
|
||||
def p_receivertype(self, p):
|
||||
"""receivertype : PENDING_RECEIVER LANGLE identifier RANGLE"""
|
||||
p[0] = "rcv<%s>" % p[3]
|
||||
|
||||
def p_associatedremotetype(self, p):
|
||||
"""associatedremotetype : PENDING_ASSOCIATED_REMOTE LANGLE identifier \
|
||||
RANGLE"""
|
||||
p[0] = "rma<%s>" % p[3]
|
||||
|
||||
def p_associatedreceivertype(self, p):
|
||||
"""associatedreceivertype : PENDING_ASSOCIATED_RECEIVER LANGLE identifier \
|
||||
RANGLE"""
|
||||
p[0] = "rca<%s>" % p[3]
|
||||
|
||||
def p_handletype(self, p):
|
||||
"""handletype : HANDLE
|
||||
| HANDLE LANGLE NAME RANGLE"""
|
||||
if len(p) == 2:
|
||||
p[0] = p[1]
|
||||
else:
|
||||
if p[3] not in ('data_pipe_consumer', 'data_pipe_producer',
|
||||
'message_pipe', 'shared_buffer', 'platform'):
|
||||
# Note: We don't enable tracking of line numbers for everything, so we
|
||||
# can't use |p.lineno(3)|.
|
||||
raise ParseError(
|
||||
self.filename,
|
||||
"Invalid handle type %r:" % p[3],
|
||||
lineno=p.lineno(1),
|
||||
snippet=self._GetSnippet(p.lineno(1)))
|
||||
p[0] = "handle<" + p[3] + ">"
|
||||
|
||||
def p_array(self, p):
|
||||
"""array : ARRAY LANGLE typename RANGLE"""
|
||||
p[0] = p[3] + "[]"
|
||||
|
||||
def p_fixed_array(self, p):
|
||||
"""fixed_array : ARRAY LANGLE typename COMMA INT_CONST_DEC RANGLE"""
|
||||
value = int(p[5])
|
||||
if value == 0 or value > _MAX_ARRAY_SIZE:
|
||||
raise ParseError(
|
||||
self.filename,
|
||||
"Fixed array size %d invalid:" % value,
|
||||
lineno=p.lineno(5),
|
||||
snippet=self._GetSnippet(p.lineno(5)))
|
||||
p[0] = p[3] + "[" + p[5] + "]"
|
||||
|
||||
def p_associative_array(self, p):
|
||||
"""associative_array : MAP LANGLE identifier COMMA typename RANGLE"""
|
||||
p[0] = p[5] + "{" + p[3] + "}"
|
||||
|
||||
def p_interfacerequest(self, p):
|
||||
"""interfacerequest : identifier AMP
|
||||
| ASSOCIATED identifier AMP"""
|
||||
if len(p) == 3:
|
||||
p[0] = p[1] + "&"
|
||||
else:
|
||||
p[0] = "asso<" + p[2] + "&>"
|
||||
|
||||
def p_ordinal_1(self, p):
|
||||
"""ordinal : """
|
||||
p[0] = None
|
||||
|
||||
def p_ordinal_2(self, p):
|
||||
"""ordinal : ORDINAL"""
|
||||
value = int(p[1][1:])
|
||||
if value > _MAX_ORDINAL_VALUE:
|
||||
raise ParseError(
|
||||
self.filename,
|
||||
"Ordinal value %d too large:" % value,
|
||||
lineno=p.lineno(1),
|
||||
snippet=self._GetSnippet(p.lineno(1)))
|
||||
p[0] = ast.Ordinal(value, filename=self.filename, lineno=p.lineno(1))
|
||||
|
||||
def p_enum_1(self, p):
|
||||
"""enum : attribute_section ENUM NAME LBRACE enum_value_list \
|
||||
RBRACE SEMI
|
||||
| attribute_section ENUM NAME LBRACE nonempty_enum_value_list \
|
||||
COMMA RBRACE SEMI"""
|
||||
p[0] = ast.Enum(
|
||||
p[3], p[1], p[5], filename=self.filename, lineno=p.lineno(2))
|
||||
|
||||
def p_enum_2(self, p):
|
||||
"""enum : attribute_section ENUM NAME SEMI"""
|
||||
p[0] = ast.Enum(
|
||||
p[3], p[1], None, filename=self.filename, lineno=p.lineno(2))
|
||||
|
||||
def p_enum_value_list_1(self, p):
|
||||
"""enum_value_list : """
|
||||
p[0] = ast.EnumValueList()
|
||||
|
||||
def p_enum_value_list_2(self, p):
|
||||
"""enum_value_list : nonempty_enum_value_list"""
|
||||
p[0] = p[1]
|
||||
|
||||
def p_nonempty_enum_value_list_1(self, p):
|
||||
"""nonempty_enum_value_list : enum_value"""
|
||||
p[0] = ast.EnumValueList(p[1])
|
||||
|
||||
def p_nonempty_enum_value_list_2(self, p):
|
||||
"""nonempty_enum_value_list : nonempty_enum_value_list COMMA enum_value"""
|
||||
p[0] = p[1]
|
||||
p[0].Append(p[3])
|
||||
|
||||
def p_enum_value(self, p):
|
||||
"""enum_value : attribute_section NAME
|
||||
| attribute_section NAME EQUALS int
|
||||
| attribute_section NAME EQUALS identifier_wrapped"""
|
||||
p[0] = ast.EnumValue(
|
||||
p[2],
|
||||
p[1],
|
||||
p[4] if len(p) == 5 else None,
|
||||
filename=self.filename,
|
||||
lineno=p.lineno(2))
|
||||
|
||||
def p_const(self, p):
|
||||
"""const : attribute_section CONST typename NAME EQUALS constant SEMI"""
|
||||
p[0] = ast.Const(p[4], p[1], p[3], p[6])
|
||||
|
||||
def p_constant(self, p):
|
||||
"""constant : literal
|
||||
| identifier_wrapped"""
|
||||
p[0] = p[1]
|
||||
|
||||
def p_identifier_wrapped(self, p):
|
||||
"""identifier_wrapped : identifier"""
|
||||
p[0] = ('IDENTIFIER', p[1])
|
||||
|
||||
# TODO(vtl): Make this produce a "wrapped" identifier (probably as an
|
||||
# |ast.Identifier|, to be added) and get rid of identifier_wrapped.
|
||||
def p_identifier(self, p):
|
||||
"""identifier : NAME
|
||||
| NAME DOT identifier"""
|
||||
p[0] = ''.join(p[1:])
|
||||
|
||||
def p_literal(self, p):
|
||||
"""literal : int
|
||||
| float
|
||||
| TRUE
|
||||
| FALSE
|
||||
| DEFAULT
|
||||
| STRING_LITERAL"""
|
||||
p[0] = p[1]
|
||||
|
||||
def p_int(self, p):
|
||||
"""int : int_const
|
||||
| PLUS int_const
|
||||
| MINUS int_const"""
|
||||
p[0] = ''.join(p[1:])
|
||||
|
||||
def p_int_const(self, p):
|
||||
"""int_const : INT_CONST_DEC
|
||||
| INT_CONST_HEX"""
|
||||
p[0] = p[1]
|
||||
|
||||
def p_float(self, p):
|
||||
"""float : FLOAT_CONST
|
||||
| PLUS FLOAT_CONST
|
||||
| MINUS FLOAT_CONST"""
|
||||
p[0] = ''.join(p[1:])
|
||||
|
||||
def p_error(self, e):
|
||||
if e is None:
|
||||
# Unexpected EOF.
|
||||
# TODO(vtl): Can we figure out what's missing?
|
||||
raise ParseError(self.filename, "Unexpected end of file")
|
||||
|
||||
raise ParseError(
|
||||
self.filename,
|
||||
"Unexpected %r:" % e.value,
|
||||
lineno=e.lineno,
|
||||
snippet=self._GetSnippet(e.lineno))
|
||||
|
||||
def _GetSnippet(self, lineno):
|
||||
return self.source.split('\n')[lineno - 1]
|
||||
|
||||
|
||||
def Parse(source, filename):
|
||||
"""Parse source file to AST.
|
||||
|
||||
Args:
|
||||
source: The source text as a str (Python 2 or 3) or unicode (Python 2).
|
||||
filename: The filename that |source| originates from.
|
||||
|
||||
Returns:
|
||||
The AST as a mojom.parse.ast.Mojom object.
|
||||
"""
|
||||
lexer = Lexer(filename)
|
||||
parser = Parser(lexer, source, filename)
|
||||
|
||||
lex.lex(object=lexer)
|
||||
yacc.yacc(module=parser, debug=0, write_tables=0)
|
||||
|
||||
tree = yacc.parse(source)
|
||||
return tree
|
||||
1390
utils/ipc/mojo/public/tools/mojom/mojom/parse/parser_unittest.py
Normal file
1390
utils/ipc/mojo/public/tools/mojom/mojom/parse/parser_unittest.py
Normal file
File diff suppressed because it is too large
Load diff
361
utils/ipc/mojo/public/tools/mojom/mojom_parser.py
Executable file
361
utils/ipc/mojo/public/tools/mojom/mojom_parser.py
Executable file
|
|
@ -0,0 +1,361 @@
|
|||
#!/usr/bin/env python
|
||||
# Copyright 2020 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.
|
||||
"""Parses mojom IDL files.
|
||||
|
||||
This script parses one or more input mojom files and produces corresponding
|
||||
module files fully describing the definitions contained within each mojom. The
|
||||
module data is pickled and can be easily consumed by other tools to, e.g.,
|
||||
generate usable language bindings.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import codecs
|
||||
import errno
|
||||
import json
|
||||
import os
|
||||
import os.path
|
||||
import sys
|
||||
from collections import defaultdict
|
||||
|
||||
from mojom.generate import module
|
||||
from mojom.generate import translate
|
||||
from mojom.parse import parser
|
||||
from mojom.parse import conditional_features
|
||||
|
||||
|
||||
def _ResolveRelativeImportPath(path, roots):
|
||||
"""Attempts to resolve a relative import path against a set of possible roots.
|
||||
|
||||
Args:
|
||||
path: The relative import path to resolve.
|
||||
roots: A list of absolute paths which will be checked in descending length
|
||||
order for a match against path.
|
||||
|
||||
Returns:
|
||||
A normalized absolute path combining one of the roots with the input path if
|
||||
and only if such a file exists.
|
||||
|
||||
Raises:
|
||||
ValueError: The path could not be resolved against any of the given roots.
|
||||
"""
|
||||
for root in reversed(sorted(roots, key=len)):
|
||||
abs_path = os.path.join(root, path)
|
||||
if os.path.isfile(abs_path):
|
||||
return os.path.normcase(os.path.normpath(abs_path))
|
||||
|
||||
raise ValueError('"%s" does not exist in any of %s' % (path, roots))
|
||||
|
||||
|
||||
def _RebaseAbsolutePath(path, roots):
|
||||
"""Rewrites an absolute file path as relative to an absolute directory path in
|
||||
roots.
|
||||
|
||||
Args:
|
||||
path: The absolute path of an existing file.
|
||||
roots: A list of absolute directory paths. The given path argument must fall
|
||||
within one of these directories.
|
||||
|
||||
Returns:
|
||||
A path equivalent to the input path, but relative to one of the provided
|
||||
roots. If the input path falls within multiple roots, the longest root is
|
||||
chosen (and thus the shortest relative path is returned).
|
||||
|
||||
Paths returned by this method always use forward slashes as a separator to
|
||||
mirror mojom import syntax.
|
||||
|
||||
Raises:
|
||||
ValueError if the given path does not fall within any of the listed roots.
|
||||
"""
|
||||
assert os.path.isabs(path)
|
||||
assert os.path.isfile(path)
|
||||
assert all(map(os.path.isabs, roots))
|
||||
|
||||
sorted_roots = list(reversed(sorted(roots, key=len)))
|
||||
|
||||
def try_rebase_path(path, root):
|
||||
head, rebased_path = os.path.split(path)
|
||||
while head != root:
|
||||
head, tail = os.path.split(head)
|
||||
if not tail:
|
||||
return None
|
||||
rebased_path = os.path.join(tail, rebased_path)
|
||||
return rebased_path
|
||||
|
||||
for root in sorted_roots:
|
||||
relative_path = try_rebase_path(path, root)
|
||||
if relative_path:
|
||||
# TODO(crbug.com/953884): Use pathlib for this kind of thing once we're
|
||||
# fully migrated to Python 3.
|
||||
return relative_path.replace('\\', '/')
|
||||
|
||||
raise ValueError('%s does not fall within any of %s' % (path, sorted_roots))
|
||||
|
||||
|
||||
def _GetModuleFilename(mojom_filename):
|
||||
return mojom_filename + '-module'
|
||||
|
||||
|
||||
def _EnsureInputLoaded(mojom_abspath, module_path, abs_paths, asts,
|
||||
dependencies, loaded_modules):
|
||||
"""Recursively ensures that a module and its dependencies are loaded.
|
||||
|
||||
Args:
|
||||
mojom_abspath: An absolute file path pointing to a mojom file to load.
|
||||
module_path: The relative path used to identify mojom_abspath.
|
||||
abs_paths: A mapping from module paths to absolute file paths for all
|
||||
inputs given to this execution of the script.
|
||||
asts: A map from each input mojom's absolute path to its parsed AST.
|
||||
dependencies: A mapping of which input mojoms depend on each other, indexed
|
||||
by absolute file path.
|
||||
loaded_modules: A mapping of all modules loaded so far, including non-input
|
||||
modules that were pulled in as transitive dependencies of the inputs.
|
||||
import_set: The working set of mojom imports processed so far in this
|
||||
call stack. Used to detect circular dependencies.
|
||||
import_stack: An ordered list of imports processed so far in this call
|
||||
stack. Used to report circular dependencies.
|
||||
|
||||
Returns:
|
||||
None
|
||||
|
||||
On return, loaded_modules will be populated with the loaded input mojom's
|
||||
Module as well as the Modules of all of its transitive dependencies."""
|
||||
|
||||
if mojom_abspath in loaded_modules:
|
||||
# Already done.
|
||||
return
|
||||
|
||||
for dep_abspath, dep_path in dependencies[mojom_abspath]:
|
||||
if dep_abspath not in loaded_modules:
|
||||
_EnsureInputLoaded(dep_abspath, dep_path, abs_paths, asts, dependencies,
|
||||
loaded_modules)
|
||||
|
||||
imports = {}
|
||||
for imp in asts[mojom_abspath].import_list:
|
||||
path = imp.import_filename
|
||||
imports[path] = loaded_modules[abs_paths[path]]
|
||||
loaded_modules[mojom_abspath] = translate.OrderedModule(
|
||||
asts[mojom_abspath], module_path, imports)
|
||||
|
||||
|
||||
def _CollectAllowedImportsFromBuildMetadata(build_metadata_filename):
|
||||
allowed_imports = set()
|
||||
processed_deps = set()
|
||||
|
||||
def collect(metadata_filename):
|
||||
processed_deps.add(metadata_filename)
|
||||
with open(metadata_filename) as f:
|
||||
metadata = json.load(f)
|
||||
allowed_imports.update(
|
||||
map(os.path.normcase, map(os.path.normpath, metadata['sources'])))
|
||||
for dep_metadata in metadata['deps']:
|
||||
if dep_metadata not in processed_deps:
|
||||
collect(dep_metadata)
|
||||
|
||||
collect(build_metadata_filename)
|
||||
return allowed_imports
|
||||
|
||||
|
||||
def _ParseMojoms(mojom_files,
|
||||
input_root_paths,
|
||||
output_root_path,
|
||||
enabled_features,
|
||||
allowed_imports=None):
|
||||
"""Parses a set of mojom files and produces serialized module outputs.
|
||||
|
||||
Args:
|
||||
mojom_files: A list of mojom files to process. Paths must be absolute paths
|
||||
which fall within one of the input or output root paths.
|
||||
input_root_paths: A list of absolute filesystem paths which may be used to
|
||||
resolve relative mojom file paths.
|
||||
output_root_path: An absolute filesystem path which will service as the root
|
||||
for all emitted artifacts. Artifacts produced from a given mojom file
|
||||
are based on the mojom's relative path, rebased onto this path.
|
||||
Additionally, the script expects this root to contain already-generated
|
||||
modules for any transitive dependencies not listed in mojom_files.
|
||||
enabled_features: A list of enabled feature names, controlling which AST
|
||||
nodes are filtered by [EnableIf] attributes.
|
||||
|
||||
Returns:
|
||||
None.
|
||||
|
||||
Upon completion, a mojom-module file will be saved for each input mojom.
|
||||
"""
|
||||
assert input_root_paths
|
||||
assert output_root_path
|
||||
|
||||
loaded_mojom_asts = {}
|
||||
loaded_modules = {}
|
||||
input_dependencies = defaultdict(set)
|
||||
mojom_files_to_parse = dict((os.path.normcase(abs_path),
|
||||
_RebaseAbsolutePath(abs_path, input_root_paths))
|
||||
for abs_path in mojom_files)
|
||||
abs_paths = dict(
|
||||
(path, abs_path) for abs_path, path in mojom_files_to_parse.items())
|
||||
for mojom_abspath, _ in mojom_files_to_parse.items():
|
||||
with codecs.open(mojom_abspath, encoding='utf-8') as f:
|
||||
ast = parser.Parse(''.join(f.readlines()), mojom_abspath)
|
||||
conditional_features.RemoveDisabledDefinitions(ast, enabled_features)
|
||||
loaded_mojom_asts[mojom_abspath] = ast
|
||||
invalid_imports = []
|
||||
for imp in ast.import_list:
|
||||
import_abspath = _ResolveRelativeImportPath(imp.import_filename,
|
||||
input_root_paths)
|
||||
if allowed_imports and import_abspath not in allowed_imports:
|
||||
invalid_imports.append(imp.import_filename)
|
||||
|
||||
abs_paths[imp.import_filename] = import_abspath
|
||||
if import_abspath in mojom_files_to_parse:
|
||||
# This import is in the input list, so we're going to translate it
|
||||
# into a module below; however it's also a dependency of another input
|
||||
# module. We retain record of dependencies to help with input
|
||||
# processing later.
|
||||
input_dependencies[mojom_abspath].add((import_abspath,
|
||||
imp.import_filename))
|
||||
else:
|
||||
# We have an import that isn't being parsed right now. It must already
|
||||
# be parsed and have a module file sitting in a corresponding output
|
||||
# location.
|
||||
module_path = _GetModuleFilename(imp.import_filename)
|
||||
module_abspath = _ResolveRelativeImportPath(module_path,
|
||||
[output_root_path])
|
||||
with open(module_abspath, 'rb') as module_file:
|
||||
loaded_modules[import_abspath] = module.Module.Load(module_file)
|
||||
|
||||
if invalid_imports:
|
||||
raise ValueError(
|
||||
'\nThe file %s imports the following files not allowed by build '
|
||||
'dependencies:\n\n%s\n' % (mojom_abspath,
|
||||
'\n'.join(invalid_imports)))
|
||||
|
||||
|
||||
# At this point all transitive imports not listed as inputs have been loaded
|
||||
# and we have a complete dependency tree of the unprocessed inputs. Now we can
|
||||
# load all the inputs, resolving dependencies among them recursively as we go.
|
||||
num_existing_modules_loaded = len(loaded_modules)
|
||||
for mojom_abspath, mojom_path in mojom_files_to_parse.items():
|
||||
_EnsureInputLoaded(mojom_abspath, mojom_path, abs_paths, loaded_mojom_asts,
|
||||
input_dependencies, loaded_modules)
|
||||
assert (num_existing_modules_loaded +
|
||||
len(mojom_files_to_parse) == len(loaded_modules))
|
||||
|
||||
# Now we have fully translated modules for every input and every transitive
|
||||
# dependency. We can dump the modules to disk for other tools to use.
|
||||
for mojom_abspath, mojom_path in mojom_files_to_parse.items():
|
||||
module_path = os.path.join(output_root_path, _GetModuleFilename(mojom_path))
|
||||
module_dir = os.path.dirname(module_path)
|
||||
if not os.path.exists(module_dir):
|
||||
try:
|
||||
# Python 2 doesn't support exist_ok on makedirs(), so we just ignore
|
||||
# that failure if it happens. It's possible during build due to races
|
||||
# among build steps with module outputs in the same directory.
|
||||
os.makedirs(module_dir)
|
||||
except OSError as e:
|
||||
if e.errno != errno.EEXIST:
|
||||
raise
|
||||
with open(module_path, 'wb') as f:
|
||||
loaded_modules[mojom_abspath].Dump(f)
|
||||
|
||||
|
||||
def Run(command_line):
|
||||
arg_parser = argparse.ArgumentParser(
|
||||
description="""
|
||||
Parses one or more mojom files and produces corresponding module outputs fully
|
||||
describing the definitions therein. The output is exhaustive, stable, and
|
||||
sufficient for another tool to consume and emit e.g. usable language
|
||||
bindings based on the original mojoms.""",
|
||||
epilog="""
|
||||
Note that each transitive import dependency reachable from the input mojoms must
|
||||
either also be listed as an input or must have its corresponding compiled module
|
||||
already present in the provided output root.""")
|
||||
|
||||
arg_parser.add_argument(
|
||||
'--input-root',
|
||||
default=[],
|
||||
action='append',
|
||||
metavar='ROOT',
|
||||
dest='input_root_paths',
|
||||
help='Adds ROOT to the set of root paths against which relative input '
|
||||
'paths should be resolved. Provided root paths are always searched '
|
||||
'in order from longest absolute path to shortest.')
|
||||
arg_parser.add_argument(
|
||||
'--output-root',
|
||||
action='store',
|
||||
required=True,
|
||||
dest='output_root_path',
|
||||
metavar='ROOT',
|
||||
help='Use ROOT as the root path in which the parser should emit compiled '
|
||||
'modules for each processed input mojom. The path of emitted module is '
|
||||
'based on the relative input path, rebased onto this root. Note that '
|
||||
'ROOT is also searched for existing modules of any transitive imports '
|
||||
'which were not included in the set of inputs.')
|
||||
arg_parser.add_argument(
|
||||
'--mojoms',
|
||||
nargs='+',
|
||||
dest='mojom_files',
|
||||
default=[],
|
||||
metavar='MOJOM_FILE',
|
||||
help='Input mojom filename(s). Each filename must be either an absolute '
|
||||
'path which falls within one of the given input or output roots, or a '
|
||||
'relative path the parser will attempt to resolve using each of those '
|
||||
'roots in unspecified order.')
|
||||
arg_parser.add_argument(
|
||||
'--mojom-file-list',
|
||||
action='store',
|
||||
metavar='LIST_FILENAME',
|
||||
help='Input file whose contents are a list of mojoms to process. This '
|
||||
'may be provided in lieu of --mojoms to avoid hitting command line '
|
||||
'length limtations')
|
||||
arg_parser.add_argument(
|
||||
'--enable-feature',
|
||||
dest='enabled_features',
|
||||
default=[],
|
||||
action='append',
|
||||
metavar='FEATURE',
|
||||
help='Enables a named feature when parsing the given mojoms. Features '
|
||||
'are identified by arbitrary string values. Specifying this flag with a '
|
||||
'given FEATURE name will cause the parser to process any syntax elements '
|
||||
'tagged with an [EnableIf=FEATURE] attribute. If this flag is not '
|
||||
'provided for a given FEATURE, such tagged elements are discarded by the '
|
||||
'parser and will not be present in the compiled output.')
|
||||
arg_parser.add_argument(
|
||||
'--check-imports',
|
||||
dest='build_metadata_filename',
|
||||
action='store',
|
||||
metavar='METADATA_FILENAME',
|
||||
help='Instructs the parser to check imports against a set of allowed '
|
||||
'imports. Allowed imports are based on build metadata within '
|
||||
'METADATA_FILENAME. This is a JSON file with a `sources` key listing '
|
||||
'paths to the set of input mojom files being processed by this parser '
|
||||
'run, and a `deps` key listing paths to metadata files for any '
|
||||
'dependencies of these inputs. This feature can be used to implement '
|
||||
'build-time dependency checking for mojom imports, where each build '
|
||||
'metadata file corresponds to a build target in the dependency graph of '
|
||||
'a typical build system.')
|
||||
|
||||
args, _ = arg_parser.parse_known_args(command_line)
|
||||
if args.mojom_file_list:
|
||||
with open(args.mojom_file_list) as f:
|
||||
args.mojom_files.extend(f.read().split())
|
||||
|
||||
if not args.mojom_files:
|
||||
raise ValueError(
|
||||
'Must list at least one mojom file via --mojoms or --mojom-file-list')
|
||||
|
||||
mojom_files = list(map(os.path.abspath, args.mojom_files))
|
||||
input_roots = list(map(os.path.abspath, args.input_root_paths))
|
||||
output_root = os.path.abspath(args.output_root_path)
|
||||
|
||||
if args.build_metadata_filename:
|
||||
allowed_imports = _CollectAllowedImportsFromBuildMetadata(
|
||||
args.build_metadata_filename)
|
||||
else:
|
||||
allowed_imports = None
|
||||
|
||||
_ParseMojoms(mojom_files, input_roots, output_root, args.enabled_features,
|
||||
allowed_imports)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
Run(sys.argv[1:])
|
||||
73
utils/ipc/mojo/public/tools/mojom/mojom_parser_test_case.py
Normal file
73
utils/ipc/mojo/public/tools/mojom/mojom_parser_test_case.py
Normal file
|
|
@ -0,0 +1,73 @@
|
|||
# Copyright 2020 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 json
|
||||
import os
|
||||
import os.path
|
||||
import shutil
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
import mojom_parser
|
||||
|
||||
from mojom.generate import module
|
||||
|
||||
|
||||
class MojomParserTestCase(unittest.TestCase):
|
||||
"""Tests covering the behavior defined by the main mojom_parser.py script.
|
||||
This includes behavior around input and output path manipulation, dependency
|
||||
resolution, and module serialization and deserialization."""
|
||||
|
||||
def __init__(self, method_name):
|
||||
super(MojomParserTestCase, self).__init__(method_name)
|
||||
self._temp_dir = None
|
||||
|
||||
def setUp(self):
|
||||
self._temp_dir = tempfile.mkdtemp()
|
||||
|
||||
def tearDown(self):
|
||||
shutil.rmtree(self._temp_dir)
|
||||
self._temp_dir = None
|
||||
|
||||
def GetPath(self, path):
|
||||
assert not os.path.isabs(path)
|
||||
return os.path.join(self._temp_dir, path)
|
||||
|
||||
def GetModulePath(self, path):
|
||||
assert not os.path.isabs(path)
|
||||
return os.path.join(self.GetPath('out'), path) + '-module'
|
||||
|
||||
def WriteFile(self, path, contents):
|
||||
full_path = self.GetPath(path)
|
||||
dirname = os.path.dirname(full_path)
|
||||
if not os.path.exists(dirname):
|
||||
os.makedirs(dirname)
|
||||
with open(full_path, 'w') as f:
|
||||
f.write(contents)
|
||||
|
||||
def LoadModule(self, mojom_path):
|
||||
with open(self.GetModulePath(mojom_path), 'rb') as f:
|
||||
return module.Module.Load(f)
|
||||
|
||||
def ParseMojoms(self, mojoms, metadata=None):
|
||||
"""Parse all input mojoms relative the temp dir."""
|
||||
out_dir = self.GetPath('out')
|
||||
args = [
|
||||
'--input-root', self._temp_dir, '--input-root', out_dir,
|
||||
'--output-root', out_dir, '--mojoms'
|
||||
] + list(map(lambda mojom: os.path.join(self._temp_dir, mojom), mojoms))
|
||||
if metadata:
|
||||
args.extend(['--check-imports', self.GetPath(metadata)])
|
||||
mojom_parser.Run(args)
|
||||
|
||||
def ExtractTypes(self, mojom):
|
||||
filename = 'test.mojom'
|
||||
self.WriteFile(filename, mojom)
|
||||
self.ParseMojoms([filename])
|
||||
m = self.LoadModule(filename)
|
||||
definitions = {}
|
||||
for kinds in (m.enums, m.structs, m.unions, m.interfaces):
|
||||
for kind in kinds:
|
||||
definitions[kind.mojom_name] = kind
|
||||
return definitions
|
||||
171
utils/ipc/mojo/public/tools/mojom/mojom_parser_unittest.py
Normal file
171
utils/ipc/mojo/public/tools/mojom/mojom_parser_unittest.py
Normal file
|
|
@ -0,0 +1,171 @@
|
|||
# Copyright 2020 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.
|
||||
|
||||
from mojom_parser_test_case import MojomParserTestCase
|
||||
|
||||
|
||||
class MojomParserTest(MojomParserTestCase):
|
||||
"""Tests covering the behavior defined by the main mojom_parser.py script.
|
||||
This includes behavior around input and output path manipulation, dependency
|
||||
resolution, and module serialization and deserialization."""
|
||||
|
||||
def testBasicParse(self):
|
||||
"""Basic test to verify that we can parse a mojom file and get a module."""
|
||||
mojom = 'foo/bar.mojom'
|
||||
self.WriteFile(
|
||||
mojom, """\
|
||||
module test;
|
||||
enum TestEnum { kFoo };
|
||||
""")
|
||||
self.ParseMojoms([mojom])
|
||||
|
||||
m = self.LoadModule(mojom)
|
||||
self.assertEqual('foo/bar.mojom', m.path)
|
||||
self.assertEqual('test', m.mojom_namespace)
|
||||
self.assertEqual(1, len(m.enums))
|
||||
|
||||
def testBasicParseWithAbsolutePaths(self):
|
||||
"""Verifies that we can parse a mojom file given an absolute path input."""
|
||||
mojom = 'foo/bar.mojom'
|
||||
self.WriteFile(
|
||||
mojom, """\
|
||||
module test;
|
||||
enum TestEnum { kFoo };
|
||||
""")
|
||||
self.ParseMojoms([self.GetPath(mojom)])
|
||||
|
||||
m = self.LoadModule(mojom)
|
||||
self.assertEqual('foo/bar.mojom', m.path)
|
||||
self.assertEqual('test', m.mojom_namespace)
|
||||
self.assertEqual(1, len(m.enums))
|
||||
|
||||
def testImport(self):
|
||||
"""Verify imports within the same set of mojom inputs."""
|
||||
a = 'a.mojom'
|
||||
b = 'b.mojom'
|
||||
self.WriteFile(
|
||||
a, """\
|
||||
module a;
|
||||
import "b.mojom";
|
||||
struct Foo { b.Bar bar; };""")
|
||||
self.WriteFile(b, """\
|
||||
module b;
|
||||
struct Bar {};""")
|
||||
self.ParseMojoms([a, b])
|
||||
|
||||
ma = self.LoadModule(a)
|
||||
mb = self.LoadModule(b)
|
||||
self.assertEqual('a.mojom', ma.path)
|
||||
self.assertEqual('b.mojom', mb.path)
|
||||
self.assertEqual(1, len(ma.imports))
|
||||
self.assertEqual(mb, ma.imports[0])
|
||||
|
||||
def testPreProcessedImport(self):
|
||||
"""Verify imports processed by a previous parser execution can be loaded
|
||||
properly when parsing a dependent mojom."""
|
||||
a = 'a.mojom'
|
||||
self.WriteFile(a, """\
|
||||
module a;
|
||||
struct Bar {};""")
|
||||
self.ParseMojoms([a])
|
||||
|
||||
b = 'b.mojom'
|
||||
self.WriteFile(
|
||||
b, """\
|
||||
module b;
|
||||
import "a.mojom";
|
||||
struct Foo { a.Bar bar; };""")
|
||||
self.ParseMojoms([b])
|
||||
|
||||
def testMissingImport(self):
|
||||
"""Verify that an import fails if the imported mojom does not exist."""
|
||||
a = 'a.mojom'
|
||||
self.WriteFile(
|
||||
a, """\
|
||||
module a;
|
||||
import "non-existent.mojom";
|
||||
struct Bar {};""")
|
||||
with self.assertRaisesRegexp(ValueError, "does not exist"):
|
||||
self.ParseMojoms([a])
|
||||
|
||||
def testUnparsedImport(self):
|
||||
"""Verify that an import fails if the imported mojom is not in the set of
|
||||
mojoms provided to the parser on this execution AND there is no pre-existing
|
||||
parsed output module already on disk for it."""
|
||||
a = 'a.mojom'
|
||||
b = 'b.mojom'
|
||||
self.WriteFile(a, """\
|
||||
module a;
|
||||
struct Bar {};""")
|
||||
self.WriteFile(
|
||||
b, """\
|
||||
module b;
|
||||
import "a.mojom";
|
||||
struct Foo { a.Bar bar; };""")
|
||||
|
||||
# a.mojom has not been parsed yet, so its import will fail when processing
|
||||
# b.mojom here.
|
||||
with self.assertRaisesRegexp(ValueError, "does not exist"):
|
||||
self.ParseMojoms([b])
|
||||
|
||||
def testCheckImportsBasic(self):
|
||||
"""Verify that the parser can handle --check-imports with a valid set of
|
||||
inputs, including support for transitive dependency resolution."""
|
||||
a = 'a.mojom'
|
||||
a_metadata = 'out/a.build_metadata'
|
||||
b = 'b.mojom'
|
||||
b_metadata = 'out/b.build_metadata'
|
||||
c = 'c.mojom'
|
||||
c_metadata = 'out/c.build_metadata'
|
||||
self.WriteFile(a_metadata,
|
||||
'{"sources": ["%s"], "deps": []}\n' % self.GetPath(a))
|
||||
self.WriteFile(
|
||||
b_metadata,
|
||||
'{"sources": ["%s"], "deps": ["%s"]}\n' % (self.GetPath(b),
|
||||
self.GetPath(a_metadata)))
|
||||
self.WriteFile(
|
||||
c_metadata,
|
||||
'{"sources": ["%s"], "deps": ["%s"]}\n' % (self.GetPath(c),
|
||||
self.GetPath(b_metadata)))
|
||||
self.WriteFile(a, """\
|
||||
module a;
|
||||
struct Bar {};""")
|
||||
self.WriteFile(
|
||||
b, """\
|
||||
module b;
|
||||
import "a.mojom";
|
||||
struct Foo { a.Bar bar; };""")
|
||||
self.WriteFile(
|
||||
c, """\
|
||||
module c;
|
||||
import "a.mojom";
|
||||
import "b.mojom";
|
||||
struct Baz { b.Foo foo; };""")
|
||||
self.ParseMojoms([a], metadata=a_metadata)
|
||||
self.ParseMojoms([b], metadata=b_metadata)
|
||||
self.ParseMojoms([c], metadata=c_metadata)
|
||||
|
||||
def testCheckImportsMissing(self):
|
||||
"""Verify that the parser rejects valid input mojoms when imports don't
|
||||
agree with build metadata given via --check-imports."""
|
||||
a = 'a.mojom'
|
||||
a_metadata = 'out/a.build_metadata'
|
||||
b = 'b.mojom'
|
||||
b_metadata = 'out/b.build_metadata'
|
||||
self.WriteFile(a_metadata,
|
||||
'{"sources": ["%s"], "deps": []}\n' % self.GetPath(a))
|
||||
self.WriteFile(b_metadata,
|
||||
'{"sources": ["%s"], "deps": []}\n' % self.GetPath(b))
|
||||
self.WriteFile(a, """\
|
||||
module a;
|
||||
struct Bar {};""")
|
||||
self.WriteFile(
|
||||
b, """\
|
||||
module b;
|
||||
import "a.mojom";
|
||||
struct Foo { a.Bar bar; };""")
|
||||
|
||||
self.ParseMojoms([a], metadata=a_metadata)
|
||||
with self.assertRaisesRegexp(ValueError, "not allowed by build"):
|
||||
self.ParseMojoms([b], metadata=b_metadata)
|
||||
127
utils/ipc/mojo/public/tools/mojom/stable_attribute_unittest.py
Normal file
127
utils/ipc/mojo/public/tools/mojom/stable_attribute_unittest.py
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
# Copyright 2020 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.
|
||||
|
||||
from mojom_parser_test_case import MojomParserTestCase
|
||||
|
||||
from mojom.generate import module
|
||||
|
||||
|
||||
class StableAttributeTest(MojomParserTestCase):
|
||||
"""Tests covering usage of the [Stable] attribute."""
|
||||
|
||||
def testStableAttributeTagging(self):
|
||||
"""Verify that we recognize the [Stable] attribute on relevant definitions
|
||||
and the resulting parser outputs are tagged accordingly."""
|
||||
mojom = 'test.mojom'
|
||||
self.WriteFile(
|
||||
mojom, """\
|
||||
[Stable] enum TestEnum { kFoo };
|
||||
enum UnstableEnum { kBar };
|
||||
[Stable] struct TestStruct { TestEnum a; };
|
||||
struct UnstableStruct { UnstableEnum a; };
|
||||
[Stable] union TestUnion { TestEnum a; TestStruct b; };
|
||||
union UnstableUnion { UnstableEnum a; UnstableStruct b; };
|
||||
[Stable] interface TestInterface { Foo@0(TestUnion x) => (); };
|
||||
interface UnstableInterface { Foo(UnstableUnion x) => (); };
|
||||
""")
|
||||
self.ParseMojoms([mojom])
|
||||
|
||||
m = self.LoadModule(mojom)
|
||||
self.assertEqual(2, len(m.enums))
|
||||
self.assertTrue(m.enums[0].stable)
|
||||
self.assertFalse(m.enums[1].stable)
|
||||
self.assertEqual(2, len(m.structs))
|
||||
self.assertTrue(m.structs[0].stable)
|
||||
self.assertFalse(m.structs[1].stable)
|
||||
self.assertEqual(2, len(m.unions))
|
||||
self.assertTrue(m.unions[0].stable)
|
||||
self.assertFalse(m.unions[1].stable)
|
||||
self.assertEqual(2, len(m.interfaces))
|
||||
self.assertTrue(m.interfaces[0].stable)
|
||||
self.assertFalse(m.interfaces[1].stable)
|
||||
|
||||
def testStableStruct(self):
|
||||
"""A [Stable] struct is valid if all its fields are also stable."""
|
||||
self.ExtractTypes('[Stable] struct S {};')
|
||||
self.ExtractTypes('[Stable] struct S { int32 x; bool b; };')
|
||||
self.ExtractTypes('[Stable] enum E { A }; [Stable] struct S { E e; };')
|
||||
self.ExtractTypes('[Stable] struct S {}; [Stable] struct T { S s; };')
|
||||
self.ExtractTypes(
|
||||
'[Stable] struct S {}; [Stable] struct T { array<S> ss; };')
|
||||
self.ExtractTypes(
|
||||
'[Stable] interface F {}; [Stable] struct T { pending_remote<F> f; };')
|
||||
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on E'):
|
||||
self.ExtractTypes('enum E { A }; [Stable] struct S { E e; };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on X'):
|
||||
self.ExtractTypes('struct X {}; [Stable] struct S { X x; };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on T'):
|
||||
self.ExtractTypes('struct T {}; [Stable] struct S { array<T> xs; };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on T'):
|
||||
self.ExtractTypes('struct T {}; [Stable] struct S { map<int32, T> xs; };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on T'):
|
||||
self.ExtractTypes('struct T {}; [Stable] struct S { map<T, int32> xs; };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on F'):
|
||||
self.ExtractTypes(
|
||||
'interface F {}; [Stable] struct S { pending_remote<F> f; };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on F'):
|
||||
self.ExtractTypes(
|
||||
'interface F {}; [Stable] struct S { pending_receiver<F> f; };')
|
||||
|
||||
def testStableUnion(self):
|
||||
"""A [Stable] union is valid if all its fields' types are also stable."""
|
||||
self.ExtractTypes('[Stable] union U {};')
|
||||
self.ExtractTypes('[Stable] union U { int32 x; bool b; };')
|
||||
self.ExtractTypes('[Stable] enum E { A }; [Stable] union U { E e; };')
|
||||
self.ExtractTypes('[Stable] struct S {}; [Stable] union U { S s; };')
|
||||
self.ExtractTypes(
|
||||
'[Stable] struct S {}; [Stable] union U { array<S> ss; };')
|
||||
self.ExtractTypes(
|
||||
'[Stable] interface F {}; [Stable] union U { pending_remote<F> f; };')
|
||||
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on E'):
|
||||
self.ExtractTypes('enum E { A }; [Stable] union U { E e; };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on X'):
|
||||
self.ExtractTypes('struct X {}; [Stable] union U { X x; };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on T'):
|
||||
self.ExtractTypes('struct T {}; [Stable] union U { array<T> xs; };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on T'):
|
||||
self.ExtractTypes('struct T {}; [Stable] union U { map<int32, T> xs; };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on T'):
|
||||
self.ExtractTypes('struct T {}; [Stable] union U { map<T, int32> xs; };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on F'):
|
||||
self.ExtractTypes(
|
||||
'interface F {}; [Stable] union U { pending_remote<F> f; };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on F'):
|
||||
self.ExtractTypes(
|
||||
'interface F {}; [Stable] union U { pending_receiver<F> f; };')
|
||||
|
||||
def testStableInterface(self):
|
||||
"""A [Stable] interface is valid if all its methods' parameter types are
|
||||
stable, including response parameters where applicable."""
|
||||
self.ExtractTypes('[Stable] interface F {};')
|
||||
self.ExtractTypes('[Stable] interface F { A@0(int32 x); };')
|
||||
self.ExtractTypes('[Stable] interface F { A@0(int32 x) => (bool b); };')
|
||||
self.ExtractTypes("""\
|
||||
[Stable] enum E { A, B, C };
|
||||
[Stable] struct S {};
|
||||
[Stable] interface F { A@0(E e, S s) => (bool b, array<S> s); };
|
||||
""")
|
||||
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on E'):
|
||||
self.ExtractTypes(
|
||||
'enum E { A, B, C }; [Stable] interface F { A@0(E e); };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on E'):
|
||||
self.ExtractTypes(
|
||||
'enum E { A, B, C }; [Stable] interface F { A@0(int32 x) => (E e); };'
|
||||
)
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on S'):
|
||||
self.ExtractTypes(
|
||||
'struct S {}; [Stable] interface F { A@0(int32 x) => (S s); };')
|
||||
with self.assertRaisesRegexp(Exception, 'because it depends on S'):
|
||||
self.ExtractTypes(
|
||||
'struct S {}; [Stable] interface F { A@0(S s) => (bool b); };')
|
||||
|
||||
with self.assertRaisesRegexp(Exception, 'explicit method ordinals'):
|
||||
self.ExtractTypes('[Stable] interface F { A() => (); };')
|
||||
|
|
@ -0,0 +1,397 @@
|
|||
# Copyright 2020 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.
|
||||
|
||||
from mojom_parser_test_case import MojomParserTestCase
|
||||
|
||||
|
||||
class VersionCompatibilityTest(MojomParserTestCase):
|
||||
"""Tests covering compatibility between two versions of the same mojom type
|
||||
definition. This coverage ensures that we can reliably detect unsafe changes
|
||||
to definitions that are expected to tolerate version skew in production
|
||||
environments."""
|
||||
|
||||
def _GetTypeCompatibilityMap(self, old_mojom, new_mojom):
|
||||
"""Helper to support the implementation of assertBackwardCompatible and
|
||||
assertNotBackwardCompatible."""
|
||||
|
||||
old = self.ExtractTypes(old_mojom)
|
||||
new = self.ExtractTypes(new_mojom)
|
||||
self.assertEqual(set(old.keys()), set(new.keys()),
|
||||
'Old and new test mojoms should use the same type names.')
|
||||
|
||||
compatibility_map = {}
|
||||
for name in old.keys():
|
||||
compatibility_map[name] = new[name].IsBackwardCompatible(old[name])
|
||||
return compatibility_map
|
||||
|
||||
def assertBackwardCompatible(self, old_mojom, new_mojom):
|
||||
compatibility_map = self._GetTypeCompatibilityMap(old_mojom, new_mojom)
|
||||
for name, compatible in compatibility_map.items():
|
||||
if not compatible:
|
||||
raise AssertionError(
|
||||
'Given the old mojom:\n\n %s\n\nand the new mojom:\n\n %s\n\n'
|
||||
'The new definition of %s should pass a backward-compatibiity '
|
||||
'check, but it does not.' % (old_mojom, new_mojom, name))
|
||||
|
||||
def assertNotBackwardCompatible(self, old_mojom, new_mojom):
|
||||
compatibility_map = self._GetTypeCompatibilityMap(old_mojom, new_mojom)
|
||||
if all(compatibility_map.values()):
|
||||
raise AssertionError(
|
||||
'Given the old mojom:\n\n %s\n\nand the new mojom:\n\n %s\n\n'
|
||||
'The new mojom should fail a backward-compatibility check, but it '
|
||||
'does not.' % (old_mojom, new_mojom))
|
||||
|
||||
def testNewNonExtensibleEnumValue(self):
|
||||
"""Adding a value to a non-extensible enum breaks backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('enum E { kFoo, kBar };',
|
||||
'enum E { kFoo, kBar, kBaz };')
|
||||
|
||||
def testNewNonExtensibleEnumValueWithMinVersion(self):
|
||||
"""Adding a value to a non-extensible enum breaks backward-compatibility,
|
||||
even with a new [MinVersion] specified for the value."""
|
||||
self.assertNotBackwardCompatible(
|
||||
'enum E { kFoo, kBar };', 'enum E { kFoo, kBar, [MinVersion=1] kBaz };')
|
||||
|
||||
def testNewValueInExistingVersion(self):
|
||||
"""Adding a value to an existing version is not allowed, even if the old
|
||||
enum was marked [Extensible]. Note that it is irrelevant whether or not the
|
||||
new enum is marked [Extensible]."""
|
||||
self.assertNotBackwardCompatible('[Extensible] enum E { kFoo, kBar };',
|
||||
'enum E { kFoo, kBar, kBaz };')
|
||||
self.assertNotBackwardCompatible(
|
||||
'[Extensible] enum E { kFoo, kBar };',
|
||||
'[Extensible] enum E { kFoo, kBar, kBaz };')
|
||||
self.assertNotBackwardCompatible(
|
||||
'[Extensible] enum E { kFoo, [MinVersion=1] kBar };',
|
||||
'enum E { kFoo, [MinVersion=1] kBar, [MinVersion=1] kBaz };')
|
||||
|
||||
def testEnumValueRemoval(self):
|
||||
"""Removal of an enum value is never valid even for [Extensible] enums."""
|
||||
self.assertNotBackwardCompatible('enum E { kFoo, kBar };',
|
||||
'enum E { kFoo };')
|
||||
self.assertNotBackwardCompatible('[Extensible] enum E { kFoo, kBar };',
|
||||
'[Extensible] enum E { kFoo };')
|
||||
self.assertNotBackwardCompatible(
|
||||
'[Extensible] enum E { kA, [MinVersion=1] kB };',
|
||||
'[Extensible] enum E { kA, };')
|
||||
self.assertNotBackwardCompatible(
|
||||
'[Extensible] enum E { kA, [MinVersion=1] kB, [MinVersion=1] kZ };',
|
||||
'[Extensible] enum E { kA, [MinVersion=1] kB };')
|
||||
|
||||
def testNewExtensibleEnumValueWithMinVersion(self):
|
||||
"""Adding a new and properly [MinVersion]'d value to an [Extensible] enum
|
||||
is a backward-compatible change. Note that it is irrelevant whether or not
|
||||
the new enum is marked [Extensible]."""
|
||||
self.assertBackwardCompatible('[Extensible] enum E { kA, kB };',
|
||||
'enum E { kA, kB, [MinVersion=1] kC };')
|
||||
self.assertBackwardCompatible(
|
||||
'[Extensible] enum E { kA, kB };',
|
||||
'[Extensible] enum E { kA, kB, [MinVersion=1] kC };')
|
||||
self.assertBackwardCompatible(
|
||||
'[Extensible] enum E { kA, [MinVersion=1] kB };',
|
||||
'[Extensible] enum E { kA, [MinVersion=1] kB, [MinVersion=2] kC };')
|
||||
|
||||
def testRenameEnumValue(self):
|
||||
"""Renaming an enum value does not affect backward-compatibility. Only
|
||||
numeric value is relevant."""
|
||||
self.assertBackwardCompatible('enum E { kA, kB };', 'enum E { kX, kY };')
|
||||
|
||||
def testAddEnumValueAlias(self):
|
||||
"""Adding new enum fields does not affect backward-compatibility if it does
|
||||
not introduce any new numeric values."""
|
||||
self.assertBackwardCompatible(
|
||||
'enum E { kA, kB };', 'enum E { kA, kB, kC = kA, kD = 1, kE = kD };')
|
||||
|
||||
def testEnumIdentity(self):
|
||||
"""An unchanged enum is obviously backward-compatible."""
|
||||
self.assertBackwardCompatible('enum E { kA, kB, kC };',
|
||||
'enum E { kA, kB, kC };')
|
||||
|
||||
def testNewStructFieldUnversioned(self):
|
||||
"""Adding a new field to a struct without a new (i.e. higher than any
|
||||
existing version) [MinVersion] tag breaks backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('struct S { string a; };',
|
||||
'struct S { string a; string b; };')
|
||||
|
||||
def testStructFieldRemoval(self):
|
||||
"""Removing a field from a struct breaks backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('struct S { string a; string b; };',
|
||||
'struct S { string a; };')
|
||||
|
||||
def testStructFieldTypeChange(self):
|
||||
"""Changing the type of an existing field always breaks
|
||||
backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('struct S { string a; };',
|
||||
'struct S { array<int32> a; };')
|
||||
|
||||
def testStructFieldBecomingOptional(self):
|
||||
"""Changing a field from non-optional to optional breaks
|
||||
backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('struct S { string a; };',
|
||||
'struct S { string? a; };')
|
||||
|
||||
def testStructFieldBecomingNonOptional(self):
|
||||
"""Changing a field from optional to non-optional breaks
|
||||
backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('struct S { string? a; };',
|
||||
'struct S { string a; };')
|
||||
|
||||
def testStructFieldOrderChange(self):
|
||||
"""Changing the order of fields breaks backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('struct S { string a; bool b; };',
|
||||
'struct S { bool b; string a; };')
|
||||
self.assertNotBackwardCompatible('struct S { string a@0; bool b@1; };',
|
||||
'struct S { string a@1; bool b@0; };')
|
||||
|
||||
def testStructFieldMinVersionChange(self):
|
||||
"""Changing the MinVersion of a field breaks backward-compatibility."""
|
||||
self.assertNotBackwardCompatible(
|
||||
'struct S { string a; [MinVersion=1] string? b; };',
|
||||
'struct S { string a; [MinVersion=2] string? b; };')
|
||||
|
||||
def testStructFieldTypeChange(self):
|
||||
"""If a struct field's own type definition changes, the containing struct
|
||||
is backward-compatible if and only if the field type's change is
|
||||
backward-compatible."""
|
||||
self.assertBackwardCompatible(
|
||||
'struct S {}; struct T { S s; };',
|
||||
'struct S { [MinVersion=1] int32 x; }; struct T { S s; };')
|
||||
self.assertBackwardCompatible(
|
||||
'[Extensible] enum E { kA }; struct S { E e; };',
|
||||
'[Extensible] enum E { kA, [MinVersion=1] kB }; struct S { E e; };')
|
||||
self.assertNotBackwardCompatible(
|
||||
'struct S {}; struct T { S s; };',
|
||||
'struct S { int32 x; }; struct T { S s; };')
|
||||
self.assertNotBackwardCompatible(
|
||||
'[Extensible] enum E { kA }; struct S { E e; };',
|
||||
'[Extensible] enum E { kA, kB }; struct S { E e; };')
|
||||
|
||||
def testNewStructFieldWithInvalidMinVersion(self):
|
||||
"""Adding a new field using an existing MinVersion breaks backward-
|
||||
compatibility."""
|
||||
self.assertNotBackwardCompatible(
|
||||
"""\
|
||||
struct S {
|
||||
string a;
|
||||
[MinVersion=1] string? b;
|
||||
};
|
||||
""", """\
|
||||
struct S {
|
||||
string a;
|
||||
[MinVersion=1] string? b;
|
||||
[MinVersion=1] string? c;
|
||||
};""")
|
||||
|
||||
def testNewStructFieldWithValidMinVersion(self):
|
||||
"""Adding a new field is safe if tagged with a MinVersion greater than any
|
||||
previously used MinVersion in the struct."""
|
||||
self.assertBackwardCompatible(
|
||||
'struct S { int32 a; };',
|
||||
'struct S { int32 a; [MinVersion=1] int32 b; };')
|
||||
self.assertBackwardCompatible(
|
||||
'struct S { int32 a; [MinVersion=1] int32 b; };',
|
||||
'struct S { int32 a; [MinVersion=1] int32 b; [MinVersion=2] bool c; };')
|
||||
|
||||
def testNewStructFieldNullableReference(self):
|
||||
"""Adding a new nullable reference-typed field is fine if versioned
|
||||
properly."""
|
||||
self.assertBackwardCompatible(
|
||||
'struct S { int32 a; };',
|
||||
'struct S { int32 a; [MinVersion=1] string? b; };')
|
||||
|
||||
def testStructFieldRename(self):
|
||||
"""Renaming a field has no effect on backward-compatibility."""
|
||||
self.assertBackwardCompatible('struct S { int32 x; bool b; };',
|
||||
'struct S { int32 a; bool b; };')
|
||||
|
||||
def testStructFieldReorderWithExplicitOrdinals(self):
|
||||
"""Reordering fields has no effect on backward-compatibility when field
|
||||
ordinals are explicitly labeled and remain unchanged."""
|
||||
self.assertBackwardCompatible('struct S { bool b@1; int32 a@0; };',
|
||||
'struct S { int32 a@0; bool b@1; };')
|
||||
|
||||
def testNewUnionFieldUnversioned(self):
|
||||
"""Adding a new field to a union without a new (i.e. higher than any
|
||||
existing version) [MinVersion] tag breaks backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('union U { string a; };',
|
||||
'union U { string a; string b; };')
|
||||
|
||||
def testUnionFieldRemoval(self):
|
||||
"""Removing a field from a union breaks backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('union U { string a; string b; };',
|
||||
'union U { string a; };')
|
||||
|
||||
def testUnionFieldTypeChange(self):
|
||||
"""Changing the type of an existing field always breaks
|
||||
backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('union U { string a; };',
|
||||
'union U { array<int32> a; };')
|
||||
|
||||
def testUnionFieldBecomingOptional(self):
|
||||
"""Changing a field from non-optional to optional breaks
|
||||
backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('union U { string a; };',
|
||||
'union U { string? a; };')
|
||||
|
||||
def testUnionFieldBecomingNonOptional(self):
|
||||
"""Changing a field from optional to non-optional breaks
|
||||
backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('union U { string? a; };',
|
||||
'union U { string a; };')
|
||||
|
||||
def testUnionFieldOrderChange(self):
|
||||
"""Changing the order of fields breaks backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('union U { string a; bool b; };',
|
||||
'union U { bool b; string a; };')
|
||||
self.assertNotBackwardCompatible('union U { string a@0; bool b@1; };',
|
||||
'union U { string a@1; bool b@0; };')
|
||||
|
||||
def testUnionFieldMinVersionChange(self):
|
||||
"""Changing the MinVersion of a field breaks backward-compatibility."""
|
||||
self.assertNotBackwardCompatible(
|
||||
'union U { string a; [MinVersion=1] string b; };',
|
||||
'union U { string a; [MinVersion=2] string b; };')
|
||||
|
||||
def testUnionFieldTypeChange(self):
|
||||
"""If a union field's own type definition changes, the containing union
|
||||
is backward-compatible if and only if the field type's change is
|
||||
backward-compatible."""
|
||||
self.assertBackwardCompatible(
|
||||
'struct S {}; union U { S s; };',
|
||||
'struct S { [MinVersion=1] int32 x; }; union U { S s; };')
|
||||
self.assertBackwardCompatible(
|
||||
'[Extensible] enum E { kA }; union U { E e; };',
|
||||
'[Extensible] enum E { kA, [MinVersion=1] kB }; union U { E e; };')
|
||||
self.assertNotBackwardCompatible(
|
||||
'struct S {}; union U { S s; };',
|
||||
'struct S { int32 x; }; union U { S s; };')
|
||||
self.assertNotBackwardCompatible(
|
||||
'[Extensible] enum E { kA }; union U { E e; };',
|
||||
'[Extensible] enum E { kA, kB }; union U { E e; };')
|
||||
|
||||
def testNewUnionFieldWithInvalidMinVersion(self):
|
||||
"""Adding a new field using an existing MinVersion breaks backward-
|
||||
compatibility."""
|
||||
self.assertNotBackwardCompatible(
|
||||
"""\
|
||||
union U {
|
||||
string a;
|
||||
[MinVersion=1] string b;
|
||||
};
|
||||
""", """\
|
||||
union U {
|
||||
string a;
|
||||
[MinVersion=1] string b;
|
||||
[MinVersion=1] string c;
|
||||
};""")
|
||||
|
||||
def testNewUnionFieldWithValidMinVersion(self):
|
||||
"""Adding a new field is safe if tagged with a MinVersion greater than any
|
||||
previously used MinVersion in the union."""
|
||||
self.assertBackwardCompatible(
|
||||
'union U { int32 a; };',
|
||||
'union U { int32 a; [MinVersion=1] int32 b; };')
|
||||
self.assertBackwardCompatible(
|
||||
'union U { int32 a; [MinVersion=1] int32 b; };',
|
||||
'union U { int32 a; [MinVersion=1] int32 b; [MinVersion=2] bool c; };')
|
||||
|
||||
def testUnionFieldRename(self):
|
||||
"""Renaming a field has no effect on backward-compatibility."""
|
||||
self.assertBackwardCompatible('union U { int32 x; bool b; };',
|
||||
'union U { int32 a; bool b; };')
|
||||
|
||||
def testUnionFieldReorderWithExplicitOrdinals(self):
|
||||
"""Reordering fields has no effect on backward-compatibility when field
|
||||
ordinals are explicitly labeled and remain unchanged."""
|
||||
self.assertBackwardCompatible('union U { bool b@1; int32 a@0; };',
|
||||
'union U { int32 a@0; bool b@1; };')
|
||||
|
||||
def testNewInterfaceMethodUnversioned(self):
|
||||
"""Adding a new method to an interface without a new (i.e. higher than any
|
||||
existing version) [MinVersion] tag breaks backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('interface F { A(); };',
|
||||
'interface F { A(); B(); };')
|
||||
|
||||
def testInterfaceMethodRemoval(self):
|
||||
"""Removing a method from an interface breaks backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('interface F { A(); B(); };',
|
||||
'interface F { A(); };')
|
||||
|
||||
def testInterfaceMethodParamsChanged(self):
|
||||
"""Changes to the parameter list are only backward-compatible if they meet
|
||||
backward-compatibility requirements of an equivalent struct definition."""
|
||||
self.assertNotBackwardCompatible('interface F { A(); };',
|
||||
'interface F { A(int32 x); };')
|
||||
self.assertNotBackwardCompatible('interface F { A(int32 x); };',
|
||||
'interface F { A(bool x); };')
|
||||
self.assertNotBackwardCompatible(
|
||||
'interface F { A(int32 x, [MinVersion=1] string? s); };', """\
|
||||
interface F {
|
||||
A(int32 x, [MinVersion=1] string? s, [MinVersion=1] int32 y);
|
||||
};""")
|
||||
|
||||
self.assertBackwardCompatible('interface F { A(int32 x); };',
|
||||
'interface F { A(int32 a); };')
|
||||
self.assertBackwardCompatible(
|
||||
'interface F { A(int32 x); };',
|
||||
'interface F { A(int32 x, [MinVersion=1] string? s); };')
|
||||
|
||||
self.assertBackwardCompatible(
|
||||
'struct S {}; interface F { A(S s); };',
|
||||
'struct S { [MinVersion=1] int32 x; }; interface F { A(S s); };')
|
||||
self.assertBackwardCompatible(
|
||||
'struct S {}; struct T {}; interface F { A(S s); };',
|
||||
'struct S {}; struct T {}; interface F { A(T s); };')
|
||||
self.assertNotBackwardCompatible(
|
||||
'struct S {}; struct T { int32 x; }; interface F { A(S s); };',
|
||||
'struct S {}; struct T { int32 x; }; interface F { A(T t); };')
|
||||
|
||||
def testInterfaceMethodReplyAdded(self):
|
||||
"""Adding a reply to a message breaks backward-compatibilty."""
|
||||
self.assertNotBackwardCompatible('interface F { A(); };',
|
||||
'interface F { A() => (); };')
|
||||
|
||||
def testInterfaceMethodReplyRemoved(self):
|
||||
"""Removing a reply from a message breaks backward-compatibility."""
|
||||
self.assertNotBackwardCompatible('interface F { A() => (); };',
|
||||
'interface F { A(); };')
|
||||
|
||||
def testInterfaceMethodReplyParamsChanged(self):
|
||||
"""Similar to request parameters, a change to reply parameters is considered
|
||||
backward-compatible if it meets the same backward-compatibility
|
||||
requirements imposed on equivalent struct changes."""
|
||||
self.assertNotBackwardCompatible('interface F { A() => (); };',
|
||||
'interface F { A() => (int32 x); };')
|
||||
self.assertNotBackwardCompatible('interface F { A() => (int32 x); };',
|
||||
'interface F { A() => (); };')
|
||||
self.assertNotBackwardCompatible('interface F { A() => (bool x); };',
|
||||
'interface F { A() => (int32 x); };')
|
||||
|
||||
self.assertBackwardCompatible('interface F { A() => (int32 a); };',
|
||||
'interface F { A() => (int32 x); };')
|
||||
self.assertBackwardCompatible(
|
||||
'interface F { A() => (int32 x); };',
|
||||
'interface F { A() => (int32 x, [MinVersion] string? s); };')
|
||||
|
||||
def testNewInterfaceMethodWithInvalidMinVersion(self):
|
||||
"""Adding a new method to an existing version is not backward-compatible."""
|
||||
self.assertNotBackwardCompatible(
|
||||
"""\
|
||||
interface F {
|
||||
A();
|
||||
[MinVersion=1] B();
|
||||
};
|
||||
""", """\
|
||||
interface F {
|
||||
A();
|
||||
[MinVersion=1] B();
|
||||
[MinVersion=1] C();
|
||||
};
|
||||
""")
|
||||
|
||||
def testNewInterfaceMethodWithValidMinVersion(self):
|
||||
"""Adding a new method is fine as long as its MinVersion exceeds that of any
|
||||
method on the old interface definition."""
|
||||
self.assertBackwardCompatible('interface F { A(); };',
|
||||
'interface F { A(); [MinVersion=1] B(); };')
|
||||
28
utils/ipc/mojo/public/tools/run_all_python_unittests.py
Executable file
28
utils/ipc/mojo/public/tools/run_all_python_unittests.py
Executable file
|
|
@ -0,0 +1,28 @@
|
|||
#!/usr/bin/env python
|
||||
# Copyright 2020 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 os.path
|
||||
import sys
|
||||
|
||||
_TOOLS_DIR = os.path.dirname(__file__)
|
||||
_MOJOM_DIR = os.path.join(_TOOLS_DIR, 'mojom')
|
||||
_SRC_DIR = os.path.join(_TOOLS_DIR, os.path.pardir, os.path.pardir,
|
||||
os.path.pardir)
|
||||
|
||||
# Ensure that the mojom library is discoverable.
|
||||
sys.path.append(_MOJOM_DIR)
|
||||
|
||||
# Help Python find typ in //third_party/catapult/third_party/typ/
|
||||
sys.path.append(
|
||||
os.path.join(_SRC_DIR, 'third_party', 'catapult', 'third_party', 'typ'))
|
||||
import typ
|
||||
|
||||
|
||||
def Main():
|
||||
return typ.main(top_level_dir=_MOJOM_DIR)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(Main())
|
||||
51
utils/ipc/tools/diagnosis/crbug_1001171.py
Normal file
51
utils/ipc/tools/diagnosis/crbug_1001171.py
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
# Copyright 2019 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.
|
||||
|
||||
"""Helper context wrapper for diagnosing crbug.com/1001171.
|
||||
|
||||
This module and all uses thereof can and should be removed once
|
||||
crbug.com/1001171 has been resolved.
|
||||
"""
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import contextlib
|
||||
import os
|
||||
import sys
|
||||
|
||||
|
||||
@contextlib.contextmanager
|
||||
def DumpStateOnLookupError():
|
||||
"""Prints potentially useful state info in the event of a LookupError."""
|
||||
try:
|
||||
yield
|
||||
except LookupError:
|
||||
print('LookupError diagnosis for crbug.com/1001171:')
|
||||
for path_index, path_entry in enumerate(sys.path):
|
||||
desc = 'unknown'
|
||||
if not os.path.exists(path_entry):
|
||||
desc = 'missing'
|
||||
elif os.path.islink(path_entry):
|
||||
desc = 'link -> %s' % os.path.realpath(path_entry)
|
||||
elif os.path.isfile(path_entry):
|
||||
desc = 'file'
|
||||
elif os.path.isdir(path_entry):
|
||||
desc = 'dir'
|
||||
print(' sys.path[%d]: %s (%s)' % (path_index, path_entry, desc))
|
||||
|
||||
real_path_entry = os.path.realpath(path_entry)
|
||||
if (path_entry.endswith(os.path.join('lib', 'python2.7'))
|
||||
and os.path.isdir(real_path_entry)):
|
||||
encodings_dir = os.path.realpath(
|
||||
os.path.join(real_path_entry, 'encodings'))
|
||||
if os.path.exists(encodings_dir):
|
||||
if os.path.isdir(encodings_dir):
|
||||
print(' %s contents: %s' % (encodings_dir,
|
||||
str(os.listdir(encodings_dir))))
|
||||
else:
|
||||
print(' %s exists but is not a directory' % encodings_dir)
|
||||
else:
|
||||
print(' %s missing' % encodings_dir)
|
||||
|
||||
raise
|
||||
Loading…
Add table
Add a link
Reference in a new issue