SYMBOL INDEX (584 symbols across 29 files)

FILE: ljd/ast/builder.py
  class _State (line 13) | class _State():
    method __init__ (line 14) | def __init__(self):
    method _warp_in_block (line 21) | def _warp_in_block(self, addr):
  function build (line 29) | def build(prototype):
  function _build_function_definition (line 33) | def _build_function_definition(prototype):
  function _build_function_arguments (line 57) | def _build_function_arguments(state, prototype):
  function _build_function_blocks (line 72) | def _build_function_blocks(state, instructions):
  function _blockenize (line 116) | def _blockenize(state, instructions):
  function _establish_warps (line 167) | def _establish_warps(state, instructions):
  function _build_warp (line 190) | def _build_warp(state, last_addr, instructions):
  function _build_jump_warp (line 207) | def _build_jump_warp(state, last_addr, instructions):
  function _build_conditional_warp (line 218) | def _build_conditional_warp(state, last_addr, instructions):
  function _build_unconditional_warp (line 255) | def _build_unconditional_warp(state, addr, instruction):
  function _build_iterator_warp (line 273) | def _build_iterator_warp(state, last_addr, instructions):
  function _build_numeric_loop_warp (line 308) | def _build_numeric_loop_warp(state, addr, instruction):
  function _build_flow_warp (line 328) | def _build_flow_warp(state, addr, instruction):
  function _build_statement (line 339) | def _build_statement(state, addr, instruction):
  function _build_var_assignment (line 386) | def _build_var_assignment(state, addr, instruction):
  function _build_knil (line 449) | def _build_knil(state, addr, instruction):
  function _build_global_assignment (line 457) | def _build_global_assignment(state, addr, instruction):
  function _build_table_assignment (line 469) | def _build_table_assignment(state, addr, instruction):
  function _build_table_mass_assignment (line 481) | def _build_table_mass_assignment(state, addr, instruction):
  function _build_call (line 496) | def _build_call(state, addr, instruction):
  function _build_vararg (line 522) | def _build_vararg(state, addr, instruction):
  function _build_return (line 537) | def _build_return(state, addr, instruction):
  function _build_call_arguments (line 560) | def _build_call_arguments(state, addr, instruction):
  function _build_range_assignment (line 585) | def _build_range_assignment(state, addr, from_slot, to_slot):
  function _build_binary_expression (line 611) | def _build_binary_expression(state, addr, instruction):
  function _build_concat_expression (line 639) | def _build_concat_expression(state, addr, instruction):
  function _build_const_expression (line 663) | def _build_const_expression(state, addr, instruction):
  function _build_table_element (line 686) | def _build_table_element(state, addr, instruction):
  function _build_function (line 698) | def _build_function(state, slot):
  function _build_table_copy (line 704) | def _build_table_copy(state, slot):
  function _build_table_record_item (line 729) | def _build_table_record_item(value):
  function _build_comparison_expression (line 777) | def _build_comparison_expression(state, addr, instruction):
  function _build_unary_expression (line 799) | def _build_unary_expression(state, addr, instruction):
  function _build_slot (line 826) | def _build_slot(state, addr, slot):
  function _build_upvalue (line 830) | def _build_upvalue(state, addr, slot):
  function _build_identifier (line 834) | def _build_identifier(state, addr, slot, want_type):
  function _build_global_variable (line 851) | def _build_global_variable(state, addr, slot):
  function _build_string_constant (line 862) | def _build_string_constant(state, index):
  function _build_cdata_constant (line 870) | def _build_cdata_constant(state, index):
  function _build_numeric_constant (line 878) | def _build_numeric_constant(state, index):
  function _build_primitive (line 892) | def _build_primitive(state, value):
  function _build_literal (line 907) | def _build_literal(state, value):

FILE: ljd/ast/helpers.py
  function insert_table_record (line 5) | def insert_table_record(constructor, key, value):
  function has_same_table (line 57) | def has_same_table(node, table):
  function is_equal (line 81) | def is_equal(a, b):

FILE: ljd/ast/locals.py
  function mark_locals (line 10) | def mark_locals(ast):
  function mark_local_definitions (line 14) | def mark_local_definitions(ast):
  class _LocalsMarker (line 18) | class _LocalsMarker(traverse.Visitor):
    class _State (line 19) | class _State():
      method __init__ (line 20) | def __init__(self):
    method __init__ (line 25) | def __init__(self):
    method _push_state (line 30) | def _push_state(self):
    method _pop_state (line 33) | def _pop_state(self):
    method _state (line 36) | def _state(self):
    method _process_slots (line 39) | def _process_slots(self, addr):
    method _reset_slot (line 65) | def _reset_slot(self, slot):
    method _reset_all (line 68) | def _reset_all(self, slots):
    method visit_function_definition (line 75) | def visit_function_definition(self, node):
    method leave_function_definition (line 79) | def leave_function_definition(self, node):
    method visit_variables_list (line 87) | def visit_variables_list(self, node):
    method visit_identifiers_list (line 92) | def visit_identifiers_list(self, node):
    method visit_numeric_loop_warp (line 95) | def visit_numeric_loop_warp(self, node):
    method visit_identifier (line 98) | def visit_identifier(self, node):
    method _process_worthy_node (line 107) | def _process_worthy_node(self, node):
    method _leave_node (line 119) | def _leave_node(self, handler, node):
    method _visit_node (line 124) | def _visit_node(self, handler, node):
  class _LocalDefinitionsMarker (line 130) | class _LocalDefinitionsMarker(traverse.Visitor):
    class _State (line 131) | class _State():
      method __init__ (line 132) | def __init__(self):
    method __init__ (line 136) | def __init__(self):
    method _push_state (line 139) | def _push_state(self):
    method _pop_state (line 142) | def _pop_state(self):
    method _state (line 145) | def _state(self):
    method _update_known_locals (line 148) | def _update_known_locals(self, local, addr):
    method visit_function_definition (line 163) | def visit_function_definition(self, node):
    method leave_function_definition (line 170) | def leave_function_definition(self, node):
    method visit_iterator_for (line 173) | def visit_iterator_for(self, node):
    method visit_numeric_for (line 180) | def visit_numeric_for(self, node):
    method visit_assignment (line 188) | def visit_assignment(self, node):
    method _visit (line 214) | def _visit(self, node):

