class Plain: def __init__(self): self.macro = Macro() def eat(self): pass def get_input(self): while True: print(f"[0]: Add waypoint") print(f"[1]: Edit waypoint") print(f"[2]: Delete waypoint") print(f"[3]: Show waypoints") print(f"[4]: Start donut") print(f"[5]: Quit") choice = int(input("What would you like to do: ")) if choice == 0: self.macro.add_waypoint() elif choice == 1: pass elif choice == 2: self.macro.show_waypoints() index = int(input("Waypoint to remove: ")) self.macro.delete_waypoint(index) elif choice == 3: self.macro.show_waypoints() elif choice == 4: self.macro.start() elif choice == 5: break
def __init__(self): pygame.init() self.screen_blit = pygame.display.set_mode(BLIT_SIZE) self.screen = pygame.Surface(WINDOW_SIZE) self.editor = Editor() self.sel = CharacterSelect(self.screen_blit).sel self.player = Player(self, 0, 0, idx=self.sel) self.camera = Camera() self.level = 0 self.black_screen = pygame.Surface(WINDOW_SIZE).convert() self.black_screen.fill((0, 0, 0)) self.black_alpha = 255.0 self.black_screen.set_alpha(self.black_alpha) self.black_shade = DOWN self.load_level() self.delay = 0 self.command_font = pygame.font.SysFont("monospace", 12) self.command_rectangles = {} test_macro = Macro() test_macro.add_block(Right()) test_macro.add_block(AttackRight()) test_macro.add_block(Left()) self.player.macros[0] = test_macro self.heart = pygame.image.load("heart.png") self.hheart = pygame.image.load("half_heart.png") self.eheart = pygame.image.load("empty_heart.png") self.heart_width = self.heart.get_width() self.mana_bar = pygame.image.load("mana_outer_bar.png") self.mana_fill = pygame.image.load("mana_inner_bar.png") self.display_mana = self.player.mana
def apply(self, line, state): result = OperationResult(line, False) # strings = [] # string start and end positions as StringPos instances trimmed = stripComments(line) output = line expanded_line = line # find the directive dirsearch = regex['directive'].search(trimmed) if dirsearch: directive = dirsearch.group(1) identifier = dirsearch.group(2) origline = output output = commentLine(line) if directive == "#define": macro = Macro(dirsearch, trimmed) if macro != None: state.macros[macro.name] = macro elif directive == "#undef": temp_macro = Macro(dirsearch, trimmed) if temp_macro.name in state.macros: del state.macros[temp_macro.name] else: warnings.add( state.row, "Trying to undefine a nonexistent macro " + temp_macro.name) elif directive == "#pragma": if state.args.verbose: print("pragma: " + identifier) state.args = handlePragma(identifier, state.args) elif directive == "#include": if state.args.filedir: self.handleInclude(state, trimmed, state.args.filedir) else: # we'll leave #ifdef, #ifndef and #else to the other operators output = origline else: if state.args.nomacros: return result visited = Stack() #for name in self.macros: output = expandAll(line, state.macros, visited, state) result.line = output return result
def parameters_replace(self): """ For values in the target_parameters dict, update the query_text Replace key with target_value Macros ## <DATEID> ==> today regardles of what replace with is ## <TABLEID-1> ==> Table_name_guid regardless of replace with """ for key, replacement_dict in self.target_parameters.iteritems(): macro = Macro(key_pattern=replacement_dict['search_for'], replace_value=str(replacement_dict['replace_with'])) self.query.query_text = macro.replace_text(self.query.query_text) date_macro = DateMacro() self.query.query_text = date_macro.replace_text(self.query.query_text)
def __init__(self, root): version = subprocess.check_output('git rev-list --count HEAD').decode( 'utf-8') root.title(f'Auto Disenchanter v{version}') root.protocol("WM_DELETE_WINDOW", self.on_closing) self.builder = builder = pygubu.Builder() builder.add_from_file('main_frame.ui') builder.get_object('main_frame', root) builder.connect_callbacks(self) self.builder_wrapper = Builder(builder) self.root = root self.logger = TkinterLogger(self.builder, '%H:%M:%S') self.settings = get_settings(self.logger, debug=True) self.logger.log_format = self.settings.log_time_format self.macro = Macro(self.logger, self.settings) self.incidents = Incidents(self.logger, self.settings) self.incidents.start_thread() root.resizable(False, False) root.wm_attributes("-topmost", 1) state = load_state() if state is not None and 'options' in state: self.builder_wrapper.init_checkboxes(state['options']) else: self.builder_wrapper.init_checkboxes(dict.fromkeys(OPTIONS, False)) if state is not None and 'accounts' in state: self.accounts = state['accounts'] self.builder_wrapper.set_treeview('accounts', self.accounts) else: self.accounts = []
def parameters_replace(self): """ For values in the target_parameters dict, update the query_text Replace key with target_value Macros ## <DATEID> ==> today regardles of what replace with is ## <TABLEID-1> ==> Table_name_guid regardless of replace with """ for key, replacement_dict in self.target_parameters.iteritems(): macro = Macro( key_pattern=replacement_dict['search_for'], replace_value=str(replacement_dict['replace_with']) ) self.query.query_text = macro.replace_text(self.query.query_text) date_macro = DateMacro() self.query.query_text = date_macro.replace_text(self.query.query_text)
def __init__(self, master): LogWriter(self) import pygubu # pylint:disable=import-outside-toplevel self.accounts = [] self.master = master self.master.title('Auto watcher client') self.builder = builder = pygubu.Builder() self.builder.add_from_file('main_frame.ui') self.mainwindow = builder.get_object('main_frame', master) # self.master.protocol("WM_DELETE_WINDOW", self.on_closing) self.builder.connect_callbacks(self) self.init_checkboxes() self.macro = Macro(RiotConnection(), LeagueConnection())
def dispatch_macro(self, path): """ Execute custom macro @path to the custom macro file """ macro = Macro(path) for cmd in macro.commands: self.dispatch_command(cmd)
def create_data(self): # Write variables variables = ProjectVariables(self.data) variables.define_variable() files = ProjectFiles(self.data) files.write_variables() variables.define_project() variables.define_target() # Write Macro macros = Macro() macros.write_macro(self.data) # Write Output Variables variables.write_output() # Write Include Directories depends = Dependencies(self.data) if self.data['includes']: depends.write_include_dir() else: send('Include Directories is not set.', '') # Write Dependencies depends.write_dependencies() # Add additional code or not if self.data['additional_code'] is not None: files.add_additional_code(self.data['additional_code']) # Write Flags all_flags = Flags(self.data) all_flags.write_flags() # Write and add Files files.write_files() files.add_artefact() # Link with other dependencies depends.link_dependencies() # Close CMake file self.data['cmake'].close()
def get_macro(self): macro = Macro(len(self.tile_containers)) for i, container in enumerate(self.tile_containers): if container.tiles: macro.add_block(container.tiles[0], i) else: macro.add_block(False, i) return macro
def createMacro(self): newMacro = Macro(self.charIndex,self.page,self.slot) newMacro.name = self.guiName.getValue() newMacro.description = self.guiToolTip.getValue() hotkey = self.guiHotkey.getValue() if hotkey == 'None': newMacro.hotkey = '' else: newMacro.hotkey = hotkey newMacro.icon = self.icon newMacro.waitAll = int(self.guiWaitAll.getValue()) == 1 try: manualDelay = int(self.guiManualDelay.getValue) if manualDelay < 0: manualDelay = 0 except: manualDelay = 0 newMacro.manualDelay = manualDelay for lineIndex in xrange(10): lineCommand = self.guiLines[lineIndex].getValue().lstrip().rstrip() mandatory = int(self.guiMandatory[lineIndex].getValue()) == 1 try: lineDelay = int(self.guiDelays[lineIndex].getValue()) if lineDelay < 0: lineDelay = 0 except: lineDelay = 0 if not lineCommand and not lineDelay: continue newMacroLine = MacroLine(lineCommand,mandatory,lineDelay) newMacro.insertMacroLine(lineIndex,newMacroLine) if newMacro.macroLineNum == 0: del newMacro return None return newMacro
return "# Copyright (c) %(year)s %(name)s" % a def countSpaces(line): for i in range(len(line)): if not line[i].isspace(): break return i if len(sys.argv) != 3: raise Exception("invalid command line syntax: %s" % ' '.join(map(repr, sys.argv))) (m4File, outFile) = sys.argv[1:] assert outFile != m4File m = Macro(m4File, computeSerialNumber=True) for i in range(len(m.description)): para = m.description[i] if para[0][0].isspace(): spaces = min(list(map(countSpaces, para))) if spaces > 1: m.description[i] = [' ' + l[spaces:] for l in para] url = "http://www.gnu.org/software/autoconf-archive/%s.html" % m.name lineLen = max(len(url) + 2, 75) m.url = "# %s\n# %s\n# %s" % ('=' * lineLen, (' ' * int( (lineLen - len(url)) / 2)) + url, '=' * lineLen) if m.__dict__.get("obsolete"): m.obsolete = "# OBSOLETE MACRO\n#\n" + '\n#\n'.join( map(formatParagraph, m.obsolete)) + "\n#\n" else: m.obsolete = ""
def getMacroKeys(macrodict, state): macrokeys = list(macrodict.keys()) linenum = Macro(None, "") linenum.name = "__LINE__" linenum.payload = str(state.row) linenum.nameregex = lineNameRegex filename= Macro(None, "") filename.name = "__FILE__" filename.payload = str('"' + state.filename + '"') filename.nameregex = fileNameRegex # temporary concatenation macro, must run LAST concat = Macro(None, "") concat.name = " ## " concat.payload = "" concat.nameregex = concatNameRegex macrodict[linenum.name] = linenum macrodict[filename.name] = filename macrodict[concat.name] = concat macrokeys = list(macrodict.keys()) macrokeys.append(linenum.name) macrokeys.append(filename.name) macrokeys.append(concat.name) return macrokeys
from macro import Macro stu_no = input('stu_no: ') pw = input('pw: ') grade = int(input('grade: ')) index = int(input('index: ')) method = int(input('method(0:전공, 1:장바구니): ')) flag = True while flag: macro = Macro(stu_no, pw, grade, index, method) try: flag = macro.run() except: macro.driver.close() flag = True
return "# Copyright (c) %(year)s %(name)s" % a def countSpaces(line): for i in range(len(line)): if not line[i].isspace(): break return i if len(sys.argv) != 3: raise Exception("invalid command line syntax: %s" % ' '.join(map(repr, sys.argv))) (m4File, outFile) = sys.argv[1:] assert outFile != m4File m = Macro(m4File) for i in range(len(m.description)): para = m.description[i] if para[0][0].isspace(): spaces = min(map(countSpaces, para)) if spaces > 1: m.description[i] = map(lambda l: ' ' + l[spaces:], para) url = "http://www.gnu.org/software/autoconf-archive/%s.html" % m.name lineLen = max(len(url) + 2, 75) m.url = "# %s\n# %s\n# %s" % ('=' * lineLen, (' ' * ( (lineLen - len(url)) / 2)) + url, '=' * lineLen) if m.__dict__.get("obsolete"): m.obsolete = "# OBSOLETE MACRO\n#\n" + '\n'.join( map(formatParagraph, m.obsolete)) + "\n#\n" else: m.obsolete = ""
def macro(bot, update, bot_globals): """user defined macro editor""" def no_flood(u): bot_globals['last_commands'][u] = time.time() - bot_globals['MESSAGE_TIMEOUT'] * 2 global MACROS message = update.message message_user = message.from_user.username if message.from_user.username is not None else message.from_user.name modes = {'eval': 'macro', 'text': 'macro', 'inline': 'macro', 'photo': 'macro', 'e621': 'macro', 'alias': 'macro', 'markov': 'macro', 'remove': 'write', 'hide': 'write', 'protect': 'write', 'clean': 'write', 'modify': 'write', 'rename': 'write', 'nsfw': 'write', 'contents': 'read', 'list': 'read'} err = 'Macro editor error:\n\n' expr = clean(message.text) if expr == '': update.message.text = '/macro_help' + bot.name.lower() no_flood(message_user) call_macro(bot, update, bot_globals) return args = expr.split() mode = args[0] name = '' if mode not in modes.keys(): message.reply_text(text=err + 'Unknown mode {}.'.format(mode)) return if len(args) > 1: name = args[1].split('\n')[0] elif not (modes[mode] == 'read' or mode == 'clean'): message.reply_text(text=err + 'Missing macro name.') return user = message_user.lower() if name in MACROS: if MACROS[name].protected and not is_mod(user) and not modes[mode] == 'read': message.reply_text(text=err + 'Macro {} is write protected.'.format(name)) return if len(args) > 2: expr = expr.replace(' '.join(args[:2]), '').strip() if len(args[1].split('\n')) == 2: expr = args[1].split('\n')[1] + expr else: expr = None if modes[mode] == 'macro' and name not in MACROS: if expr: try: MACROS.add(Macro(name, mode.upper(), expr, hidden=False, protected=is_mod(user), nsfw=False, creator={'user': message_user, 'chat': message.chat.id, 'chat_type': message.chat.type})) message.reply_text(text='{} macro "{}" created.'.format(mode, name)) except ValueError: message.reply_text(text=err + 'Bad photo url.') else: message.reply_text(text=err + 'Missing macro contents.') elif mode == 'modify': if name in MACROS and expr is not None: try: MACROS[name].content = expr message.reply_text(text='Macro "{}" modified.'.format(name)) except ValueError: message.reply_text(text=err + 'Bad photo url.') elif expr is None: message.reply_text(text=err + 'Missing macro text/code.') else: message.reply_text(text=err + 'No macro with name {}.'.format(name)) elif mode == 'clean': if is_mod(user): MACROS = MACROS.subset(protected=True) message.reply_text('Cleaned up macros.') else: message.reply_text(text=err + 'Only bot mods can do that.') elif mode == 'remove': if name in MACROS: MACROS.remove(name) message.reply_text(text='Macro "{}" removed.'.format(name)) else: message.reply_text(text=err + 'No macro with name {}.'.format(name)) elif mode == 'rename': if name in MACROS: new_name = args[1] MACROS[name].name = new_name message.reply_text(text='Macro "{}" renamed to {}'.format(name, new_name)) else: message.reply_text(text=err + 'No macro with name {}.'.format(name)) elif mode == 'list': if is_mod(user): filt = {i.split(':')[0]: i.split(':')[1] for i in args[1:] if ':' in i} include = {i.split(':')[0]: i.split(':')[1] for i in args[1:] if ':' in i and not i.startswith('-')} exclude = {i.split(':')[0][1:]: i.split(':')[1] for i in args[1:] if ':' in i and i.startswith('-')} try: macros = MACROS.subset(filt=include) if exclude: macros -= MACROS.subset(filt=exclude) except ValueError: message.reply_text(text=err + 'Unknown key in list filter: {}.'.format(filt)) return if macros: names = ((bot.name + ' ') * (m.variety == Macro.INLINE) + m.name for m in macros.sort()) message.reply_text('Macros:\n' + ', '.join(names)) else: message.reply_text(text=err + 'No macros found.') else: names = ((bot.name + ' ') * (m.variety == Macro.INLINE) + m.name for m in MACROS.subset()) message.reply_text('Visible macros:\n' + ', '.join(names)) elif mode == 'contents': if name in MACROS: if not MACROS[name].hidden or is_mod(user): message.reply_text('Contents of {} macro {}: {}' .format(MACROS[name].variety.lower(), name, MACROS[name].content)) else: message.reply_text(text=err + 'Macro {} contents hidden.'.format(name)) else: message.reply_text(text=err + 'No macro with name {}.'.format(name)) elif mode == 'hide': if name in MACROS: if is_mod(user): MACROS[name].hidden ^= True message.reply_text('Hide macro {}: {}'.format(name, MACROS[name].hidden)) else: message.reply_text(text=err + 'Only bot mods can hide or show macros.') else: message.reply_text(text=err + 'No macro with name {}.'.format(name)) elif mode == 'protect': if name in MACROS: if is_mod(user): MACROS[name].protected ^= True message.reply_text('Protect macro {}: {}'.format(name, MACROS[name].protected)) else: message.reply_text(text=err + 'Only bot mods can protect macros.') else: message.reply_text(text=err + 'No macro with name {}.'.format(name)) elif mode == 'nsfw': if name in MACROS: if is_mod(user): MACROS[name].nsfw ^= True message.reply_text('NSFW macro {}: {}'.format(name, MACROS[name].nsfw)) else: message.reply_text(text=err + 'Only bot mods can change macro nsfw state.') else: message.reply_text(text=err + 'No macro with name {}.'.format(name)) elif name in MACROS: message.reply_text(text=err + 'Macro already exists.')
from interface import window from PySimpleGUI import WIN_CLOSED # Ignore warnings filterwarnings("ignore") while True: event, values = window.read() if (event == "Exit") or (event == WIN_CLOSED): break # Trigger the comparison only if all the fields are filled if (event == "COMPARE") and all( [values[key] for key in ['LUA', 'AUTOCAD', 'BOX', 'PATH', 'NAME']]): window['LOGBOX'].reroute_stderr_to_here() window['LOGBOX'].reroute_stdout_to_here() file_name = values['NAME'] if '.' not in file_name: file_name += '.xlsx' output = join(values['PATH'], file_name) try: macro = Macro(values['LUA'], values['AUTOCAD'], values['BOX']) macro.get_indexes() macro.compare() macro.adjust_columns() macro.save_result(output) print('File successfully generated at: {}\n'.format(output)) except Exception as e: print(e, '\n') window.close()
class Application: ''' Main gui class ''' def __init__(self, master): LogWriter(self) import pygubu # pylint:disable=import-outside-toplevel self.accounts = [] self.master = master self.master.title('Auto watcher client') self.builder = builder = pygubu.Builder() self.builder.add_from_file('main_frame.ui') self.mainwindow = builder.get_object('main_frame', master) # self.master.protocol("WM_DELETE_WINDOW", self.on_closing) self.builder.connect_callbacks(self) self.init_checkboxes() self.macro = Macro(RiotConnection(), LeagueConnection()) # def on_closing(self): # ''' Kills the game processes when closing ''' # kill_process(LEAGUE_CLIENT_PROCESS) # kill_process(RIOT_CLIENT_PROCESS) # self.master.destroy() def init_checkboxes(self): ''' Checks all the checkboxes at the start ''' for option in OPTIONS: self.init_checkbox(option, True) def get_options(self): ''' Returns a list of options from checkboxes ''' options = [] for option in OPTIONS: if self.builder.get_object(option).instate(['selected']): options.append(option) return options def start(self): ''' Starts the macro thread ''' if self.accounts == []: logging.error('No accounts imported') return thread = threading.Thread(target=self.start_macro) thread.daemon = True thread.start() def start_macro(self): ''' Starts the main batch process ''' options = self.get_options() self.builder.get_object('start')['state'] = 'disabled' kill_process(LEAGUE_CLIENT_PROCESS) kill_process(RIOT_CLIENT_PROCESS) for idx, account in enumerate(self.accounts): tree = self.builder.get_object('accounts') child_id = tree.get_children()[idx] tree.focus(child_id) tree.selection_set(child_id) try: self.macro.do_macro(options, *account) except AuthenticationFailureException: logging.info('Account %s has invalid credentials', account[0]) except ConsentRequiredException: logging.info('Account %s needs consent', account[0]) progress = (idx + 1) * 100 // len(self.accounts) self.builder.get_object('progress')['value'] = progress self.builder.get_object('start')['state'] = 'normal' def import_csv(self): ''' Called when import button is pressed ''' self.accounts = import_csv() self.set_treeview('accounts', self.accounts) def export_csv(self): ''' Called when export button is pressed ''' if export_csv(self.accounts): logging.info('Successfully exported') def set_treeview(self, name, values): ''' Sets the treeview component ''' for value in values: self.set_row(name, value) def clear_treeview(self, name): ''' Clears the treeview component ''' tree = self.builder.get_object(name) tree.delete(*tree.get_children()) def set_row(self, name, value): ''' Sets a row value of a treeview component ''' self.builder.get_object(name).insert('', 'end', values=value) def init_checkbox(self, name, value): ''' Intializes a checkout component ''' self.builder.get_object(name).state(['!alternate']) if value: self.builder.get_object(name).state(['selected']) else: self.builder.get_object(name).state(['!selected']) def write_console(self, text): ''' Writes the messages to console textbox component ''' self.builder.get_object('console').insert(tk.END, text) self.builder.get_object('console').see('end')
def GetDefaultCommandAsMacro(cmd, charIndex, page, slot): from macro import Macro, MacroLine # Initialize the default macro to None, # in case we don't find the desired command. defaultMacro = None # Try to get the default command from the local dictionary. defaultCommand = DEFAULTCOMMANDS.get(cmd) # If it's not one of the default commands here, # check if it's a skill in the skillInfo dictionary # and create a macro from that. if not defaultCommand: skillInfo = GetSkillInfo(cmd, False) if skillInfo: defaultMacro = Macro(charIndex, page, slot) defaultMacro.name = cmd defaultMacro.icon = skillInfo.icon if not defaultMacro.icon.startswith("SPELLICON_"): defaultMacro.icon = "icons/%s" % defaultMacro.icon defaultMacro.description = skillInfo.name defaultMacro.appendMacroLine(MacroLine(command="/skill %s" % cmd)) else: defaultMacro = Macro(charIndex, page, slot) defaultMacro.name = defaultCommand.name defaultMacro.icon = defaultCommand.icon if not defaultMacro.icon.startswith("SPELLICON_"): defaultMacro.icon = "icons/%s" % defaultMacro.icon defaultMacro.description = defaultCommand.tooltip defaultMacro.appendMacroLine(MacroLine(command=defaultCommand.command)) # Return the default macro. return defaultMacro
def __init__(self): self.macro = Macro()
def apply(self, line, state): result = OperationResult(line, False) trimmed = stripComments(line) output = line expanded_line = line # find the directive dirsearch = regex['directive'].search(trimmed) if dirsearch: directive = dirsearch.group(1) identifier = dirsearch.group(2) output = commentLine(line) if directive == "#macro": if self.macro: warnings.add( "Trying to define multiline macro %s inside other macro %s" % (identifier, self.macro.name)) return result self.macro = Macro(dirsearch, trimmed) self.payload = "" elif directive == "#endmacro": #print ("macro %s ends") % (self.macro.name) self.macro.payload = self.macro.payload.rstrip('\n') self.multimacros[self.macro.name] = self.macro self.macro = None # TODO this is basically duplicate of the above functionality, clean it up elif directive == "#lambda": if self.macro: warnings.add( "Trying to define multiline lambda %s inside other macro %s" % (identifier, self.macro.name)) return result self.macro = Macro(dirsearch, trimmed) self.macro.oneliner = True self.payload = "" elif directive == "#endlambda": #print ("macro %s ends") % (self.macro.name) self.macro.payload = self.macro.payload.rstrip('\n') self.macro.payload = re.sub("\n+", r':', self.macro.payload) self.multimacros[self.macro.name] = self.macro self.macro = None elif directive == "#undef": temp_macro = Macro(dirsearch, trimmed) if temp_macro.name in self.multimacros: del self.multimacros[temp_macro.name] else: output = output else: if state.args.nomacros: return result # Expand collected macros only if not inside a multiline macro. if self.macro: line_trimmed = line if self.macro.oneliner: line_trimmed = line.lstrip(" ").lstrip("\t") self.macro.payload += line_trimmed output = commentLine(output) else: output = expandAll(line, self.multimacros, Stack(), state) result.line = output return result
def full_evaluate(expression, environment): """ Fully evaluate an expression until its basic representation """ while True: if is_thunk(expression): if not expression.is_evaluated: expression.is_evaluated = True expression.expression = full_evaluate(expression.expression, expression.environment) return expression.expression elif is_symbol(expression): expression = environment[expression] continue elif (is_atom(expression) or is_nil(expression) or is_procedure(expression) or is_macro(expression) or callable(expression)): return expression elif not is_pair(expression): raise ValueError("Cannot evaluate: %s" % expression) elif car(expression) == 'delay': if len(expression) != 2: raise SyntaxError( "Unexpected delay form: %s. Should be (delay <expression>)" % expression) return Thunk(cadr(expression), environment) elif car(expression) == 'defined?': if len(expression) != 2: raise SyntaxError( "Unexpected defined? form: %s. Should be (defined? <symbol>)" % expression) name = cadr(expression) if not is_symbol(name): raise SyntaxError( "Argument of defined? form should be a symbol. Evaluating: %s" % expression) return environment.exists(name) elif car(expression) == 'define': if len(expression) != 3: raise SyntaxError( "Unexpected define form: %s. Should be (define <symbol> <expression>)" % expression) name = cadr(expression) if not is_symbol(name): raise SyntaxError( "First argument of define form should be a symbol. Evaluating: %s" % expression) environment[name] = Thunk(caddr(expression), environment) return name elif car(expression) == 'quote': if len(expression) != 2: raise SyntaxError( "Unexpected quote form: %s. Should be (quote <expression>)" % expression) return cadr(expression) elif car(expression) == 'eval': if len(expression) != 2: raise SyntaxError( "Unexpected eval form: %s. Should be (eval <expression>)" % expression) expression = full_evaluate(cadr(expression), environment) continue elif car(expression) == 'if': if len(expression) != 4: raise SyntaxError( "Unexpected if form: %s. Should be (if <condition> <consequent> <alternative>)" % expression) condition = full_evaluate(cadr(expression), environment) expression = caddr(expression) if condition else cadddr(expression) continue elif car(expression) == 'lambda': if len(expression) < 3: raise SyntaxError( "Unexpected lambda form: %s. Should be (lambda (<param> ...) <expression> ...)" % expression) parameters = cadr(expression) if is_pair(parameters): current = parameters while is_pair(current): if not is_symbol(car(current)): raise SyntaxError( "Lambda parameters should be symbols. In %s" % expression) current = cdr(current) if not is_nil(current) and not is_symbol(current): raise SyntaxError( "Lambda optional parameter should be a symbol or nil. In %s" % expression) elif not is_symbol(parameters) and not is_nil(parameters): raise SyntaxError( "Lambda parameters should be a symbol or a list of zero or more. In %s" % expression) return Procedure( parameters, # parameters cddr(expression), # body (list of expressions) environment) elif car(expression) == 'macro': if len(expression) < 3: raise SyntaxError( "Unexpected define macro: %s. Should be (macro (<resword> ...) (<pattern> <transformation> ...) ...)" % expression) res_words = cadr(expression) rules = cddr(expression) if not is_nil(res_words) and not is_pair(res_words): raise SyntaxError( "Macro reserved words should be a list of symbols or nil. In %s" % expression) if is_pair(res_words): for word in res_words: if not is_symbol(word): raise SyntaxError( "Macro reserved words should all be symbols. In %s" % expression) for rule in rules: if len(rule) < 2: raise SyntaxError( "Macro rule should be in the form (<pattern> <expression> ...). In %s" % expression) return Macro( [(car(e), cdr(e)) for e in rules], # rules [] if not res_words else set(iter(res_words))) # reserved words else: # evaluate head operator = full_evaluate(car(expression), environment) if is_macro(operator): # evaluate recursively only the inner expressions (not the last) current = operator.transform(expression) while cdr(current) is not None: full_evaluate(car(current), environment) current = cdr(current) expression = car(current) continue else: # The unevaluated operands unev_operands = cdr(expression) if callable(operator): # evaluate each operand recursively operands = [ full_evaluate(e, environment) for e in unev_operands ] if unev_operands else [] # return the application of the built-in procedure return operator(make_list(operands)) elif is_procedure(operator): # create Thunks (promise to evaluate) for each operand unev_op_list = list( iter(unev_operands)) if unev_operands else [] proc_environment = Environment(parent=operator.environment) # if the lambda parameters is not in the format ( () [. <symbol>] ) # for taking zero or more arguments if len(operator.parameters) != 1 or not is_nil( operator.parameters[0]): for name in operator.parameters: try: # take next argument proc_environment[name] = Thunk( unev_op_list.pop(0), environment) except IndexError: raise ValueError( "Insufficient parameters for procedure %s. It should be at least %d" % (operator, len(operator.parameters))) if not is_nil(operator.optional): # the optional argument is something, that when # evaluated, yields the list of rest of the operands # evaluated proc_environment[operator.optional] = Thunk( cons(lambda x: x, make_list(unev_op_list)), environment) elif unev_op_list: raise ValueError( "Too much parameters for procedure %s. It should be %d." % (operator, len(operator.parameters))) # evaluate recursively only the inner procedure expressions # (not the last) current = operator.body while cdr(current) is not None: full_evaluate(car(current), proc_environment) current = cdr(current) environment = proc_environment expression = car(current) # continue not-recursively to evaluate the procedure's body # in the extended environment continue else: raise ValueError("Not an operator: %s, in expression: %s" % (operator, expression))
def createMacro(self): newMacro = Macro(self.charIndex, self.page, self.slot) newMacro.name = self.guiName.getValue() newMacro.description = self.guiToolTip.getValue() hotkey = self.guiHotkey.getValue() if hotkey == 'None': newMacro.hotkey = '' else: newMacro.hotkey = hotkey newMacro.icon = self.icon newMacro.waitAll = int(self.guiWaitAll.getValue()) == 1 try: manualDelay = int(self.guiManualDelay.getValue) if manualDelay < 0: manualDelay = 0 except: manualDelay = 0 newMacro.manualDelay = manualDelay for lineIndex in xrange(10): lineCommand = self.guiLines[lineIndex].getValue().lstrip().rstrip() mandatory = int(self.guiMandatory[lineIndex].getValue()) == 1 try: lineDelay = int(self.guiDelays[lineIndex].getValue()) if lineDelay < 0: lineDelay = 0 except: lineDelay = 0 if not lineCommand and not lineDelay: continue newMacroLine = MacroLine(lineCommand, mandatory, lineDelay) newMacro.insertMacroLine(lineIndex, newMacroLine) if newMacro.macroLineNum == 0: del newMacro return None return newMacro
def getMacroKeys(macrodict, state): macrokeys = list(macrodict.keys()) linenum = Macro(None, "") linenum.name = "__LINE__" linenum.payload = str(state.row) linenum.nameregex = lineNameRegex filename = Macro(None, "") filename.name = "__FILE__" filename.payload = str('"' + state.filename + '"') filename.nameregex = fileNameRegex # temporary concatenation macro, must run LAST concat = Macro(None, "") concat.name = " ## " concat.payload = "" concat.nameregex = concatNameRegex macrodict[linenum.name] = linenum macrodict[filename.name] = filename macrodict[concat.name] = concat macrokeys = list(macrodict.keys()) macrokeys.append(linenum.name) macrokeys.append(filename.name) macrokeys.append(concat.name) return macrokeys
def GetDefaultCommandAsMacro(cmd, charIndex, page, slot): from macro import Macro, MacroLine # Initialize the default macro to None, # in case we don't find the desired command. defaultMacro = None # Try to get the default command from the local dictionary. defaultCommand = DEFAULTCOMMANDS.get(cmd) # If it's not one of the default commands here, # check if it's a skill in the skillInfo dictionary # and create a macro from that. if not defaultCommand: skillInfo = GetSkillInfo(cmd, False) if skillInfo: defaultMacro = Macro(charIndex, page, slot) defaultMacro.name = cmd defaultMacro.icon = skillInfo.icon if not defaultMacro.icon.startswith('SPELLICON_'): defaultMacro.icon = 'icons/%s' % defaultMacro.icon defaultMacro.description = skillInfo.name defaultMacro.appendMacroLine(MacroLine(command='/skill %s' % cmd)) else: defaultMacro = Macro(charIndex, page, slot) defaultMacro.name = defaultCommand.name defaultMacro.icon = defaultCommand.icon if not defaultMacro.icon.startswith('SPELLICON_'): defaultMacro.icon = 'icons/%s' % defaultMacro.icon defaultMacro.description = defaultCommand.tooltip defaultMacro.appendMacroLine(MacroLine(command=defaultCommand.command)) # Return the default macro. return defaultMacro
if "email" in a: return "# Copyright (c) %(year)s %(name)s <%(email)s>" % a else: return "# Copyright (c) %(year)s %(name)s" % a def countSpaces(line): for i in range(len(line)): if not line[i].isspace(): break return i if len(sys.argv) != 3: raise Exception("invalid command line syntax: %s" % ' '.join(map(repr, sys.argv))) (m4File,outFile) = sys.argv[1:] assert outFile != m4File m = Macro(m4File, computeSerialNumber=True) for i in range(len(m.description)): para = m.description[i] if para[0][0].isspace(): spaces = min(list(map(countSpaces, para))) if spaces > 1: m.description[i] = [' ' + l[spaces:] for l in para] url = "https://www.gnu.org/software/autoconf-archive/%s.html" % m.name lineLen = max(len(url) + 2, 75) m.url = "# %s\n# %s\n# %s" % ('=' * lineLen, (' ' * int((lineLen - len(url)) / 2)) + url, '=' * lineLen) if m.__dict__.get("obsolete"): m.obsolete = "# OBSOLETE MACRO\n#\n" + '\n#\n'.join(map(formatParagraph, m.obsolete)) + "\n#\n" else: m.obsolete = "" m.synopsis = "\n".join([ "# %s" % l for l in m.synopsis ]) m.description = '\n#\n'.join(map(formatParagraph, m.description))
return "@smallexample\n%s\n@end smallexample" % quoteTexi( '\n'.join(para)) else: return quoteTexi('\n'.join(para)) def formatAuthor(a): assert a a["year"] = quoteTexi(a["year"]) a["name"] = quoteTexi(a["name"]) if "email" in a: a["email"] = quoteTexi(a["email"]) return "Copyright @copyright{} %(year)s %(name)s @email{%(email)s}" % a else: return "Copyright @copyright{} %(year)s %(name)s" % a if len(sys.argv) != 3: raise Exception("invalid command line syntax: %s" % ' '.join(map(repr, sys.argv))) (m4File, outFile) = sys.argv[1:] assert outFile != m4File m = Macro(m4File) m.synopsis = "@smallexample\n%s\n@end smallexample" % "\n".join( map(quoteTexi, m.synopsis)) m.description = '\n\n'.join(map(formatParagraph, m.description)) m.description = m.description.replace("@end smallexample\n@smallexample", "\n") m.authors = " @* ".join(["@w{%s}" % formatAuthor(a) for a in m.authors]) m.license = "\n\n".join(map(formatParagraph, m.license)) writeFile(outFile, tmpl % m.__dict__)