frida 16.2.1 → 16.2.2

package/releng/meson/mesonbuild/cargo/__init__.py

@@ -0,0 +1,5 @@
+__all__ = [
+    'interpret'
+]
+
+from .interpreter import interpret

package/releng/meson/mesonbuild/cargo/builder.py

@@ -0,0 +1,238 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright © 2022-2023 Intel Corporation
+
+"""Provides helpers for building AST
+
+This is meant to make building Meson AST from foreign (largely declarative)
+build descriptions easier.
+"""
+
+from __future__ import annotations
+import dataclasses
+import typing as T
+
+from .. import mparser
+
+if T.TYPE_CHECKING:
+    import builtins
+
+
+@dataclasses.dataclass
+class Builder:
+
+    filename: str
+
+    def _token(self, tid: str, value: mparser.TV_TokenTypes) -> mparser.Token[mparser.TV_TokenTypes]:
+        """Create a Token object, but with the line numbers stubbed out.
+
+        :param tid: the token id (such as string, number, etc)
+        :param filename: the filename that the token was generated from
+        :param value: the value of the token
+        :return: A Token object
+        """
+        return mparser.Token(tid, self.filename, -1, -1, -1, (-1, -1), value)
+
+    def _symbol(self, val: str) -> mparser.SymbolNode:
+        return mparser.SymbolNode(self._token('', val))
+
+    def assign(self, value: mparser.BaseNode, varname: str) -> mparser.AssignmentNode:
+        return mparser.AssignmentNode(self.identifier(varname), self._symbol('='), value)
+
+    def string(self, value: str) -> mparser.StringNode:
+        """Build A StringNode
+
+        :param value: the value of the string
+        :return: A StringNode
+        """
+        return mparser.StringNode(self._token('string', value))
+
+    def number(self, value: int) -> mparser.NumberNode:
+        """Build A NumberNode
+
+        :param value: the value of the number
+        :return: A NumberNode
+        """
+        return mparser.NumberNode(self._token('number', str(value)))
+
+    def bool(self, value: builtins.bool) -> mparser.BooleanNode:
+        """Build A BooleanNode
+
+        :param value: the value of the boolean
+        :return: A BooleanNode
+        """
+        return mparser.BooleanNode(self._token('bool', value))
+
+    def array(self, value: T.List[mparser.BaseNode]) -> mparser.ArrayNode:
+        """Build an Array Node
+
+        :param value: A list of nodes to insert into the array
+        :return: An ArrayNode built from the arguments
+        """
+        args = mparser.ArgumentNode(self._token('array', 'unused'))
+        args.arguments = value
+        return mparser.ArrayNode(self._symbol('['), args, self._symbol(']'))
+
+    def dict(self, value: T.Dict[mparser.BaseNode, mparser.BaseNode]) -> mparser.DictNode:
+        """Build an Dictionary Node
+
+        :param value: A dict of nodes to insert into the dictionary
+        :return: An DictNode built from the arguments
+        """
+        args = mparser.ArgumentNode(self._token('dict', 'unused'))
+        for key, val in value.items():
+            args.set_kwarg_no_check(key, val)
+        return mparser.DictNode(self._symbol('{'), args, self._symbol('}'))
+
+    def identifier(self, value: str) -> mparser.IdNode:
+        """Build A IdNode
+
+        :param value: the value of the boolean
+        :return: A BooleanNode
+        """
+        return mparser.IdNode(self._token('id', value))
+
+    def method(self, name: str, id_: mparser.BaseNode,
+               pos: T.Optional[T.List[mparser.BaseNode]] = None,
+               kw: T.Optional[T.Mapping[str, mparser.BaseNode]] = None,
+               ) -> mparser.MethodNode:
+        """Create a method call.
+
+        :param name: the name of the method
+        :param id_: the object to call the method of
+        :param pos: a list of positional arguments, defaults to None
+        :param kw: a dictionary of keyword arguments, defaults to None
+        :return: a method call object
+        """
+        args = mparser.ArgumentNode(self._token('array', 'unused'))
+        if pos is not None:
+            args.arguments = pos
+        if kw is not None:
+            args.kwargs = {self.identifier(k): v for k, v in kw.items()}
+        return mparser.MethodNode(id_, self._symbol('.'), self.identifier(name), self._symbol('('), args, self._symbol(')'))
+
+    def function(self, name: str,
+                 pos: T.Optional[T.List[mparser.BaseNode]] = None,
+                 kw: T.Optional[T.Mapping[str, mparser.BaseNode]] = None,
+                 ) -> mparser.FunctionNode:
+        """Create a function call.
+
+        :param name: the name of the function
+        :param pos: a list of positional arguments, defaults to None
+        :param kw: a dictionary of keyword arguments, defaults to None
+        :return: a method call object
+        """
+        args = mparser.ArgumentNode(self._token('array', 'unused'))
+        if pos is not None:
+            args.arguments = pos
+        if kw is not None:
+            args.kwargs = {self.identifier(k): v for k, v in kw.items()}
+        return mparser.FunctionNode(self.identifier(name), self._symbol('('), args, self._symbol(')'))
+
+    def equal(self, lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.ComparisonNode:
+        """Create an equality operation
+
+        :param lhs: The left hand side of the equal
+        :param rhs: the right hand side of the equal
+        :return: A compraison node
+        """
+        return mparser.ComparisonNode('==', lhs, self._symbol('=='), rhs)
+
+    def not_equal(self, lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.ComparisonNode:
+        """Create an inequality operation
+
+        :param lhs: The left hand side of the "!="
+        :param rhs: the right hand side of the "!="
+        :return: A compraison node
+        """
+        return mparser.ComparisonNode('!=', lhs, self._symbol('!='), rhs)
+
+    def in_(self, lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.ComparisonNode:
+        """Create an "in" operation
+
+        :param lhs: The left hand side of the "in"
+        :param rhs: the right hand side of the "in"
+        :return: A compraison node
+        """
+        return mparser.ComparisonNode('in', lhs, self._symbol('in'), rhs)
+
+    def not_in(self, lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.ComparisonNode:
+        """Create an "not in" operation
+
+        :param lhs: The left hand side of the "not in"
+        :param rhs: the right hand side of the "not in"
+        :return: A compraison node
+        """
+        return mparser.ComparisonNode('notin', lhs, self._symbol('not in'), rhs)
+
+    def or_(self, lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.OrNode:
+        """Create and OrNode
+
+        :param lhs: The Left of the Node
+        :param rhs: The Right of the Node
+        :return: The OrNode
+        """
+        return mparser.OrNode(lhs, self._symbol('or'), rhs)
+
+    def and_(self, lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.AndNode:
+        """Create an AndNode
+
+        :param lhs: The left of the And
+        :param rhs: The right of the And
+        :return: The AndNode
+        """
+        return mparser.AndNode(lhs, self._symbol('and'), rhs)
+
+    def not_(self, value: mparser.BaseNode) -> mparser.NotNode:
+        """Create a not node
+
+        :param value: The value to negate
+        :return: The NotNode
+        """
+        return mparser.NotNode(self._token('not', ''), self._symbol('not'), value)
+
+    def block(self, lines: T.List[mparser.BaseNode]) -> mparser.CodeBlockNode:
+        block = mparser.CodeBlockNode(self._token('node', ''))
+        block.lines = lines
+        return block
+
+    def plus(self, lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.ArithmeticNode:
+        """Create an addition node
+
+        :param lhs: The left of the addition
+        :param rhs: The right of the addition
+        :return: The ArithmeticNode
+        """
+        return mparser.ArithmeticNode('add', lhs, self._symbol('+'), rhs)
+
+    def plusassign(self, value: mparser.BaseNode, varname: str) -> mparser.PlusAssignmentNode:
+        """Create a "+=" node
+
+        :param value: The value to add
+        :param varname: The variable to assign
+        :return: The PlusAssignmentNode
+        """
+        return mparser.PlusAssignmentNode(self.identifier(varname), self._symbol('+='), value)
+
+    def if_(self, condition: mparser.BaseNode, block: mparser.CodeBlockNode) -> mparser.IfClauseNode:
+        """Create a "if" block
+
+        :param condition: The condition
+        :param block: Lines inside the condition
+        :return: The IfClauseNode
+        """
+        clause = mparser.IfClauseNode(condition)
+        clause.ifs.append(mparser.IfNode(clause, self._symbol('if'), condition, block))
+        clause.elseblock = mparser.EmptyNode(-1, -1, self.filename)
+        return clause
+
+    def foreach(self, varnames: T.List[str], items: mparser.BaseNode, block: mparser.CodeBlockNode) -> mparser.ForeachClauseNode:
+        """Create a "foreach" loop
+
+        :param varnames: Iterator variable names (one for list, two for dict).
+        :param items: The list of dict to iterate
+        :param block: Lines inside the loop
+        :return: The ForeachClauseNode
+        """
+        varids = [self.identifier(i) for i in varnames]
+        commas = [self._symbol(',') for i in range(len(varnames) - 1)]
+        return mparser.ForeachClauseNode(self._symbol('foreach'), varids, commas, self._symbol(':'), items, block, self._symbol('endforeach'))

package/releng/meson/mesonbuild/cargo/cfg.py

@@ -0,0 +1,274 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright © 2022-2023 Intel Corporation
+
+"""Rust CFG parser.
+
+Rust uses its `cfg()` format in cargo.
+
+This may have the following functions:
+ - all()
+ - any()
+ - not()
+
+And additionally is made up of `identifier [ = str]`. Where the str is optional,
+so you could have examples like:
+```
+[target.`cfg(unix)`.dependencies]
+[target.'cfg(target_arch = "x86_64")'.dependencies]
+[target.'cfg(all(target_arch = "x86_64", target_arch = "x86"))'.dependencies]
+```
+"""
+
+from __future__ import annotations
+import dataclasses
+import enum
+import functools
+import typing as T
+
+
+from . import builder
+from .. import mparser
+from ..mesonlib import MesonBugException
+
+if T.TYPE_CHECKING:
+    _T = T.TypeVar('_T')
+    _LEX_TOKEN = T.Tuple['TokenType', T.Optional[str]]
+    _LEX_STREAM = T.Iterable[_LEX_TOKEN]
+    _LEX_STREAM_AH = T.Iterator[T.Tuple[_LEX_TOKEN, T.Optional[_LEX_TOKEN]]]
+
+
+class TokenType(enum.Enum):
+
+    LPAREN = enum.auto()
+    RPAREN = enum.auto()
+    STRING = enum.auto()
+    IDENTIFIER = enum.auto()
+    ALL = enum.auto()
+    ANY = enum.auto()
+    NOT = enum.auto()
+    COMMA = enum.auto()
+    EQUAL = enum.auto()
+
+
+def lexer(raw: str) -> _LEX_STREAM:
+    """Lex a cfg() expression.
+
+    :param raw: The raw cfg() expression
+    :return: An iterable of tokens
+    """
+    buffer: T.List[str] = []
+    is_string: bool = False
+    for s in raw:
+        if s.isspace() or s in {')', '(', ',', '='} or (s == '"' and buffer):
+            val = ''.join(buffer)
+            buffer.clear()
+            if is_string:
+                yield (TokenType.STRING, val)
+            elif val == 'any':
+                yield (TokenType.ANY, None)
+            elif val == 'all':
+                yield (TokenType.ALL, None)
+            elif val == 'not':
+                yield (TokenType.NOT, None)
+            elif val:
+                yield (TokenType.IDENTIFIER, val)
+
+            if s == '(':
+                yield (TokenType.LPAREN, None)
+                continue
+            elif s == ')':
+                yield (TokenType.RPAREN, None)
+                continue
+            elif s == ',':
+                yield (TokenType.COMMA, None)
+                continue
+            elif s == '=':
+                yield (TokenType.EQUAL, None)
+                continue
+            elif s.isspace():
+                continue
+
+        if s == '"':
+            is_string = not is_string
+        else:
+            buffer.append(s)
+    if buffer:
+        # This should always be an identifier
+        yield (TokenType.IDENTIFIER, ''.join(buffer))
+
+
+def lookahead(iter: T.Iterator[_T]) -> T.Iterator[T.Tuple[_T, T.Optional[_T]]]:
+    """Get the current value of the iterable, and the next if possible.
+
+    :param iter: The iterable to look into
+    :yield: A tuple of the current value, and, if possible, the next
+    :return: nothing
+    """
+    current: _T
+    next_: T.Optional[_T]
+    try:
+        next_ = next(iter)
+    except StopIteration:
+        # This is an empty iterator, there's nothing to look ahead to
+        return
+
+    while True:
+        current = next_
+        try:
+            next_ = next(iter)
+        except StopIteration:
+            next_ = None
+
+        yield current, next_
+
+        if next_ is None:
+            break
+
+
+@dataclasses.dataclass
+class IR:
+
+    """Base IR node for Cargo CFG."""
+
+
+@dataclasses.dataclass
+class String(IR):
+
+    value: str
+
+
+@dataclasses.dataclass
+class Identifier(IR):
+
+    value: str
+
+
+@dataclasses.dataclass
+class Equal(IR):
+
+    lhs: IR
+    rhs: IR
+
+
+@dataclasses.dataclass
+class Any(IR):
+
+    args: T.List[IR]
+
+
+@dataclasses.dataclass
+class All(IR):
+
+    args: T.List[IR]
+
+
+@dataclasses.dataclass
+class Not(IR):
+
+    value: IR
+
+
+def _parse(ast: _LEX_STREAM_AH) -> IR:
+    (token, value), n_stream = next(ast)
+    if n_stream is not None:
+        ntoken, _ = n_stream
+    else:
+        ntoken, _ = (None, None)
+
+    stream: T.List[_LEX_TOKEN]
+    if token is TokenType.IDENTIFIER:
+        if ntoken is TokenType.EQUAL:
+            return Equal(Identifier(value), _parse(ast))
+    if token is TokenType.STRING:
+        return String(value)
+    if token is TokenType.EQUAL:
+        # In this case the previous caller already has handled the equal
+        return _parse(ast)
+    if token in {TokenType.ANY, TokenType.ALL}:
+        type_ = All if token is TokenType.ALL else Any
+        assert ntoken is TokenType.LPAREN
+        next(ast)  # advance the iterator to get rid of the LPAREN
+        stream = []
+        args: T.List[IR] = []
+        while token is not TokenType.RPAREN:
+            (token, value), _ = next(ast)
+            if token is TokenType.COMMA:
+                args.append(_parse(lookahead(iter(stream))))
+                stream.clear()
+            else:
+                stream.append((token, value))
+        if stream:
+            args.append(_parse(lookahead(iter(stream))))
+        return type_(args)
+    if token is TokenType.NOT:
+        next(ast)  # advance the iterator to get rid of the LPAREN
+        stream = []
+        # Mypy can't figure out that token is overridden inside the while loop
+        while token is not TokenType.RPAREN:  # type: ignore
+            (token, value), _ = next(ast)
+            stream.append((token, value))
+        return Not(_parse(lookahead(iter(stream))))
+
+    raise MesonBugException(f'Unhandled Cargo token: {token}')
+
+
+def parse(ast: _LEX_STREAM) -> IR:
+    """Parse the tokenized list into Meson AST.
+
+    :param ast: An iterable of Tokens
+    :return: An mparser Node to be used as a conditional
+    """
+    ast_i: _LEX_STREAM_AH = lookahead(iter(ast))
+    return _parse(ast_i)
+
+
+@functools.singledispatch
+def ir_to_meson(ir: T.Any, build: builder.Builder) -> mparser.BaseNode:
+    raise NotImplementedError
+
+
+@ir_to_meson.register
+def _(ir: String, build: builder.Builder) -> mparser.BaseNode:
+    return build.string(ir.value)
+
+
+@ir_to_meson.register
+def _(ir: Identifier, build: builder.Builder) -> mparser.BaseNode:
+    host_machine = build.identifier('host_machine')
+    if ir.value == "target_arch":
+        return build.method('cpu_family', host_machine)
+    elif ir.value in {"target_os", "target_family"}:
+        return build.method('system', host_machine)
+    elif ir.value == "target_endian":
+        return build.method('endian', host_machine)
+    raise MesonBugException(f"Unhandled Cargo identifier: {ir.value}")
+
+
+@ir_to_meson.register
+def _(ir: Equal, build: builder.Builder) -> mparser.BaseNode:
+    return build.equal(ir_to_meson(ir.lhs, build), ir_to_meson(ir.rhs, build))
+
+
+@ir_to_meson.register
+def _(ir: Not, build: builder.Builder) -> mparser.BaseNode:
+    return build.not_(ir_to_meson(ir.value, build))
+
+
+@ir_to_meson.register
+def _(ir: Any, build: builder.Builder) -> mparser.BaseNode:
+    args = iter(reversed(ir.args))
+    last = next(args)
+    cur = build.or_(ir_to_meson(next(args), build), ir_to_meson(last, build))
+    for a in args:
+        cur = build.or_(ir_to_meson(a, build), cur)
+    return cur
+
+
+@ir_to_meson.register
+def _(ir: All, build: builder.Builder) -> mparser.BaseNode:
+    args = iter(reversed(ir.args))
+    last = next(args)
+    cur = build.and_(ir_to_meson(next(args), build), ir_to_meson(last, build))
+    for a in args:
+        cur = build.and_(ir_to_meson(a, build), cur)
+    return cur