FILE: ljd/ast/mutator.py
  class SimpleLoopWarpSwapper (line 10) | class SimpleLoopWarpSwapper(traverse.Visitor):
    method visit_statements_list (line 11) | def visit_statements_list(self, node):
    method _create_dummy_block (line 59) | def _create_dummy_block(self, block, slot):
    method _fix_uclo_return (line 85) | def _fix_uclo_return(self, block, next_block):
    method _swap_iterator_warps (line 104) | def _swap_iterator_warps(self, blocks, end):
    method _swap_numeric_loop_warps (line 130) | def _swap_numeric_loop_warps(self, blocks, end):
  class MutatorVisitor (line 158) | class MutatorVisitor(traverse.Visitor):
    method leave_if (line 161) | def leave_if(self, node):
    method visit_statements_list (line 178) | def visit_statements_list(self, node):
    method _fill_constructor (line 205) | def _fill_constructor(self, table, constructor, statements):
  function pre_pass (line 236) | def pre_pass(ast):
  function primary_pass (line 242) | def primary_pass(ast):

FILE: ljd/ast/nodes.py
  class FunctionDefinition (line 9) | class FunctionDefinition():
    method __init__ (line 10) | def __init__(self):
    method _accept (line 18) | def _accept(self, visitor):
  class TableConstructor (line 27) | class TableConstructor():
    method __init__ (line 28) | def __init__(self):
    method _accept (line 32) | def _accept(self, visitor):
  class ArrayRecord (line 41) | class ArrayRecord():
    method __init__ (line 42) | def __init__(self):
    method _accept (line 45) | def _accept(self, visitor):
  class TableRecord (line 53) | class TableRecord():
    method __init__ (line 54) | def __init__(self):
    method _accept (line 58) | def _accept(self, visitor):
  class Assignment (line 67) | class Assignment():
    method __init__ (line 71) | def __init__(self):
    method _accept (line 76) | def _accept(self, visitor):
  class BinaryOperator (line 85) | class BinaryOperator():
    method __init__ (line 108) | def __init__(self):
    method _accept (line 113) | def _accept(self, visitor):
  class UnaryOperator (line 122) | class UnaryOperator():
    method __init__ (line 127) | def __init__(self):
    method _accept (line 131) | def _accept(self, visitor):
  class StatementsList (line 139) | class StatementsList():
    method __init__ (line 140) | def __init__(self):
    method _accept (line 143) | def _accept(self, visitor):
  class IdentifiersList (line 151) | class IdentifiersList():
    method __init__ (line 152) | def __init__(self):
    method _accept (line 155) | def _accept(self, visitor):
  class RecordsList (line 163) | class RecordsList():
    method __init__ (line 164) | def __init__(self):
    method _accept (line 167) | def _accept(self, visitor):
  class VariablesList (line 175) | class VariablesList():
    method __init__ (line 176) | def __init__(self):
    method _accept (line 179) | def _accept(self, visitor):
  class ExpressionsList (line 187) | class ExpressionsList():
    method __init__ (line 188) | def __init__(self):
    method _accept (line 191) | def _accept(self, visitor):
  class Identifier (line 200) | class Identifier():
    method __init__ (line 206) | def __init__(self):
    method _accept (line 211) | def _accept(self, visitor):
  class MULTRES (line 218) | class MULTRES():
    method _accept (line 219) | def _accept(self, visitor):
  class TableElement (line 224) | class TableElement():
    method __init__ (line 225) | def __init__(self):
    method _accept (line 229) | def _accept(self, visitor):
  class Vararg (line 238) | class Vararg():
    method _accept (line 239) | def _accept(self, visitor):
  class FunctionCall (line 244) | class FunctionCall():
    method __init__ (line 245) | def __init__(self):
    method _accept (line 249) | def _accept(self, visitor):
  class If (line 258) | class If():
    method __init__ (line 259) | def __init__(self):
    method _accept (line 265) | def _accept(self, visitor):
  class ElseIf (line 278) | class ElseIf():
    method __init__ (line 279) | def __init__(self):
    method _accept (line 283) | def _accept(self, visitor):
  class Block (line 294) | class Block():
    method __init__ (line 295) | def __init__(self):
    method _accept (line 303) | def _accept(self, visitor):
  class UnconditionalWarp (line 312) | class UnconditionalWarp():
    method __init__ (line 316) | def __init__(self):
    method _accept (line 321) | def _accept(self, visitor):
  class ConditionalWarp (line 329) | class ConditionalWarp():
    method __init__ (line 330) | def __init__(self):
    method _accept (line 335) | def _accept(self, visitor):
  class IteratorWarp (line 345) | class IteratorWarp():
    method __init__ (line 346) | def __init__(self):
    method _accept (line 352) | def _accept(self, visitor):
  class NumericLoopWarp (line 363) | class NumericLoopWarp():
    method __init__ (line 364) | def __init__(self):
    method _accept (line 370) | def _accept(self, visitor):
  class EndWarp (line 381) | class EndWarp():
    method _accept (line 382) | def _accept(self, visitor):
  class Return (line 390) | class Return():
    method __init__ (line 391) | def __init__(self):
    method _accept (line 394) | def _accept(self, visitor):
  class Break (line 402) | class Break():
    method _accept (line 403) | def _accept(self, visitor):
  class While (line 408) | class While():
    method __init__ (line 409) | def __init__(self):
    method _accept (line 413) | def _accept(self, visitor):
  class RepeatUntil (line 422) | class RepeatUntil():
    method __init__ (line 423) | def __init__(self):
    method _accept (line 427) | def _accept(self, visitor):
  class NumericFor (line 436) | class NumericFor():
    method __init__ (line 437) | def __init__(self):
    method _accept (line 442) | def _accept(self, visitor):
  class IteratorFor (line 452) | class IteratorFor():
    method __init__ (line 453) | def __init__(self):
    method _accept (line 458) | def _accept(self, visitor):
  class Constant (line 468) | class Constant():
    method __init__ (line 474) | def __init__(self):
    method _accept (line 478) | def _accept(self, visitor):
  class Primitive (line 483) | class Primitive():
    method __init__ (line 488) | def __init__(self):
    method _accept (line 491) | def _accept(self, visitor):

