def _handle_func_decls(self, tokens): """ Look for functions/subs declared anywhere, including inside the body of other functions/subs. """ # Look through each parsed item in the module for function/sub # definitions. for token in tokens: if (not hasattr(token, "accept")): continue func_visitor = function_defn_visitor() token.accept(func_visitor) for i in func_visitor.func_objects: # Sub to add? if isinstance(i, Sub): if (log.getEffectiveLevel() == logging.DEBUG): log.debug("saving sub decl: %r" % i.name) self.subs[i.name] = i # Func to add? elif isinstance(i, Function): if (log.getEffectiveLevel() == logging.DEBUG): log.debug("saving func decl: %r" % i.name) self.functions[i.name] = i
def eval(self, context, params=None): # Perform all of the const assignments first. for block in self.loose_lines: if (isinstance(block, Sub) or isinstance(block, Function) or isinstance(block, External_Function)): if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Skip loose line const eval of " + str(block)) continue if (isinstance(block, LooseLines)): context.global_scope = True do_const_assignments(block.block, context) context.global_scope = False # Emulate the loose line blocks (statements that appear outside sub/func # defs) in order. done_emulation = False for block in self.loose_lines: if (isinstance(block, Sub) or isinstance(block, Function) or isinstance(block, External_Function)): if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Skip loose line eval of " + str(block)) continue context.global_scope = True block.eval(context, params) context.global_scope = False done_emulation = True # Return if we ran anything. return done_emulation
def add_compiled_module(self, m): """ Add an already parsed and processed module. """ if (m is None): return self.modules.append(m) for name, _sub in m.subs.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing sub "%s" in globals' % name) self.globals[name.lower()] = _sub self.globals[name] = _sub for name, _function in m.functions.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing function "%s" in globals' % name) self.globals[name.lower()] = _function self.globals[name] = _function for name, _function in m.external_functions.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing external function "%s" in globals' % name) self.globals[name.lower()] = _function self.externals[name.lower()] = _function for name, _var in m.global_vars.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing global var "%s" = %s in globals (1)' % (name, str(_var))) if (isinstance(name, str)): self.globals[name.lower()] = _var if (isinstance(name, list)): self.globals[name[0].lower()] = _var self.types[name[0].lower()] = name[1]
def set_cached_value(arg, val): """Set the cached value of an all constant numeric expression. @param arg (VBA_Object object) The unresolved expression to cache. @param val (int, float, complex) The value of the resolved expression. """ # We should be setting this to a numeric expression if ((not isinstance(val, int)) and (not isinstance(val, float)) and (not isinstance(val, complex))): if (log.getEffectiveLevel() == logging.DEBUG): log.warning("Expression '" + safe_str_convert(val) + "' is a " + safe_str_convert(type(val)) + ", not an int. Not caching.") return # Don't cache things that contain Excel sheets or workbooks. if contains_excel(arg): return # We have a number. Cache it. arg_str = safe_str_convert(arg) try: if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Cache value of " + arg_str + " = " + safe_str_convert(val)) except UnicodeEncodeError: pass constant_expr_cache[arg_str] = val
def load_context(self, context): """ Load functions/subs defined in the module into the given context. """ for name, _sub in self.subs.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing sub "%s" in globals' % name) context.set(name, _sub) context.set(name, _sub, force_global=True) for name, _function in self.functions.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing function "%s" in globals' % name) context.set(name, _function) context.set(name, _function, force_global=True) for name, _function in self.external_functions.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing external function "%s" in globals' % name) context.set(name, _function) for name, _var in self.global_vars.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing global var "%s" = %s in globals (1)' % (name, str(_var))) if (isinstance(name, str)): context.set(name, _var) context.set(name, _var, force_global=True) if (isinstance(name, list)): context.set(name[0], _var, var_type=name[1]) context.set(name[0], _var, var_type=name[1], force_global=True)
def _handle_selected_item_read(arg, context, got_constant_math): """Handle reads of the selectedItem field of an object. @param arg (VBA_Object object) The item being evaluated. @param context (Context object) The current program state. @param got_constant_math (boolean) If True the given arg is an all numeric literal expression, if False it is not. @return (??) On success the evaluated item is returned, None is returned on error. """ # This is a hack to get values saved in the .rapt.Value field of objects. if (".selecteditem" in arg.lower()): try: tmp = arg.lower().replace(".selecteditem", ".rapt.value") if (log.getEffectiveLevel() == logging.DEBUG): log.debug("eval_arg: Try to get as " + tmp + "...") val = context.get(tmp) if got_constant_math: set_cached_value(arg, val) return val except KeyError: if (log.getEffectiveLevel() == logging.DEBUG): log.debug("eval_arg: Not found as .rapt.value.") # Not handled. return None
def add_compiled_module(self, m, stream): """Add an already parsed and processed module. @param m (Module object) The parsed object. @param stream (str) The OLE stream name containing the module. """ if (m is None): return self.modules.append(m) for name, _sub in m.subs.items(): # Append the stream name for duplicate subs if (name in self.globals): new_name = safe_str_convert(stream) + "::" + safe_str_convert( name) log.warn("Renaming duplicate function " + name + " to " + new_name) name = new_name # Save the sub. if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing sub "%s" in globals' % name) self.globals[name.lower()] = _sub self.globals[name] = _sub # Functions. for name, _function in m.functions.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing function "%s" in globals' % name) self.globals[name.lower()] = _function self.globals[name] = _function # Properties. for name, _prop in m.functions.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing property let "%s" in globals' % name) self.globals[name.lower()] = _prop self.globals[name] = _prop # External DLL functions. for name, _function in m.external_functions.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing external function "%s" in globals' % name) self.globals[name.lower()] = _function self.externals[name.lower()] = _function # Global variables. for name, _var in m.global_vars.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing global var "%s" = %s in globals (1)' % (name, safe_str_convert(_var))) if (isinstance(name, str)): self.globals[name.lower()] = _var if (isinstance(name, list)): self.globals[name[0].lower()] = _var self.types[name[0].lower()] = name[1]
def parse_next_line(self): # extract next line line = self.lines.pop(0) if (log.getEffectiveLevel() == logging.DEBUG): log.debug('Parsing line %d: %s' % (self.line_index, line.rstrip())) self.line_index += 1 # extract first two keywords in lowercase, for quick matching line_keywords = line.lower().split(None, 2) if (log.getEffectiveLevel() == logging.DEBUG): log.debug('line_keywords: %r' % line_keywords) # ignore empty lines if len(line_keywords) == 0 or line_keywords[0].startswith("'"): return self.line_index - 1, line, None return self.line_index - 1, line, line_keywords
def eval(self, context, params=None): # NOTE: in the specification, the parameter is expected to be an integer # But in reality, VBA accepts a string containing the representation # of an integer in decimal, hexadecimal or octal form. # It also ignores leading and trailing spaces. # Examples: Chr("65"), Chr("&65 "), Chr(" &o65"), Chr(" &H65") # => need to parse the string as integer # It also looks like floating point numbers are allowed. # First, eval the argument: param = eval_arg(self.arg, context) # Get the ordinal value. if isinstance(param, basestring): try: param = integer.parseString(param.strip())[0] except: log.error("%r is not a valid chr() value. Returning ''." % param) return '' elif isinstance(param, float): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('Chr: converting float %r to integer' % param) try: param = int(round(param)) except: log.error("%r is not a valid chr() value. Returning ''." % param) return '' elif isinstance(param, int): pass else: log.error('Chr: parameter must be an integer or a string, not %s' % type(param)) return '' # Figure out whether to create a unicode or ascii character. converter = chr if (param < 0): param = param * -1 if (param > 255): converter = unichr # Do the conversion. try: r = converter(param) if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Chr(" + str(param) + ") = " + r) return r except Exception as e: log.error(str(e)) log.error("%r is not a valid chr() value. Returning ''." % param) return ""
def eval(self, context, params=None): # Exit if an exit function statement was previously called. #if (context.exit_func): # return # Assign all const variables first. do_const_assignments(self.block, context) # Emulate the statements in the block. log.info("Emulating " + str(self) + " ...") context.global_scope = True for curr_statement in self.block: # Don't emulate declared functions. if (isinstance(curr_statement, Sub) or isinstance(curr_statement, Function) or isinstance(curr_statement, External_Function)): if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Skip loose line eval of " + str(curr_statement)) continue # Is this something we can emulate? if (not isinstance(curr_statement, VBA_Object)): continue curr_statement.eval(context, params=params) # Was there an error that will make us jump to an error handler? if (context.must_handle_error()): break context.clear_error() # Run the error handler if we have one and we broke out of the statement # loop with an error. context.handle_error(params)
def _read_from_excel(arg, context): """Try to evaluate an argument by reading from the loaded Excel spreadsheet. @param arg (VBA_Object object) The argument to evaluate. @param context (Context object) The current program state. @return (any) The result of the evaluation on success, None on failure. """ # Try handling reading value from an Excel spreadsheet cell. # ThisWorkbook.Sheets('YHRPN').Range('J106').Value if ("MemberAccessExpression" not in safe_str_convert(type(arg))): return None arg_str = safe_str_convert(arg) if (("sheets(" in arg_str.lower()) and (("range(" in arg_str.lower()) or ("cells(" in arg_str.lower()))): if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Try as Excel cell read...") return arg.eval(context) # Not handled. return None
def __init__(self, original_str, location, tokens): super(Concatenation, self).__init__(original_str, location, tokens) # extract argument from the tokens: # expected to be a tuple containing a list [a,'&',b,'&',c,...] self.arg = tokens[0][::2] if (log.getEffectiveLevel() == logging.DEBUG): log.debug('Concatenation: self.arg=%s' % repr(self.arg))
def eval(self, context, params=None): # The wildcard for matching propagates through operations. evaluated_args = eval_args(self.arg, context) if ((isinstance(evaluated_args, Iterable)) and ("**MATCH ANY**" in evaluated_args)): return "**MATCH ANY**" # return the floor division of all the arguments: try: if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Compute floor div " + str(self.arg)) return reduce(lambda x, y: x // y, coerce_args(evaluated_args, preferred_type="int")) except (TypeError, ValueError): # Try converting strings to ints. # TODO: Need to handle floats in strings. try: return reduce(lambda x, y: int(x) // int(y), evaluated_args) except Exception as e: if (str(e).strip() != "division by zero"): log.error( 'Impossible to divide arguments of different types. ' + str(e)) # TODO return 0 except ZeroDivisionError as e: context.set_error(str(e))
def _handle_shapes_access(r, arg, context, got_constant_math): """Finish handling a partially handled Shapes() access. @param arg (VBA_Object object) The item being evaluated. @param context (Context object) The current program state. @param got_constant_math (boolean) If True the given arg is an all numeric literal expression, if False it is not. @return (??) On success the evaluated item is returned, None is returned on error. """ # Is this a Shapes() access that still needs to be handled? poss_shape_txt = "" if isinstance(r, (VBA_Object, str)): poss_shape_txt = safe_str_convert(r) if ((poss_shape_txt.startswith("Shapes(")) or (poss_shape_txt.startswith("InlineShapes("))): if (log.getEffectiveLevel() == logging.DEBUG): log.debug("eval_arg: Handling intermediate Shapes() access for " + safe_str_convert(r)) r = eval_arg(r, context) if got_constant_math: set_cached_value(arg, r) return r # Not handled. return None
def eval(self, context, params=None): # The wildcard for matching propagates through operations. evaluated_args = eval_args(self.arg, context) if ((isinstance(evaluated_args, Iterable)) and ("**MATCH ANY**" in evaluated_args)): return "**MATCH ANY**" # return the exponentiation of all the arguments: try: if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Compute pow " + safe_str_convert(self.arg)) return reduce( lambda x, y: pow(x, y), vba_conversion.coerce_args(evaluated_args, preferred_type="int")) except (TypeError, ValueError): # Try converting strings to ints. # TODO: Need to handle floats in strings. try: return reduce(lambda x, y: pow(int(x), int(y)), evaluated_args) except Exception as e: log.error( 'Impossible to do exponentiation with arguments of different types. ' + safe_str_convert(e)) return 0
def load_excel_xlrd(data): """Read in an Excel file into an ExceBook object directly with the xlrd Excel library. @param data (str) The Excel file contents. @return (core.excel.ExceBook object) On success return the Excel spreadsheet as an ExcelBook object. Returns None on error. """ # Only use this on Office 97 Excel files. if (not filetype.is_office97_file(data, True)): log.warning("File is not an Excel 97 file. Not reading with xlrd2.") return None # It is Office 97. See if we can read it with xlrd2. try: if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Trying to load with xlrd...") r = xlrd.open_workbook(file_contents=data) return r except Exception as e: log.error("Reading in file as Excel with xlrd failed. " + str(e)) return None
def __init__(self, original_str, location, tokens): super(Chr, self).__init__(original_str, location, tokens) # extract argument from the tokens: # Here the arg is expected to be either an int or a VBA_Object self.arg = tokens[0] if (log.getEffectiveLevel() == logging.DEBUG): log.debug('parsed %r as %s' % (self, self.__class__.__name__))
def get_metadata_exif(filename): # Use exiftool to get the document metadata. output = None try: output = subprocess.check_output(["exiftool", filename]) except Exception as e: log.error("Cannot read metadata with exiftool. " + str(e)) return {} # Sanity check results. if (log.getEffectiveLevel() == logging.DEBUG): log.debug("exiftool output: '" + str(output) + "'") if (":" not in output): log.warning("Cannot read metadata with exiftool.") return {} # Store the metadata in an object. lines = output.split("\n") r = FakeMeta() for line in lines: line = line.strip() if ((len(line) == 0) or (":" not in line)): continue field = line[:line.index(":")].strip().lower() val = line[line.index(":") + 1:].strip().replace("...", "\r\n") setattr(r, field, val) # Done. return r
def eval(self, context, params=None): # The wildcard for matching propagates through operations. evaluated_args = eval_args(self.arg, context) if ((isinstance(evaluated_args, Iterable)) and ("**MATCH ANY**" in evaluated_args)): return "**MATCH ANY**" # return the and of all the arguments: try: if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Compute or " + str(self.arg)) return reduce(lambda x, y: x | y, coerce_args(evaluated_args, preferred_type="int")) except (TypeError, ValueError): # Try converting strings to ints. # TODO: Need to handle floats in strings. try: return reduce(lambda x, y: int(x) | int(y), evaluated_args) except: log.error('Impossible to or arguments of different types.') return 0 except RuntimeError as e: log.error("overflow trying eval or: %r" % self.arg) raise e
def eval(self, context, params=None): # return the environment variable name surrounded by % signs: # e.g. Environ("TEMP") => "%TEMP%" arg = eval_arg(self.arg, context=context) value = '%%%s%%' % arg if (log.getEffectiveLevel() == logging.DEBUG): log.debug('evaluating Environ(%s) => %r' % (arg, value)) return value
def add_compiled_module(self, m): """ Add an already parsed and processed module. """ if (m is None): return self.modules.append(m) for name, _sub in m.subs.items(): # Skip duplicate subs that look less interesting than the old one. if (name in self.globals): old_sub = self.globals[name] if (hasattr(old_sub, "statements")): if (len(_sub.statements) < len(old_sub.statements)): log.warning( "Sub " + str(name) + " is already defined. Skipping new definition.") continue if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing sub "%s" in globals' % name) self.globals[name.lower()] = _sub self.globals[name] = _sub for name, _function in m.functions.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing function "%s" in globals' % name) self.globals[name.lower()] = _function self.globals[name] = _function for name, _prop in m.functions.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing property let "%s" in globals' % name) self.globals[name.lower()] = _prop self.globals[name] = _prop for name, _function in m.external_functions.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing external function "%s" in globals' % name) self.globals[name.lower()] = _function self.externals[name.lower()] = _function for name, _var in m.global_vars.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing global var "%s" = %s in globals (1)' % (name, str(_var))) if (isinstance(name, str)): self.globals[name.lower()] = _var if (isinstance(name, list)): self.globals[name[0].lower()] = _var self.types[name[0].lower()] = name[1]
def eval(self, context, params=None): """ Evaluate the current value of the object. :param context: Context for the evaluation (local and global variables) :return: current value of the object """ if (log.getEffectiveLevel() == logging.DEBUG): log.debug(self)
def eval(self, context, params=None): # The wildcard for matching propagates through operations. evaluated_args = eval_args(self.arg, context) if ((isinstance(evaluated_args, Iterable)) and ("**MATCH ANY**" in evaluated_args)): return "**MATCH ANY**" # return the sum of all the arguments: # (Note: sum() is not applicable here, because it does not work for strings) # see https://docs.python.org/2/library/functions.html#reduce try: if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Compute sum (1) " + safe_str_convert(self.arg)) r = reduce( lambda x, y: x + y, vba_conversion.coerce_args(evaluated_args, preferred_type="int")) return r except (TypeError, ValueError): # NOTE: In VB you are not supposed to be able to add integers and strings. # However, there are maldocs that do this. If the strings are integer strings, # integer addition is performed. if (log.getEffectiveLevel() == logging.DEBUG): log.debug( 'Impossible to sum arguments of different types. Try converting strings to common type.' ) try: r = reduce(lambda x, y: int(x) + int(y), evaluated_args) return r except (TypeError, ValueError): # Punt and sum all arguments as strings. if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Compute sum (2) " + safe_str_convert(self.arg)) r = reduce( lambda x, y: safe_str_convert(x) + safe_str_convert(y), vba_conversion.coerce_args_to_str(evaluated_args)) return r except RuntimeError as e: log.error("overflow trying eval sum: %r" % self.arg) raise e
def set_cached_value(arg, val): """ Set the cached value of an all constant numeric expression. """ # We should be setting this to a numeric expression if ((not isinstance(val, int)) and (not isinstance(val, float)) and (not isinstance(val, complex))): if (log.getEffectiveLevel() == logging.DEBUG): log.warning("Expression '" + str(val) + "' is a " + str(type(val)) + ", not an int. Not caching.") return # We have a number. Cache it. arg_str = str(arg) try: if (log.getEffectiveLevel() == logging.DEBUG): log.debug("Cache value of " + arg_str + " = " + str(val)) except UnicodeEncodeError: pass constant_expr_cache[arg_str] = val
def load_context(self, context): """Load functions/subs defined in the module into the given context. The function/sub names will be associated with the function/sub definitions in the context. @param context (VBA_Context object) The context in which to load the functions/subs defined in the current module. """ for name, _sub in self.subs.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing sub "%s" in globals' % name) context.set(name, _sub) context.set(name, _sub, force_global=True) for name, _function in self.functions.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing function "%s" in globals' % name) context.set(name, _function) context.set(name, _function, force_global=True) for name, _prop in self.props.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing property let "%s" in globals' % name) context.set(name, _prop) context.set(name, _prop, force_global=True) for name, _function in self.external_functions.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing external function "%s" in globals' % name) context.set(name, _function) for name, _var in self.global_vars.items(): if (log.getEffectiveLevel() == logging.DEBUG): log.debug('(1) storing global var "%s" = %s in globals (1)' % (name, safe_str_convert(_var))) if (isinstance(name, str)): context.set(name, _var) context.set(name, _var, force_global=True) if (isinstance(name, list)): context.set(name[0], _var, var_type=name[1]) context.set(name[0], _var, var_type=name[1], force_global=True)
def _handle_nodetypedvalue_read(arg, context, got_constant_math): """Handle reads of the nodeTypedValue field of an object. @param arg (VBA_Object object) The item being evaluated. @param context (Context object) The current program state. @param got_constant_math (boolean) If True the given arg is an all numeric literal expression, if False it is not. @return (??) On success the evaluated item is returned, None is returned on error. """ # This is a hack to get values saved in the .text field of objects. # To do this properly we need to save "FOO.text" as a variable and # return the value of "FOO.text" when getting "FOO.nodeTypedValue". if ("nodetypedvalue" in arg.lower()): try: tmp = arg.lower().replace("nodetypedvalue", "text") if (log.getEffectiveLevel() == logging.DEBUG): log.debug("eval_arg: Try to get as " + tmp + "...") val = context.get(tmp) # It looks like maybe this magically does base64 decode? Try that. if (log.getEffectiveLevel() == logging.DEBUG): log.debug("eval_arg: Try base64 decode of '" + safe_str_convert(val) + "'...") val_decode = utils.b64_decode(val) if (val_decode is not None): if got_constant_math: set_cached_value(arg, val_decode) return val_decode except KeyError: if (log.getEffectiveLevel() == logging.DEBUG): log.debug("eval_arg: Not found as .text.") # Not handled. return None
def eval(self, context, params=None): # The wildcard for matching propagates through operations. evaluated_args = eval_args(self.arg, context) if ((isinstance(evaluated_args, Iterable)) and ("**MATCH ANY**" in evaluated_args)): return "**MATCH ANY**" # return the concatenation of all the arguments: # TODO: handle non-string args if (log.getEffectiveLevel() == logging.DEBUG): log.debug('Concatenation before eval: %r' % params) try: eval_params = evaluated_args eval_params = coerce_args_to_str(eval_params) if (log.getEffectiveLevel() == logging.DEBUG): log.debug('Concatenation after eval: %r' % eval_params) return ''.join(eval_params) except (TypeError, ValueError) as e: log.exception('Impossible to concatenate non-string arguments. ' + str(e)) # TODO return ''
def _handle_func_decls(self, tokens): """Look for functions/subs declared anywhere, including inside the body of other functions/subs. The function/sub declarations will be saved in the subs and functions fields of the current Module object. @param tokens (list) A list of pyparsing tokens representing a parsed Module. """ # Look through each parsed item in the module for function/sub # definitions. for token in tokens: if (not hasattr(token, "accept")): continue func_visitor = function_defn_visitor() token.accept(func_visitor) for i in func_visitor.func_objects: # Sub to add? if isinstance(i, Sub): if (log.getEffectiveLevel() == logging.DEBUG): log.debug("saving sub decl: %r" % i.name) self.subs[i.name] = i # Func to add? elif isinstance(i, Function): if (log.getEffectiveLevel() == logging.DEBUG): log.debug("saving func decl: %r" % i.name) self.functions[i.name] = i # Property Let or Get function to add? elif isinstance(i, (PropertyLet, PropertyGet)): if (log.getEffectiveLevel() == logging.DEBUG): log.debug("saving property let/get decl: %r" % i.name) self.props[i.name] = i
def _updated_vars_to_python(loop, context, indent): """Generate Python JIT code for saving the variables updated in a loop in Python. These updates are saved in the Python var_updates variable. @param loop (VBA_Object object) The loop for which to generate Python JIT code. @param context (Context object) The current program state. @param indent (int) The number of spaces to indent the generated Python code. @return (str) Python JIT code. """ import statements indent_str = " " * indent lhs_visitor = lhs_var_visitor() loop.accept(lhs_visitor) lhs_var_names = lhs_visitor.variables # Handle With variables if needed. if (context.with_prefix_raw is not None): lhs_var_names.add(safe_str_convert(context.with_prefix_raw)) # Handle For loop index variables if needed. if (isinstance(loop, statements.For_Statement)): lhs_var_names.add(safe_str_convert(loop.name)) var_dict_str = "{" first = True for var in lhs_var_names: py_var = utils.fix_python_overlap(var) if (not first): var_dict_str += ", " first = False var = var.replace(".", "") var_dict_str += '"' + var + '" : ' + py_var var_dict_str += "}" save_vals = indent_str + "try:\n" save_vals += indent_str + " " * 4 + "var_updates\n" save_vals += indent_str + " " * 4 + "var_updates.update(" + var_dict_str + ")\n" save_vals += indent_str + "except (NameError, UnboundLocalError):\n" save_vals += indent_str + " " * 4 + "var_updates = " + var_dict_str + "\n" save_vals += indent_str + 'var_updates["__shell_code__"] = core.vba_library.get_raw_shellcode_data()\n' save_vals = indent_str + "# Save the updated variables for reading into ViperMonkey.\n" + save_vals if (log.getEffectiveLevel() == logging.DEBUG): save_vals += indent_str + "print \"UPDATED VALS!!\"\n" save_vals += indent_str + "print var_updates\n" return save_vals
def eval(self, context, params=None): """Evaluate the current value of the object. @param context (Context object) Context for the evaluation (local and global variables). State updates will be reflected in the given context. @param params (list) Any parameters provided to the object. @return (any) The result of emulating the current object. """ context = context # pylint params = params # pylint if (log.getEffectiveLevel() == logging.DEBUG): log.debug(self)
return response else: log.error("Unhandled error {0}. If you get this error message something is broken in the intent module. Please raise an issue on https://github.com/ironman5366/W.I.L.L".format(str(parsed.values()[0]))) except Exception as e: log.error(e, 'error') return str(e) if __name__ == "__main__": '''Open logs, check log settings, and start the flask server and slack thread''' log.info(''' \ / | | | \ / | | | \ / | | | \ /\ / | | | \ / \ / | | | \/ \/ | ------------ ------------ ''') if log.getEffectiveLevel() == logging.DEBUG: debugval = True else: debugval = False log.info("Debug value is {0}".format(debugval)) log.info("Connecting to rtm socket") t = threading.Thread(target=slack) t.daemon=True #Kills the thread on program exit t.start() log.info("Starting flask server on localhost") print app.run(debug=debugval, use_reloader=False)