sentence1 stringlengths 52 3.87M | sentence2 stringlengths 1 47.2k | label stringclasses 1
value |
|---|---|---|
def _pfp__is_non_consecutive_duplicate(self, name, child):
"""Return True/False if the child is a non-consecutive duplicately named
field. Consecutive duplicately-named fields are stored in an implicit array,
non-consecutive duplicately named fields have a numeric suffix appended to their name""... | Return True/False if the child is a non-consecutive duplicately named
field. Consecutive duplicately-named fields are stored in an implicit array,
non-consecutive duplicately named fields have a numeric suffix appended to their name | entailment |
def _pfp__handle_implicit_array(self, name, child):
"""Handle inserting implicit array elements
"""
existing_child = self._pfp__children_map[name]
if isinstance(existing_child, Array):
# I don't think we should check this
#
#if existing_child.field_cls... | Handle inserting implicit array elements | entailment |
def _pfp__parse(self, stream, save_offset=False):
"""Parse the incoming stream
:stream: Input stream to be parsed
:returns: Number of bytes parsed
"""
if save_offset:
self._pfp__offset = stream.tell()
res = 0
for child in self._pfp__children:
... | Parse the incoming stream
:stream: Input stream to be parsed
:returns: Number of bytes parsed | entailment |
def _pfp__build(self, stream=None, save_offset=False):
"""Build the field and write the result into the stream
:stream: An IO stream that can be written to
:returns: None
"""
if save_offset and stream is not None:
self._pfp__offset = stream.tell()
# returns... | Build the field and write the result into the stream
:stream: An IO stream that can be written to
:returns: None | entailment |
def _pfp__show(self, level=0, include_offset=False):
"""Show the contents of the struct
"""
res = []
res.append("{}{} {{".format(
"{:04x} ".format(self._pfp__offset) if include_offset else "",
self._pfp__show_name
))
for child in self._pfp__childre... | Show the contents of the struct | entailment |
def _pfp__add_child(self, name, child, stream=None):
"""Add a child to the Union field
:name: The name of the child
:child: A :class:`.Field` instance
:returns: The resulting field
"""
res = super(Union, self)._pfp__add_child(name, child)
self._pfp__buff.seek(0, ... | Add a child to the Union field
:name: The name of the child
:child: A :class:`.Field` instance
:returns: The resulting field | entailment |
def _pfp__notify_update(self, child=None):
"""Handle a child with an updated value
"""
if getattr(self, "_pfp__union_update_other_children", True):
self._pfp__union_update_other_children = False
new_data = child._pfp__build()
new_stream = bitwrap.BitwrappedS... | Handle a child with an updated value | entailment |
def _pfp__parse(self, stream, save_offset=False):
"""Parse the incoming stream
:stream: Input stream to be parsed
:returns: Number of bytes parsed
"""
if save_offset:
self._pfp__offset = stream.tell()
max_res = 0
for child in self._pfp__children:
... | Parse the incoming stream
:stream: Input stream to be parsed
:returns: Number of bytes parsed | entailment |
def _pfp__build(self, stream=None, save_offset=False):
"""Build the union and write the result into the stream.
:stream: None
:returns: None
"""
max_size = -1
if stream is None:
core_stream = six.BytesIO()
new_stream = bitwrap.BitwrappedStream(cor... | Build the union and write the result into the stream.
:stream: None
:returns: None | entailment |
def _pfp__parse(self, stream, save_offset=False):
"""Parse the IO stream for this numeric field
:stream: An IO stream that can be read from
:returns: The number of bytes parsed
"""
if save_offset:
self._pfp__offset = stream.tell()
if self.bitsize is None:
... | Parse the IO stream for this numeric field
:stream: An IO stream that can be read from
:returns: The number of bytes parsed | entailment |
def _pfp__build(self, stream=None, save_offset=False):
"""Build the field and write the result into the stream
:stream: An IO stream that can be written to
:returns: None
"""
if stream is not None and save_offset:
self._pfp__offset = stream.tell()
if self.b... | Build the field and write the result into the stream
:stream: An IO stream that can be written to
:returns: None | entailment |
def _dom_class(self, obj1, obj2):
"""Return the dominating numeric class between the two
:obj1: TODO
:obj2: TODO
:returns: TODO
"""
if isinstance(obj1, Double) or isinstance(obj2, Double):
return Double
if isinstance(obj1, Float) or isinstance(obj2, ... | Return the dominating numeric class between the two
:obj1: TODO
:obj2: TODO
:returns: TODO | entailment |
def _pfp__set_value(self, new_val):
"""Set the value, potentially converting an unsigned
value to a signed one (and visa versa)"""
if self._pfp__frozen:
raise errors.UnmodifiableConst()
if isinstance(new_val, IntBase):
# will automatically convert correctly betwe... | Set the value, potentially converting an unsigned
value to a signed one (and visa versa) | entailment |
def _pfp__parse(self, stream, save_offset=False):
"""Parse the IO stream for this enum
:stream: An IO stream that can be read from
:returns: The number of bytes parsed
"""
res = super(Enum, self)._pfp__parse(stream, save_offset)
if self._pfp__value in self.enum_vals:
... | Parse the IO stream for this enum
:stream: An IO stream that can be read from
:returns: The number of bytes parsed | entailment |
def _pfp__snapshot(self, recurse=True):
"""Save off the current value of the field
"""
super(Array, self)._pfp__snapshot(recurse=recurse)
self.snapshot_raw_data = self.raw_data
if recurse:
for item in self.items:
item._pfp__snapshot(recurse=recurse) | Save off the current value of the field | entailment |
def _pfp__set_value(self, new_val):
"""Set the value of the String, taking into account
escaping and such as well
"""
if not isinstance(new_val, Field):
new_val = utils.binary(utils.string_escape(new_val))
super(String, self)._pfp__set_value(new_val) | Set the value of the String, taking into account
escaping and such as well | entailment |
def _pfp__parse(self, stream, save_offset=False):
"""Read from the stream until the string is null-terminated
:stream: The input stream
:returns: None
"""
if save_offset:
self._pfp__offset = stream.tell()
res = utils.binary("")
while True:
... | Read from the stream until the string is null-terminated
:stream: The input stream
:returns: None | entailment |
def _pfp__build(self, stream=None, save_offset=False):
"""Build the String field
:stream: TODO
:returns: TODO
"""
if stream is not None and save_offset:
self._pfp__offset = stream.tell()
data = self._pfp__value + utils.binary("\x00")
if stream is No... | Build the String field
:stream: TODO
:returns: TODO | entailment |
def Printf(params, ctxt, scope, stream, coord, interp):
"""Prints format string to stdout
:params: TODO
:returns: TODO
"""
if len(params) == 1:
if interp._printf:
sys.stdout.write(PYSTR(params[0]))
return len(PYSTR(params[0]))
parts = []
for part in params[1:]:... | Prints format string to stdout
:params: TODO
:returns: TODO | entailment |
def mutate(field, strat_name_or_cls, num=100, at_once=1, yield_changed=False):
"""Mutate the provided field (probably a Dom or struct instance) using the
strategy specified with ``strat_name_or_class``, yielding ``num`` mutations
that affect up to ``at_once`` fields at once.
This function will yield ba... | Mutate the provided field (probably a Dom or struct instance) using the
strategy specified with ``strat_name_or_class``, yielding ``num`` mutations
that affect up to ``at_once`` fields at once.
This function will yield back the field after each mutation, optionally
also yielding a ``set`` of fields tha... | entailment |
def get_strategy(name_or_cls):
"""Return the strategy identified by its name. If ``name_or_class`` is a class,
it will be simply returned.
"""
if isinstance(name_or_cls, six.string_types):
if name_or_cls not in STRATS:
raise MutationError("strat is not defined")
return STRATS... | Return the strategy identified by its name. If ``name_or_class`` is a class,
it will be simply returned. | entailment |
def mutate(self, field):
"""Mutate the given field, modifying it directly. This is not
intended to preserve the value of the field.
:field: The pfp.fields.Field instance that will receive the new value
"""
new_val = self.next_val(field)
field._pfp__set_value(new_val)
... | Mutate the given field, modifying it directly. This is not
intended to preserve the value of the field.
:field: The pfp.fields.Field instance that will receive the new value | entailment |
def next_val(self, field):
"""Return a new value to mutate a field with. Do not modify the field directly
in this function. Override the ``mutate()`` function if that is needed (the field is
only passed into this function as a reference).
:field: The pfp.fields.Field instance that will ... | Return a new value to mutate a field with. Do not modify the field directly
in this function. Override the ``mutate()`` function if that is needed (the field is
only passed into this function as a reference).
:field: The pfp.fields.Field instance that will receive the new value. Passed in for r... | entailment |
def generate_subid(self, token=None, return_user=False):
'''generate a new user in the database, still session based so we
create a new identifier.
'''
from expfactory.database.models import Participant
if not token:
p = Participant()
else:
p = Participant(token=token)
... | generate a new user in the database, still session based so we
create a new identifier. | entailment |
def print_user(self, user):
'''print a relational database user
'''
status = "active"
token = user.token
if token in ['finished', 'revoked']:
status = token
if token is None:
token = ''
subid = "%s\t%s[%s]" %(user.id, token, status)
print(subid)
return subid | print a relational database user | entailment |
def list_users(self, user=None):
'''list users, each having a model in the database. A headless experiment
will use protected tokens, and interactive will be based on auto-
incremented ids.
'''
from expfactory.database.models import Participant
participants = Participant.query.all()
u... | list users, each having a model in the database. A headless experiment
will use protected tokens, and interactive will be based on auto-
incremented ids. | entailment |
def generate_user(self):
'''generate a new user in the database, still session based so we
create a new identifier. This function is called from the users new
entrypoint, and it assumes we want a user generated with a token.
'''
token = str(uuid.uuid4())
return self.generate_subid(token=t... | generate a new user in the database, still session based so we
create a new identifier. This function is called from the users new
entrypoint, and it assumes we want a user generated with a token. | entailment |
def finish_user(self, subid):
'''finish user will remove a user's token, making the user entry not
accesible if running in headless model'''
p = self.revoke_token(subid)
p.token = "finished"
self.session.commit()
return p | finish user will remove a user's token, making the user entry not
accesible if running in headless model | entailment |
def restart_user(self, subid):
'''restart a user, which means revoking and issuing a new token.'''
p = self.revoke_token(subid)
p = self.refresh_token(subid)
return p | restart a user, which means revoking and issuing a new token. | entailment |
def validate_token(self, token):
'''retrieve a subject based on a token. Valid means we return a participant
invalid means we return None
'''
from expfactory.database.models import Participant
p = Participant.query.filter(Participant.token == token).first()
if p is not None:
if p.toke... | retrieve a subject based on a token. Valid means we return a participant
invalid means we return None | entailment |
def revoke_token(self, subid):
'''revoke a token by removing it. Is done at finish, and also available
as a command line option'''
from expfactory.database.models import Participant
p = Participant.query.filter(Participant.id == subid).first()
if p is not None:
p.token = 'revoked'
self.s... | revoke a token by removing it. Is done at finish, and also available
as a command line option | entailment |
def refresh_token(self, subid):
'''refresh or generate a new token for a user'''
from expfactory.database.models import Participant
p = Participant.query.filter(Participant.id == subid).first()
if p is not None:
p.token = str(uuid.uuid4())
self.session.commit()
return p | refresh or generate a new token for a user | entailment |
def save_data(self,session, exp_id, content):
'''save data will obtain the current subid from the session, and save it
depending on the database type. Currently we just support flat files'''
from expfactory.database.models import (
Participant,
Result
)
subid = session.get('subid'... | save data will obtain the current subid from the session, and save it
depending on the database type. Currently we just support flat files | entailment |
def init_db(self):
'''initialize the database, with the default database path or custom with
a format corresponding to the database type:
Examples:
sqlite:////scif/data/expfactory.db
'''
# The user can provide a custom string
if self.database is None:
self.logger.error("Y... | initialize the database, with the default database path or custom with
a format corresponding to the database type:
Examples:
sqlite:////scif/data/expfactory.db | entailment |
def LazyField(lookup_name, scope):
"""Super non-standard stuff here. Dynamically changing the base
class using the scope and the lazy name when the class is
instantiated. This works as long as the original base class is
not directly inheriting from object (which we're not, since
our original base cl... | Super non-standard stuff here. Dynamically changing the base
class using the scope and the lazy name when the class is
instantiated. This works as long as the original base class is
not directly inheriting from object (which we're not, since
our original base class is fields.Field). | entailment |
def _wrap_type_instantiation(self, type_cls):
"""Wrap the creation of the type so that we can provide
a null-stream to initialize it"""
def wrapper(*args, **kwargs):
# use args for struct arguments??
return type_cls(stream=self._null_stream)
return wrapper | Wrap the creation of the type so that we can provide
a null-stream to initialize it | entailment |
def level(self):
"""Return the current scope level
"""
res = len(self._scope_stack)
if self._parent is not None:
res += self._parent.level()
return res | Return the current scope level | entailment |
def push(self, new_scope=None):
"""Create a new scope
:returns: TODO
"""
if new_scope is None:
new_scope = {
"types": {},
"vars": {}
}
self._curr_scope = new_scope
self._dlog("pushing new scope, scope level = {}".fo... | Create a new scope
:returns: TODO | entailment |
def clone(self):
"""Return a new Scope object that has the curr_scope
pinned at the current one
:returns: A new scope object
"""
self._dlog("cloning the stack")
# TODO is this really necessary to create a brand new one?
# I think it is... need to think about it mo... | Return a new Scope object that has the curr_scope
pinned at the current one
:returns: A new scope object | entailment |
def pop(self):
"""Leave the current scope
:returns: TODO
"""
res = self._scope_stack.pop()
self._dlog("popping scope, scope level = {}".format(self.level()))
self._curr_scope = self._scope_stack[-1]
return res | Leave the current scope
:returns: TODO | entailment |
def add_var(self, field_name, field, root=False):
"""Add a var to the current scope (vars are fields that
parse the input stream)
:field_name: TODO
:field: TODO
:returns: TODO
"""
self._dlog("adding var '{}' (root={})".format(field_name, root))
# do bot... | Add a var to the current scope (vars are fields that
parse the input stream)
:field_name: TODO
:field: TODO
:returns: TODO | entailment |
def get_var(self, name, recurse=True):
"""Return the first var of name ``name`` in the current
scope stack (remember, vars are the ones that parse the
input stream)
:name: The name of the id
:recurse: Whether parent scopes should also be searched (defaults to True)
:retu... | Return the first var of name ``name`` in the current
scope stack (remember, vars are the ones that parse the
input stream)
:name: The name of the id
:recurse: Whether parent scopes should also be searched (defaults to True)
:returns: TODO | entailment |
def add_local(self, field_name, field):
"""Add a local variable in the current scope
:field_name: The field's name
:field: The field
:returns: None
"""
self._dlog("adding local '{}'".format(field_name))
field._pfp__name = field_name
# TODO do we allow cl... | Add a local variable in the current scope
:field_name: The field's name
:field: The field
:returns: None | entailment |
def get_local(self, name, recurse=True):
"""Get the local field (search for it) from the scope stack. An alias
for ``get_var``
:name: The name of the local field
"""
self._dlog("getting local '{}'".format(name))
return self._search("vars", name, recurse) | Get the local field (search for it) from the scope stack. An alias
for ``get_var``
:name: The name of the local field | entailment |
def add_type_struct_or_union(self, name, interp, node):
"""Store the node with the name. When it is instantiated,
the node itself will be handled.
:name: name of the typedefd struct/union
:node: the union/struct node
:interp: the 010 interpreter
"""
self.add_type... | Store the node with the name. When it is instantiated,
the node itself will be handled.
:name: name of the typedefd struct/union
:node: the union/struct node
:interp: the 010 interpreter | entailment |
def add_type(self, new_name, orig_names):
"""Record the typedefd name for orig_names. Resolve orig_names
to their core names and save those.
:new_name: TODO
:orig_names: TODO
:returns: TODO
"""
self._dlog("adding a type '{}'".format(new_name))
# TODO do ... | Record the typedefd name for orig_names. Resolve orig_names
to their core names and save those.
:new_name: TODO
:orig_names: TODO
:returns: TODO | entailment |
def get_type(self, name, recurse=True):
"""Get the names for the typename (created by typedef)
:name: The typedef'd name to resolve
:returns: An array of resolved names associated with the typedef'd name
"""
self._dlog("getting type '{}'".format(name))
return self._sear... | Get the names for the typename (created by typedef)
:name: The typedef'd name to resolve
:returns: An array of resolved names associated with the typedef'd name | entailment |
def get_id(self, name, recurse=True):
"""Get the first id matching ``name``. Will either be a local
or a var.
:name: TODO
:returns: TODO
"""
self._dlog("getting id '{}'".format(name))
var = self._search("vars", name, recurse)
return var | Get the first id matching ``name``. Will either be a local
or a var.
:name: TODO
:returns: TODO | entailment |
def _resolve_name(self, name):
"""TODO: Docstring for _resolve_names.
:name: TODO
:returns: TODO
"""
res = [name]
while True:
orig_names = self._search("types", name)
if orig_names is not None:
name = orig_names[-1]
... | TODO: Docstring for _resolve_names.
:name: TODO
:returns: TODO | entailment |
def _search(self, category, name, recurse=True):
"""Search the scope stack for the name in the specified
category (types/locals/vars).
:category: the category to search in (locals/types/vars)
:name: name to search for
:returns: None if not found, the result of the found local/ty... | Search the scope stack for the name in the specified
category (types/locals/vars).
:category: the category to search in (locals/types/vars)
:name: name to search for
:returns: None if not found, the result of the found local/type/id | entailment |
def add_native(cls, name, func, ret, interp=None, send_interp=False):
"""Add the native python function ``func`` into the pfp interpreter with the
name ``name`` and return value ``ret`` so that it can be called from
within a template script.
.. note::
The :any:`@native <pfp.... | Add the native python function ``func`` into the pfp interpreter with the
name ``name`` and return value ``ret`` so that it can be called from
within a template script.
.. note::
The :any:`@native <pfp.native.native>` decorator exists to simplify this.
All native functions ... | entailment |
def define_natives(cls):
"""Define the native functions for PFP
"""
if len(cls._natives) > 0:
return
glob_pattern = os.path.join(os.path.dirname(__file__), "native", "*.py")
for filename in glob.glob(glob_pattern):
basename = os.path.basename(filename).re... | Define the native functions for PFP | entailment |
def _dlog(self, msg, indent_increase=0):
"""log the message to the log"""
self._log.debug("interp", msg, indent_increase, filename=self._orig_filename, coord=self._coord) | log the message to the log | entailment |
def parse(self, stream, template, predefines=True, orig_filename=None, keep_successful=False, printf=True):
"""Parse the data stream using the template (e.g. parse the 010 template
and interpret the template using the stream as the data source).
:stream: The input data stream
:template:... | Parse the data stream using the template (e.g. parse the 010 template
and interpret the template using the stream as the data source).
:stream: The input data stream
:template: The template to parse the stream with
:keep_successful: Return whatever was successfully parsed before an erro... | entailment |
def eval(self, statement, ctxt=None):
"""Eval a single statement (something returnable)
"""
self._no_debug = True
statement = statement.strip()
if not statement.endswith(";"):
statement += ";"
ast = self._parse_string(statement, predefines=False)
s... | Eval a single statement (something returnable) | entailment |
def set_break(self, break_type):
"""Set if the interpreter should break.
:returns: TODO
"""
self._break_type = break_type
self._break_level = self._scope.level() | Set if the interpreter should break.
:returns: TODO | entailment |
def get_curr_lines(self):
"""Return the current line number in the template,
as well as the surrounding source lines
"""
start = max(0, self._coord.line - 5)
end = min(len(self._template_lines), self._coord.line + 4)
lines = [(x, self._template_lines[x]) for x in six.mov... | Return the current line number in the template,
as well as the surrounding source lines | entailment |
def set_bitfield_padded(self, val):
"""Set if the bitfield input/output stream should be padded
:val: True/False
:returns: None
"""
self._padded_bitfield = val
self._stream.padded = val
self._ctxt._pfp__padded_bitfield = val | Set if the bitfield input/output stream should be padded
:val: True/False
:returns: None | entailment |
def _run(self, keep_successfull):
"""Interpret the parsed 010 AST
:returns: PfpDom
"""
# example self._ast.show():
# FileAST:
# Decl: data, [], [], []
# TypeDecl: data, []
# Struct: DATA
# Decl: a, [], [], []
... | Interpret the parsed 010 AST
:returns: PfpDom | entailment |
def _handle_node(self, node, scope=None, ctxt=None, stream=None):
"""Recursively handle nodes in the 010 AST
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
if scope is None:
if self._scope is None:
self._... | Recursively handle nodes in the 010 AST
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_file_ast(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_file_ast.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._root = ctxt = fields.Dom(stream)
ctxt._pfp__scope = scope
self._ro... | TODO: Docstring for _handle_file_ast.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_cast(self, node, scope, ctxt, stream):
"""Handle cast nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling cast")
to_type = self._handle_node(node.to_type, scope, ctxt, stream)
val_t... | Handle cast nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_typename(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_typename
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling typename")
return self._handle_node(node.type, scope, ctxt,... | TODO: Docstring for _handle_typename
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _get_node_name(self, node):
"""Get the name of the node - check for node.name and
node.type.declname. Not sure why the second one occurs
exactly - it happens with declaring a new struct field
with parameters"""
res = getattr(node, "name", None)
if res is None:
... | Get the name of the node - check for node.name and
node.type.declname. Not sure why the second one occurs
exactly - it happens with declaring a new struct field
with parameters | entailment |
def _handle_decl(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_decl.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling decl")
metadata_processor = None
if node.metadata is not N... | TODO: Docstring for _handle_decl.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_metadata(self, node, scope, ctxt, stream):
"""Handle metadata for the node
"""
self._dlog("handling node metadata {}".format(node.metadata.keyvals))
keyvals = node.metadata.keyvals
metadata_info = []
if "watch" in node.metadata.keyvals or "update" in keyval... | Handle metadata for the node | entailment |
def _handle_watch_metadata(self, node, scope, ctxt, stream):
"""Handle watch vars for fields
"""
keyvals = node.metadata.keyvals
if "watch" not in keyvals:
raise errors.PfpError("Packed fields require a packer function set")
if "update" not in keyvals:
rai... | Handle watch vars for fields | entailment |
def _handle_packed_metadata(self, node, scope, ctxt, stream):
"""Handle packed metadata
"""
keyvals = node.metadata.keyvals
if "packer" not in keyvals and ("pack" not in keyvals or "unpack" not in keyvals):
raise errors.PfpError("Packed fields require a packer function to be ... | Handle packed metadata | entailment |
def _handle_byref_decl(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_byref_decl.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling byref decl")
field = self._handle_node(node.type.type, ... | TODO: Docstring for _handle_byref_decl.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_type_decl(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_type_decl.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling type decl")
decl = self._handle_node(node.type, scope, ct... | TODO: Docstring for _handle_type_decl.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_struct_ref(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_struct_ref.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling struct ref")
# name
# field
struct = s... | TODO: Docstring for _handle_struct_ref.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_union(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_union.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling union")
union_cls = StructUnionDef("union", self, node)
... | TODO: Docstring for _handle_union.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_init_list(self, node, scope, ctxt, stream):
"""Handle InitList nodes (e.g. when initializing a struct)
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling init list")
res = []
for _,init_... | Handle InitList nodes (e.g. when initializing a struct)
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_struct_call_type_decl(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_struct_call_type_decl.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling struct with parameters")
struct_... | TODO: Docstring for _handle_struct_call_type_decl.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_struct(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_struct.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling struct")
if node.args is not None:
for param in no... | TODO: Docstring for _handle_struct.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_identifier_type(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_identifier_type.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling identifier")
cls = self._resolve_to_field_cl... | TODO: Docstring for _handle_identifier_type.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_typedef(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_typedef.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
is_union_or_struct = (node.type.type.__class__ in [AST.Union, AST.Struct])
is_enum... | TODO: Docstring for _handle_typedef.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _str_to_int(self, string):
"""Check for the hex
"""
string = string.lower()
if string.endswith("l"):
string = string[:-1]
if string.lower().startswith("0x"):
# should always match
match = re.match(r'0[xX]([a-fA-F0-9]+)', string)
... | Check for the hex | entailment |
def _handle_constant(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_constant.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling constant type {}".format(node.type))
switch = {
... | TODO: Docstring for _handle_constant.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_binary_op(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_binary_op.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling binary operation {}".format(node.op))
switch = {
... | TODO: Docstring for _handle_binary_op.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_unary_op(self, node, scope, ctxt, stream):
"""TODO: Docstring for _handle_unary_op.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling unary op {}".format(node.op))
special_switch = {
... | TODO: Docstring for _handle_unary_op.
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_parentof(self, node, scope, ctxt, stream):
"""Handle the parentof unary operator
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
# if someone does something like parentof(this).blah,
# we'll end up with a StructR... | Handle the parentof unary operator
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_exists(self, node, scope, ctxt, stream):
"""Handle the exists unary operator
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
res = fields.Int()
try:
self._handle_node(node.expr, scope, ctxt, stream)
... | Handle the exists unary operator
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_function_exists(self, node, scope, ctxt, stream):
"""Handle the function_exists unary operator
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
res = fields.Int()
try:
func = self._handle_node(node.exp... | Handle the function_exists unary operator
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_id(self, node, scope, ctxt, stream):
"""Handle an ID node (return a field object for the ID)
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
if node.name == "__root":
return self._root
if node.name ==... | Handle an ID node (return a field object for the ID)
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_assignment(self, node, scope, ctxt, stream):
"""Handle assignment nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
def add_op(x,y): x += y
def sub_op(x,y): x -= y
def div_op(x,y): x /= y
def ... | Handle assignment nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_func_def(self, node, scope, ctxt, stream):
"""Handle FuncDef nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling function definition")
func = self._handle_node(node.decl, scope, ctxt, strea... | Handle FuncDef nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_param_list(self, node, scope, ctxt, stream):
"""Handle ParamList nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling param list")
# params should be a list of tuples:
# [(<name>, <f... | Handle ParamList nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_func_decl(self, node, scope, ctxt, stream):
"""Handle FuncDecl nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling func decl")
if node.args is not None:
# could just call _hand... | Handle FuncDecl nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_func_call(self, node, scope, ctxt, stream):
"""Handle FuncCall nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling function call to '{}'".format(node.name.name))
if node.args is None:
... | Handle FuncCall nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_expr_list(self, node, scope, ctxt, stream):
"""Handle ExprList nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling expression list")
exprs = [
self._handle_node(expr, scope, ctx... | Handle ExprList nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_compound(self, node, scope, ctxt, stream):
"""Handle Compound nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling compound statement")
#scope.push()
try:
for child in n... | Handle Compound nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_return(self, node, scope, ctxt, stream):
"""Handle Return nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling return")
if node.expr is None:
ret_val = None
else:
... | Handle Return nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_enum(self, node, scope, ctxt, stream):
"""Handle enum nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling enum")
if node.type is None:
enum_cls = fields.Int
else:
... | Handle enum nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_array_decl(self, node, scope, ctxt, stream):
"""Handle ArrayDecl nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling array declaration '{}'".format(node.type.declname))
if node.dim is None... | Handle ArrayDecl nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_array_ref(self, node, scope, ctxt, stream):
"""Handle ArrayRef nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
ary = self._handle_node(node.name, scope, ctxt, stream)
subscript = self._handle_node(node.subs... | Handle ArrayRef nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_if(self, node, scope, ctxt, stream):
"""Handle If nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling if/ternary_op")
cond = self._handle_node(node.cond, scope, ctxt, stream)
if con... | Handle If nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_for(self, node, scope, ctxt, stream):
"""Handle For nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling for")
if node.init is not None:
# perform the init
self._hand... | Handle For nodes
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_while(self, node, scope, ctxt, stream):
"""Handle break node
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
self._dlog("handling while")
while node.cond is None or self._handle_node(node.cond, scope, ctxt, strea... | Handle break node
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
def _handle_switch(self, node, scope, ctxt, stream):
"""Handle break node
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO
"""
def exec_case(idx, cases):
# keep executing cases until a break is found,
# or they've... | Handle break node
:node: TODO
:scope: TODO
:ctxt: TODO
:stream: TODO
:returns: TODO | entailment |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.