FILE: ljd/ast/slotworks.py
  function eliminate_temporary (line 10) | def eliminate_temporary(ast):
  function _eliminate_temporary (line 23) | def _eliminate_temporary(slots):
  function _fill_massive_refs (line 56) | def _fill_massive_refs(info, simple, massive, iterators):
  function _fill_simple_refs (line 90) | def _fill_simple_refs(info, simple, tables):
  function _get_holder (line 128) | def _get_holder(path):
  function _eliminate_simple_cases (line 136) | def _eliminate_simple_cases(simple):
  function _eliminate_into_table_constructors (line 156) | def _eliminate_into_table_constructors(tables):
  function _eliminate_mass_assignments (line 174) | def _eliminate_mass_assignments(massive):
  function _replace_node (line 184) | def _replace_node(holder, original, replacement):
  function _replace_node_in_list (line 193) | def _replace_node_in_list(nodes, original, replacement):
  function _eliminate_iterators (line 203) | def _eliminate_iterators(iterators):
  function _mark_invalidated (line 222) | def _mark_invalidated(node):
  function _is_invalidated (line 226) | def _is_invalidated(node):
  function _remove_unused (line 230) | def _remove_unused(unused):
  function _collect_slots (line 234) | def _collect_slots(ast):
  function _eliminate_multres (line 241) | def _eliminate_multres(ast):
  class _MultresEliminator (line 246) | class _MultresEliminator(traverse.Visitor):
    method __init__ (line 247) | def __init__(self):
    method leave_assignment (line 250) | def leave_assignment(self, node):
    method _process_multres_in_list (line 277) | def _process_multres_in_list(self, nodes_list):
    method visit_function_call (line 289) | def visit_function_call(self, node):
    method visit_return (line 292) | def visit_return(self, node):
  class _SlotReference (line 296) | class _SlotReference():
    method __init__ (line 297) | def __init__(self):
  class _SlotInfo (line 302) | class _SlotInfo():
    method __init__ (line 303) | def __init__(self):
  class _SlotsCollector (line 313) | class _SlotsCollector(traverse.Visitor):
    class _State (line 314) | class _State():
      method __init__ (line 315) | def __init__(self):
    method __init__ (line 321) | def __init__(self):
    method _state (line 333) | def _state(self):
    method _push_state (line 336) | def _push_state(self):
    method _pop_state (line 339) | def _pop_state(self):
    method _commit_info (line 342) | def _commit_info(self, info):
    method _commit_slot (line 350) | def _commit_slot(self, slot, node):
    method _register_slot (line 362) | def _register_slot(self, slot, node):
    method _register_all_slots (line 372) | def _register_all_slots(self, node, slots):
    method _commit_all_slots (line 382) | def _commit_all_slots(self, slots, node):
    method _register_slot_reference (line 389) | def _register_slot_reference(self, slot, node):
    method visit_assignment (line 405) | def visit_assignment(self, node):
    method leave_assignment (line 411) | def leave_assignment(self, node):
    method visit_identifier (line 414) | def visit_identifier(self, node):
    method visit_function_definition (line 420) | def visit_function_definition(self, node):
    method leave_function_definition (line 424) | def leave_function_definition(self, node):
    method leave_block (line 427) | def leave_block(self, node):
    method visit_iterator_warp (line 433) | def visit_iterator_warp(self, node):
    method visit_numeric_loop_warp (line 436) | def visit_numeric_loop_warp(self, node):
    method _visit_node (line 441) | def _visit_node(self, handler, node):
    method _leave_node (line 446) | def _leave_node(self, handler, node):
    method _visit (line 451) | def _visit(self, node):
  function _cleanup_invalid_nodes (line 458) | def _cleanup_invalid_nodes(ast):
  class _TreeCleanup (line 462) | class _TreeCleanup(traverse.Visitor):
    method visit_block (line 463) | def visit_block(self, node):

FILE: ljd/ast/traverse.py
  class Visitor (line 1) | class Visitor():
    method __init__ (line 2) | def __init__(self):
    method visit_function_definition (line 7) | def visit_function_definition(self, node):
    method leave_function_definition (line 10) | def leave_function_definition(self, node):
    method visit_table_constructor (line 15) | def visit_table_constructor(self, node):
    method leave_table_constructor (line 18) | def leave_table_constructor(self, node):
    method visit_table_record (line 21) | def visit_table_record(self, node):
    method leave_table_record (line 24) | def leave_table_record(self, node):
    method visit_array_record (line 27) | def visit_array_record(self, node):
    method leave_array_record (line 30) | def leave_array_record(self, node):
    method visit_assignment (line 35) | def visit_assignment(self, node):
    method leave_assignment (line 38) | def leave_assignment(self, node):
    method visit_binary_operator (line 43) | def visit_binary_operator(self, node):
    method leave_binary_operator (line 46) | def leave_binary_operator(self, node):
    method visit_unary_operator (line 49) | def visit_unary_operator(self, node):
    method leave_unary_operator (line 52) | def leave_unary_operator(self, node):
    method visit_statements_list (line 57) | def visit_statements_list(self, node):
    method leave_statements_list (line 60) | def leave_statements_list(self, node):
    method visit_identifiers_list (line 63) | def visit_identifiers_list(self, node):
    method leave_identifiers_list (line 66) | def leave_identifiers_list(self, node):
    method visit_records_list (line 69) | def visit_records_list(self, node):
    method leave_records_list (line 72) | def leave_records_list(self, node):
    method visit_variables_list (line 75) | def visit_variables_list(self, node):
    method leave_variables_list (line 78) | def leave_variables_list(self, node):
    method visit_expressions_list (line 81) | def visit_expressions_list(self, node):
    method leave_expressions_list (line 84) | def leave_expressions_list(self, node):
    method visit_identifier (line 89) | def visit_identifier(self, node):
    method leave_identifier (line 92) | def leave_identifier(self, node):
    method visit_multres (line 95) | def visit_multres(self, node):
    method leave_multres (line 98) | def leave_multres(self, node):
    method visit_table_element (line 101) | def visit_table_element(self, node):
    method leave_table_element (line 104) | def leave_table_element(self, node):
    method visit_vararg (line 107) | def visit_vararg(self, node):
    method leave_vararg (line 110) | def leave_vararg(self, node):
    method visit_function_call (line 113) | def visit_function_call(self, node):
    method leave_function_call (line 116) | def leave_function_call(self, node):
    method visit_if (line 121) | def visit_if(self, node):
    method leave_if (line 124) | def leave_if(self, node):
    method visit_elseif (line 127) | def visit_elseif(self, node):
    method leave_elseif (line 130) | def leave_elseif(self, node):
    method visit_block (line 135) | def visit_block(self, node):
    method leave_block (line 138) | def leave_block(self, node):
    method visit_unconditional_warp (line 141) | def visit_unconditional_warp(self, node):
    method leave_unconditional_warp (line 144) | def leave_unconditional_warp(self, node):
    method visit_conditional_warp (line 147) | def visit_conditional_warp(self, node):
    method leave_conditional_warp (line 150) | def leave_conditional_warp(self, node):
    method visit_iterator_warp (line 153) | def visit_iterator_warp(self, node):
    method leave_iterator_warp (line 156) | def leave_iterator_warp(self, node):
    method visit_numeric_loop_warp (line 159) | def visit_numeric_loop_warp(self, node):
    method leave_numeric_loop_warp (line 162) | def leave_numeric_loop_warp(self, node):
    method visit_end_warp (line 165) | def visit_end_warp(self, node):
    method leave_end_warp (line 168) | def leave_end_warp(self, node):
    method visit_return (line 173) | def visit_return(self, node):
    method leave_return (line 176) | def leave_return(self, node):
    method visit_break (line 179) | def visit_break(self, node):
    method leave_break (line 182) | def leave_break(self, node):
    method visit_while (line 187) | def visit_while(self, node):
    method leave_while (line 190) | def leave_while(self, node):
    method visit_repeat_until (line 193) | def visit_repeat_until(self, node):
    method leave_repeat_until (line 196) | def leave_repeat_until(self, node):
    method visit_numeric_for (line 199) | def visit_numeric_for(self, node):
    method leave_numeric_for (line 202) | def leave_numeric_for(self, node):
    method visit_iterator_for (line 205) | def visit_iterator_for(self, node):
    method leave_iterator_for (line 208) | def leave_iterator_for(self, node):
    method visit_constant (line 213) | def visit_constant(self, node):
    method leave_constant (line 216) | def leave_constant(self, node):
    method visit_primitive (line 219) | def visit_primitive(self, node):
    method leave_primitive (line 222) | def leave_primitive(self, node):
    method _visit_node (line 227) | def _visit_node(self, handler, node):
    method _leave_node (line 230) | def _leave_node(self, handler, node):
    method _visit (line 235) | def _visit(self, node):
    method _visit_list (line 240) | def _visit_list(self, nodes_list):
  function traverse (line 247) | def traverse(visitor, node):

FILE: ljd/ast/unwarper.py
  class _StatementsCollector (line 20) | class _StatementsCollector(traverse.Visitor):
    method __init__ (line 21) | def __init__(self):
    method visit_statements_list (line 24) | def visit_statements_list(self, node):
  function unwarp (line 29) | def unwarp(node):
  function _run_step (line 41) | def _run_step(step, node, **kargs):
  function _gather_statements_lists (line 51) | def _gather_statements_lists(node):
  function _glue_flows (line 57) | def _glue_flows(node):
  function _unwarp_expressions (line 83) | def _unwarp_expressions(blocks):
  function _find_endest_end (line 129) | def _find_endest_end(expressions):
  function _unwarp_ifs (line 139) | def _unwarp_ifs(blocks, top_end=None, topmost_end=None):
  function _extract_if_body (line 176) | def _extract_if_body(start_index, blocks, topmost_end):
  function _unwarp_expressions_pack (line 192) | def _unwarp_expressions_pack(blocks, pack):
  function _split_by_slot_use (line 244) | def _split_by_slot_use(statements, min_i, warp, slot):
  function _extract_destination_slots (line 275) | def _extract_destination_slots(statement):
  function _gather_slots (line 288) | def _gather_slots(node):
  function _find_expressions (line 304) | def _find_expressions(start, body, end):
  function _find_subexpressions (line 447) | def _find_subexpressions(start, body):
  function _get_simple_local_assignment_slot (line 460) | def _get_simple_local_assignment_slot(start, body, end):
  function _find_expression_slot (line 473) | def _find_expression_slot(body):
  function _unwarp_logical_expression (line 486) | def _unwarp_logical_expression(start, end, body):
  function _compile_expression (line 504) | def _compile_expression(body, end, true, false):
  function _unwarp_expression (line 570) | def _unwarp_expression(body, end, true, false):
  function _get_target (line 691) | def _get_target(warp, allow_end=False):
  function _set_target (line 702) | def _set_target(warp, target):
  function _get_operator (line 710) | def _get_operator(block, true, end):
  function _get_last_assignment_source (line 740) | def _get_last_assignment_source(block):
  function _get_and_remove_last_assignment_source (line 749) | def _get_and_remove_last_assignment_source(block):
  function _compile_subexpression (line 755) | def _compile_subexpression(subexpression, operator,
  function _is_inverted (line 785) | def _is_inverted(warp, true, end):
  function _invert (line 813) | def _invert(expression):
  function _get_terminators (line 836) | def _get_terminators(body):
  function _assemble_expression (line 868) | def _assemble_expression(parts):
  function _make_explicit_subexpressions (line 901) | def _make_explicit_subexpressions(parts):
  function _unwarp_if_statement (line 936) | def _unwarp_if_statement(start, body, end, topmost_end):
  function _extract_if_expression (line 989) | def _extract_if_expression(start, body, end, topmost_end):
  function _search_expression_end (line 1034) | def _search_expression_end(expression, falses):
  function _find_branching_end (line 1055) | def _find_branching_end(blocks, topmost_end):
  function _remove_processed_blocks (line 1076) | def _remove_processed_blocks(blocks, boundaries):
  function _unwarp_loops (line 1099) | def _unwarp_loops(blocks, repeat_until):
  function _cleanup_breaks_and_if_ends (line 1139) | def _cleanup_breaks_and_if_ends(loops, blocks):
  function _replace_targets (line 1200) | def _replace_targets(blocks, original, replacement):
  function _unwarp_loop (line 1223) | def _unwarp_loop(start, end, body):
  function _create_next_block (line 1356) | def _create_next_block(original):
  function _set_flow_to (line 1366) | def _set_flow_to(block, target):
  function _set_end (line 1372) | def _set_end(block):
  function _is_flow (line 1383) | def _is_flow(warp):
  function _is_jump (line 1388) | def _is_jump(warp):
  function _fix_nested_ifs (line 1393) | def _fix_nested_ifs(blocks, start):
  function _fix_expression (line 1413) | def _fix_expression(blocks, start, end):
  function _gather_possible_ends (line 1424) | def _gather_possible_ends(block):
  function _unwarp_breaks (line 1442) | def _unwarp_breaks(start, blocks, next_block):
  function _find_all_loops (line 1556) | def _find_all_loops(blocks, repeat_until):
  function _get_previous_block (line 1628) | def _get_previous_block(block, blocks):

FILE: ljd/ast/validator.py
  class TypeRestriction (line 9) | class TypeRestriction():
    method __init__ (line 10) | def __init__(self, default, specific):
    method check (line 18) | def check(self, node):
  class Visitor (line 70) | class Visitor(traverse.Visitor):
    method __init__ (line 71) | def __init__(self, warped=True):
    method _set_restrictions (line 76) | def _set_restrictions(self, default, specific={}):
    method visit_function_definition (line 81) | def visit_function_definition(self, node):
    method visit_table_constructor (line 89) | def visit_table_constructor(self, node):
    method visit_array_record (line 92) | def visit_array_record(self, node):
    method visit_table_record (line 95) | def visit_table_record(self, node):
    method visit_assignment (line 100) | def visit_assignment(self, node):
    method visit_binary_operator (line 115) | def visit_binary_operator(self, node):
    method visit_unary_operator (line 140) | def visit_unary_operator(self, node):
    method visit_statements_list (line 149) | def visit_statements_list(self, node):
    method visit_identifiers_list (line 157) | def visit_identifiers_list(self, node):
    method visit_records_list (line 161) | def visit_records_list(self, node):
    method visit_variables_list (line 178) | def visit_variables_list(self, node):
    method visit_expressions_list (line 181) | def visit_expressions_list(self, node):
    method visit_identifier (line 186) | def visit_identifier(self, node):
    method visit_table_element (line 195) | def visit_table_element(self, node):
    method visit_function_call (line 198) | def visit_function_call(self, node):
    method visit_if (line 206) | def visit_if(self, node):
    method visit_elseif (line 213) | def visit_elseif(self, node):
    method visit_block (line 221) | def visit_block(self, node):
    method visit_unconditional_warp (line 234) | def visit_unconditional_warp(self, node):
    method visit_conditional_warp (line 240) | def visit_conditional_warp(self, node):
    method visit_iterator_warp (line 253) | def visit_iterator_warp(self, node):
    method visit_numeric_loop_warp (line 264) | def visit_numeric_loop_warp(self, node):
    method visit_return (line 275) | def visit_return(self, node):
    method visit_while (line 280) | def visit_while(self, node):
    method visit_repeat_until (line 286) | def visit_repeat_until(self, node):
    method visit_numeric_for (line 292) | def visit_numeric_for(self, node):
    method visit_iterator_for (line 299) | def visit_iterator_for(self, node):
    method visit_constant (line 308) | def visit_constant(self, node):
    method visit_primitive (line 314) | def visit_primitive(self, node):
    method _visit (line 321) | def _visit(self, node):
  function validate (line 336) | def validate(ast, warped=True):

FILE: ljd/bytecode/constants.py
  class Table (line 10) | class Table():
    method __init__ (line 11) | def __init__(self):
  class Constants (line 19) | class Constants():
    method __init__ (line 20) | def __init__(self):

FILE: ljd/bytecode/debuginfo.py
  class VariableInfo (line 6) | class VariableInfo():
    method __init__ (line 10) | def __init__(self):
  class DebugInformation (line 17) | class DebugInformation():
    method __init__ (line 18) | def __init__(self):
    method lookup_line_number (line 23) | def lookup_line_number(self, addr):
    method lookup_local_name (line 29) | def lookup_local_name(self, addr, slot):
    method lookup_upvalue_name (line 42) | def lookup_upvalue_name(self, slot):

FILE: ljd/bytecode/helpers.py
  function get_jump_destination (line 1) | def get_jump_destination(addr, instruction):
  function set_jump_destination (line 5) | def set_jump_destination(addr, instruction, value):

FILE: ljd/bytecode/instructions.py
  class _Instruction (line 46) | class _Instruction():
    method __init__ (line 47) | def __init__(self, definition):
  class _IDef (line 61) | class _IDef():
    method __init__ (line 64) | def __init__(self, name, A_type, B_type, CD_type, description):
    method __call__ (line 78) | def __call__(self):

FILE: ljd/bytecode/prototype.py
  class Flags (line 9) | class Flags():
    method __init (line 10) | def __init(self):
  class Prototype (line 18) | class Prototype():
    method __init__ (line 19) | def __init__(self):

FILE: ljd/lua/writer.py
  class _State (line 40) | class _State():
    method __init__ (line 41) | def __init__(self):
  class Visitor (line 47) | class Visitor(traverse.Visitor):
    method __init__ (line 48) | def __init__(self):
    method _start_statement (line 58) | def _start_statement(self, statement):
    method _end_statement (line 63) | def _end_statement(self, statement):
    method _end_line (line 68) | def _end_line(self):
    method _start_block (line 71) | def _start_block(self):
    method _end_block (line 74) | def _end_block(self):
    method _write (line 77) | def _write(self, fmt, *args, **kargs):
    method _state (line 80) | def _state(self):
    method _push_state (line 83) | def _push_state(self):
    method _pop_state (line 86) | def _pop_state(self):
    method visit_function_definition (line 91) | def visit_function_definition(self, node):
    method visit_table_constructor (line 125) | def visit_table_constructor(self, node):
    method visit_table_record (line 166) | def visit_table_record(self, node):
    method visit_assignment (line 186) | def visit_assignment(self, node):
    method _is_variable (line 223) | def _is_variable(self, node):
    method _is_global (line 229) | def _is_global(self, node):
    method _is_builtin (line 235) | def _is_builtin(self, node):
    method _is_valid_name (line 241) | def _is_valid_name(self, key):
    method visit_binary_operator (line 249) | def visit_binary_operator(self, node):
    method visit_unary_operator (line 335) | def visit_unary_operator(self, node):
    method visit_statements_list (line 356) | def visit_statements_list(self, node):
    method leave_statements_list (line 362) | def leave_statements_list(self, node):
    method _visit_comma_separated_list (line 368) | def _visit_comma_separated_list(self, node):
    method visit_records_list (line 380) | def visit_records_list(self, node):
    method visit_identifier (line 398) | def visit_identifier(self, node):
    method visit_multres (line 404) | def visit_multres(self, node):
    method visit_table_element (line 407) | def visit_table_element(self, node):
    method visit_vararg (line 446) | def visit_vararg(self, node):
    method visit_function_call (line 449) | def visit_function_call(self, node):
    method visit_if (line 494) | def visit_if(self, node):
    method visit_elseif (line 522) | def visit_elseif(self, node):
    method visit_block (line 535) | def visit_block(self, node):
    method visit_unconditional_warp (line 555) | def visit_unconditional_warp(self, node):
    method visit_conditional_warp (line 565) | def visit_conditional_warp(self, node):
    method visit_iterator_warp (line 590) | def visit_iterator_warp(self, node):
    method visit_numeric_loop_warp (line 607) | def visit_numeric_loop_warp(self, node):
    method visit_return (line 624) | def visit_return(self, node):
    method visit_break (line 633) | def visit_break(self, node):
    method visit_while (line 642) | def visit_while(self, node):
    method visit_repeat_until (line 656) | def visit_repeat_until(self, node):
    method visit_numeric_for (line 669) | def visit_numeric_for(self, node):
    method visit_iterator_for (line 687) | def visit_iterator_for(self, node):
    method visit_constant (line 705) | def visit_constant(self, node):
    method visit_primitive (line 731) | def visit_primitive(self, node):
    method _skip (line 739) | def _skip(self, node):
    method _visit (line 742) | def _visit(self, node):
  function write (line 760) | def write(fd, ast):
  function _get_next_significant (line 770) | def _get_next_significant(queue, i):
  function _process_queue (line 787) | def _process_queue(fd, queue):

FILE: ljd/pseudoasm/constants.py
  function write_tables (line 8) | def write_tables(writer, prototype):
  function _write_table (line 18) | def _write_table(writer, index, table):
  function _translate_element (line 42) | def _translate_element(element):

FILE: ljd/pseudoasm/instructions.py
  class _State (line 16) | class _State():
    method __init__ (line 17) | def __init__(self, writer, prototype, instructions):
  function write (line 25) | def write(writer, prototype):
  function _write_instruction (line 47) | def _write_instruction(writer, addr, line, instruction):
  function _write_function (line 61) | def _write_function(writer, addr, line, instruction):
  function _translate_description (line 83) | def _translate_description(writer, addr, line, instruction):
  function _translate (line 92) | def _translate(writer, addr, value, attr_type):
  function _lookup_variable_name (line 134) | def _lookup_variable_name(writer, addr, slot):
  function _lookup_variable_name_step (line 146) | def _lookup_variable_name_step(writer, addr, slot):
  function _translate_standard (line 207) | def _translate_standard(writer, addr, line, instruction):
  function _translate_normal (line 224) | def _translate_normal(writer, description, addr, line, instruction):
  function _translate_concat (line 230) | def _translate_concat(writer, description, addr, line, instruction):
  function _translate_nil (line 246) | def _translate_nil(writer, description, addr, line, instruction):
  function _translate_table_str_op (line 260) | def _translate_table_str_op(writer, description, addr, line, instruction):
  function _translate_new_table (line 268) | def _translate_new_table(writer, description, addr, line, instruction):
  function _translate_mass_set (line 283) | def _translate_mass_set(writer, description, addr, line, instruction):
  function _translate_varg_call (line 297) | def _translate_varg_call(writer, description, addr, line, instruction):
  function _translate_call (line 324) | def _translate_call(writer, description, addr, line, instruction):
  function _translate_varg_tailcall (line 351) | def _translate_varg_tailcall(writer, description, addr, line, instruction):
  function _translate_tailcall (line 370) | def _translate_tailcall(writer, description, addr, line, instruction):
  function _translate_iterator (line 389) | def _translate_iterator(writer, description, addr, line, instruction):
  function _translate_vararg (line 420) | def _translate_vararg(writer, description, addr, line, instruction):
  function _translate_return_mult (line 440) | def _translate_return_mult(writer, description, addr, line, instruction):
  function _translate_return_many (line 457) | def _translate_return_many(writer, description, addr, line, instruction):
  function _translate_return_one (line 474) | def _translate_return_one(writer, description, addr, line, instruction):
  function _translate_for_init (line 480) | def _translate_for_init(writer, description, addr, line, instruction):
  function _translate_numeric_loop (line 495) | def _translate_numeric_loop(writer, description, addr, line, instruction):
  function _translate_iter_loop (line 511) | def _translate_iter_loop(writer, description, addr, line, instruction):
  function _init (line 677) | def _init():

FILE: ljd/pseudoasm/prototype.py
  function write (line 9) | def write(writer, prototype):
  function _write_header (line 16) | def _write_header(writer, prototype):
  function format_header (line 20) | def format_header(writer, prototype):
  function write_body (line 33) | def write_body(writer, prototype):

FILE: ljd/pseudoasm/writer.py
  class _State (line 10) | class _State():
    method __init__ (line 11) | def __init__(self):
  function write (line 17) | def write(fd, header, prototype):
  function _write_header (line 29) | def _write_header(writer, header):

FILE: ljd/rawdump/code.py
  function read (line 173) | def read(parser):
  function _set_instruction_operands (line 196) | def _set_instruction_operands(parser, codeword, instruction):
  function _process_operand (line 215) | def _process_operand(parser, operand_type, operand):
  function _init (line 227) | def _init():

FILE: ljd/rawdump/constants.py
  function read (line 28) | def read(parser, constants):
  function _read_upvalue_references (line 38) | def _read_upvalue_references(parser, references):
  function _read_complex_constants (line 49) | def _read_complex_constants(parser, complex_constants):
  function _read_numeric_constants (line 86) | def _read_numeric_constants(parser, numeric_constants):
  function _read_number (line 106) | def _read_number(parser):
  function _read_signed_int (line 113) | def _read_signed_int(parser):
  function _assemble_number (line 119) | def _assemble_number(lo, hi):
  function _process_sign (line 129) | def _process_sign(number):
  function _read_table (line 136) | def _read_table(parser, table):
  function _read_table_item (line 158) | def _read_table_item(parser):

FILE: ljd/rawdump/debuginfo.py
  function read (line 31) | def read(parser, line_offset, debuginfo):
  function _read_lineinfo (line 41) | def _read_lineinfo(parser, line_offset, lineinfo):
  function _read_upvalue_names (line 58) | def _read_upvalue_names(parser, names):
  function _read_variable_infos (line 66) | def _read_variable_infos(parser, infos):

FILE: ljd/rawdump/header.py
  class Flags (line 17) | class Flags():
    method __init__ (line 18) | def __init__(self):
  class Header (line 24) | class Header():
    method __init__ (line 25) | def __init__(self):
  function read (line 32) | def read(state, header):
  function _check_magic (line 47) | def _check_magic(state):
  function _read_version (line 55) | def _read_version(state, header):
  function _read_flags (line 66) | def _read_flags(parser, header):
  function _read_name (line 90) | def _read_name(state, header):

FILE: ljd/rawdump/parser.py
  class _State (line 16) | class _State():
    method __init__ (line 17) | def __init__(self):
  function parse (line 23) | def parse(filename):
  function _read_header (line 60) | def _read_header(parser, header):
  function _read_prototypes (line 73) | def _read_prototypes(state, prototypes):

FILE: ljd/rawdump/prototype.py
  class _State (line 21) | class _State():
    method __init__ (line 22) | def __init__(self, parser):
  function read (line 40) | def read(parser, prototype):
  function _read_flags (line 72) | def _read_flags(parser, prototype):
  function _read_counts_and_sizes (line 97) | def _read_counts_and_sizes(parser, prototype):
  function _read_instructions (line 122) | def _read_instructions(parser, prototype):
  function _read_constants (line 151) | def _read_constants(parser, prototype):
  function _read_debuginfo (line 155) | def _read_debuginfo(stream, prototype):

FILE: ljd/util/binstream.py
  class BinStream (line 10) | class BinStream():
    method __init__ (line 11) | def __init__(self):
    method open (line 20) | def open(self, filename):
    method close (line 25) | def close(self):
    method eof (line 30) | def eof(self):
    method check_data_available (line 33) | def check_data_available(self, size=1):
    method read_bytes (line 36) | def read_bytes(self, size=1):
    method read_byte (line 46) | def read_byte(self):
    method read_zstring (line 57) | def read_zstring(self):
    method read_uleb128 (line 70) | def read_uleb128(self):
    method read_uleb128_from33bit (line 88) | def read_uleb128_from33bit(self):
    method read_uint (line 109) | def read_uint(self, size=4):

FILE: ljd/util/indentedstream.py
  class IndentedStream (line 8) | class IndentedStream():
    method __init__ (line 9) | def __init__(self, fd):
    method write_multiline (line 15) | def write_multiline(self, fmt, *args, **kargs):
    method start_line (line 36) | def start_line(self):
    method write (line 42) | def write(self, fmt="", *args, **kargs):
    method end_line (line 56) | def end_line(self):
    method write_line (line 63) | def write_line(self, *args, **kargs):
    method open_block (line 68) | def open_block(self, *args, **kargs):
    method close_block (line 74) | def close_block(self, *args, **kargs):

FILE: ljd/util/log.py
  function errprint (line 8) | def errprint(*args):

FILE: main.py
  function dump (line 40) | def dump(name, obj, level=0):
  function main (line 75) | def main():