def calc(expression): source = InputStream(expression) lexer = Lexer(source) parser = Parser(lexer) tree = parser.parse() function_handler = FunctionHandler() interpreter = Interpreter(function_handler) result = interpreter.visit(tree) if result.type == 'image': response = make_response(base64.b64encode(result.image)) response.headers.set('Content-Type', 'image/jpeg') return response elif result.type == 'float' or result.type == 'integer' or result.type == 'text': if result.type == 'float': response = make_response('{:.5f}'.format(result.value)) elif result.type == 'integer': response = make_response(str(result.value)) elif result.type == 'text': response = make_response(result.text) response.headers.set('Content-Type', 'text/plain') return response
def test1(): '''test loop \"\" is used to post evaluation of a expression''' value = "International Bussiness Machine" expression = '''substr(value,indexOf(value,',','UWRD',-1),indexOf(value,'LWRD','END',-1))+substr(value,indexOf(value,'LWRD','SYB',1),-6)+substr(value,indexOf(value,'START','NUM',1),indexOf(value,'LWRD','SYB',-1))''' loopexp = "foreach(value.split(),\"substr(value,indexOf(value,'START','UWRD'),indexOf(value,'UWRD','LWRD'))\")" e = Interpreter(loopexp) print e.execute(value)
def runCode(self): if self.windowTitle() == self.settingWindowTitle: # print('run settings') self.settings = self.editor.toPlainText() self.setSettings() return if self.txtClearRun: self.text_res.setText('') else: self.text_res.append('') print('Run Code >>> ') interpreter = Interpreter() run_code = self.editor.toPlainText() # print(run_code) # self.print_debug_info('R', '<font color = "red"><b> RunCode </b></font> <br> <b>Code:</b> ' + run_code) run_code = '( ' + run_code + ' *RETURN* )' run_code = parse(pretrans(run_code)) for code in run_code: self.print_debug_info( 'R', '<font color = "red"><b> RunCode </b></font> <br> <b>Code:</b> ' + str(code)) run_res = interpreter.getResult(code) self.text_res.append(str(run_res)) del interpreter print()
def test5(): '''test loop''' stript = '''substr(value,indexOf(value,'NUM','\.',1),indexOf(value,'\.','22',1))+'edu'+'/'+'images'+'/'+substr(value,indexOf(value,'ANY','NUM',-1),-12)+'/'+substr(value,indexOf(value,'START','NUM',1),-12)+substr(value,-9,-8)+substr(value,5,16) ''' value = "1978.43.8_1a.jpg" e = Interpreter(stript) print e.execute(value)
def main(): text = """\ FUNC TEST(n,x,y,){ FOR(i=1, i<=n, i=i+1,){ FOR(j=1, j<=n, j=j+1,){ PRINT(i,",",j," ",); } PRINT("\n",); } } FUNC recur(n,){ IF(n==1){ RETURN 1; }RETURN n+CALL recur(n-1,); } FUNC MAIN(){CALL TEST(4,2,3,); n=4;a=5; FOR(i=1,i<=n,i=i+1,){PRINT(i,": ",CALL recur(i,),"\n",);} PRINT(a,"\n;",);} """ Beautifier = Beautify(text) res = Beautifier.solve() print(res) lexer = Lexer(text) parser = Parser(lexer) interpreter = Interpreter(parser) interpreter.interpret()
def test0(): '''test concatenation''' s = "13 Jan 2008 00:00:00 +0000" scripts = '''substr(value,indexOf(value,'START','NUM',1),12)+loop(value,"substr(value,-11,18)")+substr(value,12,-12) ''' a = Interpreter(scripts) print a.execute(s)
def GetModule(): return Application.Module( 'Core:Control:Flow', { 'if': Interpreter.BuiltIn(If), 'case': Interpreter.BuiltIn(Case), 'let': Interpreter.BuiltIn(Let) }, {}, ['if', 'case', 'let'])
def Module(name,directives_star): assert(isinstance(name,Interpreter.InAtom)) assert(isinstance(directives_star,Interpreter.InAtom)) Utils.testSymbol(name,'Module') directives = Utils.argStarAsList(directives_star) c_type = Interpreter.Symbol('Type') c_define = Interpreter.Symbol('Define') c_import = Interpreter.Symbol('Import') c_export = Interpreter.Symbol('Export') defines = {} imports = {} exports = [] for directive in directives: t = directive.get(c_type) if t == c_define: defines[directive.get(Interpreter.Symbol('Name')).value] = directive.get(Interpreter.Symbol('Value')) elif t == c_import: imports[directive.get(Interpreter.Symbol('Module'))] = \ (directive.get(Interpreter.Symbol('As')).value, map(lambda x: x.value,Utils.argStarAsList(directive.get(Interpreter.Symbol('Names'))))) elif t == c_export: exports.extend(map(lambda x: x.value,Utils.argStarAsList(directive.get(Interpreter.Symbol('Names'))))) else: raise Exception('Invalid module directive type!') return Application.Module(name.value,defines,imports,exports)
def Printing_Screen(self): self.scrollbar = Scrollbar(self.frame) self.scrollbar.grid(row=0, column=2, sticky=N+S) self.printing_l = Text(self.frame) self.printing_l.grid(row=0, column = 0) self.scrollbar.config(command=self.printing_l.yview) self.pause_b = Button(self.frame, text="Pause Printing", font=("Helvetica", 14),command= self.Pause_Screen) self.pause_b.grid(row=1, column = 0, pady=10) self.quit_b = Button(self.frame, text= "Quit Printing", font=("Helvetica", 14),command= self.to_quit) self.quit_b.grid(row=2, column = 0, pady=10) # Interpreter self.display_message("Reading file...") bricks = Interpreter.parsing(self.file.name) Interpreter.translation(bricks) self.display_message("Parsing file...") build_order = Interpreter.generate_build_order(bricks) self.display_message("Generating build order...") #build_list = Interpreter.generate_build_list(build_order) # Communication self.display_message("Opening communication channel...") com = Communicator() com.setup_connection() self.display_message("Communication established.") self.display_message("Printing...") bricks = com.print_bricks(build_order) for instruction in bricks: com.send_message(instruction[0], instruction[1]) com.close_connection()
def LoadPythonInterpreters(self): if sysutils.isWindows(): import _winreg ROOT_KEY_LIST = [ _winreg.HKEY_LOCAL_MACHINE, _winreg.HKEY_CURRENT_USER ] ROOT_KEY_NAMES = ['LOCAL_MACHINE', 'CURRENT_USER'] for k, root_key in enumerate(ROOT_KEY_LIST): try: open_key = _winreg.OpenKey(root_key, r"SOFTWARE\Python\Pythoncore") countkey = _winreg.QueryInfoKey(open_key)[0] keylist = [] for i in range(int(countkey)): name = _winreg.EnumKey(open_key, i) try: child_key = _winreg.OpenKey( root_key, r"SOFTWARE\Python\Pythoncore\%s" % name) install_path = _winreg.QueryValue( child_key, "InstallPath") interpreter = Interpreter.PythonInterpreter( name, os.path.join( install_path, Interpreter. PythonInterpreter.CONSOLE_EXECUTABLE_NAME)) if not interpreter.IsValidInterpreter: app_debugLogger.error( "interpreter name %s path %s,version %s is not a valid interpreter", interpreter.Name, interpreter.Path, interpreter.Version) continue self.interpreters.insert(0, interpreter) app_debugLogger.info( "load python interpreter from regkey success,path is %s,version is %s", interpreter.Path, interpreter.Version) help_key = _winreg.OpenKey(child_key, "Help") help_path = _winreg.QueryValue( help_key, "Main Python Documentation") interpreter.HelpPath = help_path app_debugLogger.info( "interpreter %s,help path is %s", interpreter.Name, interpreter.HelpPath) except Exception as e: app_debugLogger.error( "read python child regkey %s\\xxx\\%s error:%s", ROOT_KEY_NAMES[k], name, e) continue except Exception as e: app_debugLogger.error( "load python interpreter from regkey %s error:%s", ROOT_KEY_NAMES[k], e) continue else: executable_path = sys.executable install_path = os.path.dirname(executable_path) interpreter = Interpreter.PythonInterpreter( "default", executable_path) self.interpreters.append(interpreter)
def test_feedback_opcode(self): f = FeedbackMachine.FeedbackOutputFactory() i2 = Interpreter.Interpreter([],{},[]) i = Interpreter.Interpreter([4,3,99,7],{4:f.construct,99:Halt}) f.set_outerpreter(i2) i.run() outputs = i2._Interpreter__inputs self.assertEqual(outputs, [7])
def generate_model(filename, overrideParams={}, return_analysis=False, parse=True, spec={}): # --------- # PARSE Specification = spec if parse == True: Specification = Parser.parse('Specifications/'+filename+'.txt', overrideParams) vertices = [] if Specification['self_org'] == False: # DERIVE n = Specification['depth'] axiom = Specification['axiom'] tree = [axiom] tree = Deriver.derive(tree,n) # INTERPRET vertices = Interpreter.interpret(tree, return_analysis) else: # DERIVE AND INTERPRET TOGETHER n = Specification['depth'] axiom = Specification['axiom'] tree = [axiom] num_voxels = Specification['num_voxels'] shadow_height = Specification['shadow_height'] shadow_width = Specification['shadow_width'] decrement_close = Specification['dec_close'] decrement_far = Specification['dec_far'] for i in range(0,n): tree = Deriver.derive(tree,1) vertices, scale = Interpreter.interpret(tree, return_analysis, return_scale = True) voxels = SelfOrg.calc_light(vertices, num_voxels, shadow_height, shadow_width, decrement_close, decrement_far) SelfOrg.update_cells(tree, voxels, scale) print("Interpreted for the "+str(i+1)+"th time.") for e in tree: if isinstance(e, Cell): print(e.can_i_grow) # Return points of if being used in rendering, write file if return_analysis == True: return vertices else: #commented for use in metric visualisation print("writing to file...") with open("data.dat", mode="w") as f: f.write(str(len(vertices))+"\n") for vertex in vertices: for feature in vertex: f.write(str(feature)+"\t") f.write("\n")
def TinyShell (prompt='>>> '): while True: try: line = raw_input (prompt) buffer = StringIO (line) Interpreter.evaluate (buffer) buffer.close () except EOFError: break
def test_feedback_and_fork(self): f = FeedbackMachine.FeedbackOutputFactory(FeedbackMachine.FeedbackAndFork) i = Interpreter.Interpreter([4,3,99,7],{4:f.construct,99:Halt}) i2 = Interpreter.Interpreter([]) f.set_outerpreter(i2) i.run() outputs = i2._Interpreter__inputs self.assertEqual(outputs, [7]) self.assertEqual(i.pop_output(), 7)
def main(): repeat = True while (repeat): query = InputOutput.TakeCommand() parameters, is_syntax_correct = Interpreter.SyntaxAnalyzer(query) if (is_syntax_correct): repeat = Interpreter.ImplementOperations(parameters) else: print("Syntax Error")
def test_sixth_code(self): tape = [3, 3, 1105, -1, 9, 1101, 0, 0, 12, 4, 12, 99, 1] i = Interpreter.Interpreter(tape, self.ops, [4]) i.run() self.assertEqual(i.pop_output(), 1) tape = [3, 3, 1105, -1, 9, 1101, 0, 0, 12, 4, 12, 99, 1] i = Interpreter.Interpreter(tape, self.ops, [0]) i.run() self.assertEqual(i.pop_output(), 0)
def test_fifth_code(self): tape = [3, 12, 6, 12, 15, 1, 13, 14, 13, 4, 13, 99, -1, 0, 1, 9] i = Interpreter.Interpreter(tape, self.ops, [4]) i.run() self.assertEqual(i.pop_output(), 1) tape = [3, 12, 6, 12, 15, 1, 13, 14, 13, 4, 13, 99, -1, 0, 1, 9] i = Interpreter.Interpreter(tape, self.ops, [0]) i.run() self.assertEqual(i.pop_output(), 0)
def test_fourth_code(self): tape = [3, 3, 1107, -1, 8, 3, 4, 3, 99] i = Interpreter.Interpreter(tape, self.ops, [4]) i.run() self.assertEqual(i.pop_output(), 1) tape = [3, 3, 1107, -1, 8, 3, 4, 3, 99] i = Interpreter.Interpreter(tape, self.ops, [9]) i.run() self.assertEqual(i.pop_output(), 0)
def buildArray(l): assert (isinstance(l, list)) assert (all(map(lambda x: isinstance(x, Interpreter.InAtom), l))) kvs = [(Interpreter.Symbol('Length'), Interpreter.Number(len(l)))] for i in range(0, len(l)): kvs.append((Interpreter.Number(float(i)), l[i])) return Interpreter.Dict(kvs)
def test_second_code(self): tape = [3, 9, 7, 9, 10, 9, 4, 9, 99, -1, 8] i = Interpreter.Interpreter(tape, self.ops, [4]) i.run() self.assertEqual(i.pop_output(), 1) tape = [3, 9, 7, 9, 10, 9, 4, 9, 99, -1, 8] i = Interpreter.Interpreter(tape, self.ops, [8]) i.run() self.assertEqual(i.pop_output(), 0)
def parse_ascendent(self): input = self.textEdit.toPlainText() Interpreter.parse_ascendent(input) console_value = Interpreter.console_value html = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n" html = html + "<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\n" html = html + "p, li { white-space: pre-wrap; }\n" html = html + "</style></head><body style=\" font-family:\'Fixedsys\'; font-size:8pt; font-weight:400; font-style:normal;\" bgcolor=\"#2d3436\">\n" html = html + "<p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" color:#dfe6e9;\">" html = html + console_value self.textBrowser.setHtml(html)
def test4(): '''test switch function''' condi1 = "len(value) < 10" condi2 = "len(value) < 10" loopexp1 = "foreach(value.split(),\"substr(value,indexOf(value,'START','UWRD'),indexOf(value,'UWRD','LWRD'))\")" loopexp2 = '''foreach(foreach(value.split(),\"substr(value,indexOf(value,'START','UWRD'),indexOf(value,'UWRD','LWRD'))\"),\"value+'see'\")''' tuplist = "[("+condi1+","+loopexp1+"),("+condi2+","+loopexp2+")]" sw = "switch("+tuplist+")" value = "International Bussiness Machine" e = Interpreter(sw) print e.execute(value)
def test4(): '''test switch function''' condi1 = "len(value) < 10" condi2 = "len(value) < 10" loopexp1 = "foreach(value.split(),\"substr(value,indexOf(value,'START','UWRD'),indexOf(value,'UWRD','LWRD'))\")" loopexp2 = '''foreach(foreach(value.split(),\"substr(value,indexOf(value,'START','UWRD'),indexOf(value,'UWRD','LWRD'))\"),\"value+'see'\")''' tuplist = "[(" + condi1 + "," + loopexp1 + "),(" + condi2 + "," + loopexp2 + ")]" sw = "switch(" + tuplist + ")" value = "International Bussiness Machine" e = Interpreter(sw) print e.execute(value)
def main(): file_object = open('source_code.txt') try: text = file_object.read() lexer = Lexer(text) parser = Parser(lexer) interpreter = Interpreter(parser) interpreter.interpret() print(interpreter.GLOBAL_SCOPE) finally: file_object.close()
def run(fn, text): lexer = lex(fn, text) tokens, error = lexer.make_tokens() if error: return None, error p = parse(tokens) ast = p.parse() if ast.error: return None, ast.error interpreter = Interpreter() context = Context('<program>') result = interpreter.visit(ast.node, context) return result.value, result.error
def argStarAsList(arg_star): assert (isinstance(arg_star, Interpreter.Dict)) length = arg_star.get(Interpreter.Symbol('Length')) assert (length) new_ls = [] for i in range(0, length.value): new_item = arg_star.get(Interpreter.Number(i)) assert (new_item) new_ls.append(new_item) return new_ls
def main(): while True: # try: # try: # text = raw_input('spi> ') # except NameError: # Python3 # text = input('spi> ') # except EOFError: # break # if not text: # continue text = text = """\ FUNC TEST(){ n=10; x=100000000; FOR(i=1;i<=n;i=i+1;){ FOR(j=1; j<=n; j=j+1;){ PRINT(i,",",j," ",) } PRINT("\n",) x=x-1; } x=x-10; y=10; } FUNC MAIN(){ CALL TEST(); n=8; x=4; FOR(i=1;i<=n;i=i+1;){ FOR(j=1; j<=n; j=j+1;){ PRINT(i,",",j," ",) a=10; b=10; } PRINT("\n",) } PRINT(x,"\n",) } """ lexer = Lexer(text) parser = Parser(lexer) interpreter = Interpreter(parser) result = interpreter.interpret() print(interpreter.GLOBAL_SCOPE.get('hello')) break
def setOffset(): global OFFSET_RIGHT global OFFSET_LEFT OFFSET_RIGHT = [[0 for x in range(5)] for y in range(10)] OFFSET_LEFT = [[0 for x in range(5)] for y in range(10)] raw_left_data = SohlenConnection.getdata("L") left_data = Interpreter.input_raw_data_left(raw_left_data, OFFSET_LEFT) OFFSET_LEFT = left_data raw_right_data = SohlenConnection.getdata("R") right_data = Interpreter.input_raw_data_right(raw_right_data, OFFSET_RIGHT) OFFSET_RIGHT = right_data
def loadInterpreter(self,configPaths, projectName="", subtask_name=""): import sys, os sys.path.append(os.path.abspath(configPaths)) sys.path.append(os.path.abspath(configPaths)+'/Assistant/') import Interpreter from importlib import reload reload(Interpreter) # use 1, 2 to use different config file #self.config = configuration.initConfig(2) #return configuration.initConfig(1) if projectName == "" or subtask_name == "": interpreter = Interpreter.Interpreter() return interpreter interpreter = Interpreter.Interpreter(projectName+'.'+subtask_name) return interpreter#.ParsingConfig()
def main(): if len(sys.argv) == 2: file = open(sys.argv[1], 'r') source = file.read() try: lexer = Lexer(source) parser = Parser(lexer) interpreter = Interpreter(parser) result = interpreter.interpret() print(result) except Exception as e: print(e) else: print("Usage: ki.py kotlinFilename") sys.exit()
def main(): while True: # try: # try: # text = raw_input('spi> ') # except NameError: # Python3 # text = input('spi> ') # except EOFError: # break # if not text: # continue text = text = """\ { number = 2523*10; x = 11; IF(x<=11){ hello=2; hello=hello-2; a=0; IF(a<1){ hello=108; }ELSEIF(a<2){ hello=109; }ELSEIF(a<3){ hello=110; }ELSEIF(a<4){ hello=111; }ELSEIF(a<5){ hello=112; }ELSE{ hello=113; } FOR(i=2;i<=10;i=i+2;){ PRINT("Hello World!",) } } } """ lexer = Lexer(text) parser = Parser(lexer) interpreter = Interpreter(parser) result = interpreter.interpret() print(result) print(interpreter.GLOBAL_SCOPE.get('hello')) break
def TinyPython (): parser = optparse.OptionParser () parser.add_option ("-v", "--version", dest='version', default=False, help="Print version", action="store_true") (options, args) = parser.parse_args () if options.version is True: PrintVersion () return if len (args) > 0: try: with open (args [0], 'r') as fd: Interpreter.evaluate (fd) except IOError: print >>sys.stderr, 'Unable to open [%s]' % args [0] else: TinyShell ()
def interactive(): while (True): line = raw_input(": ") if (line == "quit"): break val = Interpreter.evaluate(line, False) if (val != 0): return val
def HasKey(d, key): assert (isinstance(d, Interpreter.InAtom)) assert (isinstance(key, Interpreter.InAtom)) Utils.testDict(d, 'HasKey') return Interpreter.Boolean(d.hasKey(key))
def handle(self): reload(Interpreter); self.recvMsg = self.request.recv(1024).strip(); self.sndMsg = Interpreter.parseCommand(self.recvMsg, self.client_address); cur_thread = threading.currentThread(); print "======== New Event (TCP) @ %s =========" % time.ctime(time.time()); print "Thread: %s" % cur_thread.getName(); print "Client: %s" % self.client_address[0]; print "Incoming Msg: %s" % self.recvMsg; print "Outgoing Msg: %s\n\n" % self.sndMsg; print "----------------end--------------------"; if self.sndMsg != None: self.request.send(self.sndMsg);
def handle(self): reload(Interpreter); self.recvMsg = self.request[0].strip(); self.sndMsg = Interpreter.parseCommand(self.recvMsg, self.client_address); cur_thread = threading.currentThread(); print "======== New Event (UDP) @ %s =========" % time.ctime(time.time()); print "Thread: %s" % cur_thread.getName(); print "Client: %s" % self.client_address[0]; print "Incoming Msg: %s" % self.recvMsg; print "Outgoing Msg: %s\n\n" % self.sndMsg; print "----------------end--------------------"; sck = socket.socket(socket.AF_INET, socket.SOCK_DGRAM); if self.sndMsg != None: sck.sendto(self.sndMsg, (self.client_address[0], 11315));
def main(): """ Runs the main JTL program. :return: int """ #Parse arguments parser = argparse.ArgumentParser(description='JSON Transformation Language') parser.add_argument('-i', '--indent', default=4, type=int, help='Indentation amount.') parser.add_argument('-t', '--transform-file', help='The name of the JSON file containing the transformation to run.') parser.add_argument('transform', nargs='?', help='The transformation to run.') arguments = parser.parse_args(sys.argv[1:]) #Load the transformation if arguments.transform is None and arguments.transform_file is not None: #From a file with open(arguments.transform_file, 'r') as f: transformStr = f.read() elif arguments.transform is not None and arguments.transform_file is None: #From the command line transformStr = arguments.transform else: print('ERROR: Specify either a transform file or a transform') return 1 transformData = json.loads(transformStr) #Read the JSON in from stdin #TODO: error handling data = json.loads(sys.stdin.read()) #Transform the JSON #TODO: cleaner way to do this sys.path.append('.') import Interpreter result = Interpreter.transformJson(data, transformData) #Output the result print(json.dumps(result, indent=arguments.indent, sort_keys=True)) return 0
def handle(self): reload(Interpreter); self.recvMsg = self.request.recv(1024).strip(); self.sndMsg = Interpreter.parseCommand(self.recvMsg, self.client_address); cur_thread = threading.currentThread(); print "======== New Event (TCP) @ %s =========" % time.ctime(time.time()); print "Thread: %s" % cur_thread.getName(); print "Client: %s" % self.client_address[0]; print "Incoming Msg: %s" % self.recvMsg; print "Outgoing Msg: %s\n\n" % self.sndMsg; print "----------------end--------------------"; if self.sndMsg != None: #self.request.send(self.sndMsg); try: socket.setdefaulttimeout(10); sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM); sck.connect((self.client_address[0],11314)); sck.send(self.sndMsg); except socket.error, socket.timeout: print "back connect client timeout";
def test_DivideOnly4(self): interpreter = Interpreter("96/ 2 ") result = interpreter.interpret(); self.assertEqual(48, result)
def test3(): '''test embeded loop''' value = "International Bussiness Machine" loopexp = '''foreach(foreach(value.split(),\"substr(value,indexOf(value,'START','UWRD'),indexOf(value,'UWRD','LWRD'))\"),\"value+'See'\")''' e = Interpreter(loopexp) print e.execute(value)
def test_MultiplyOnly3(self): interpreter = Interpreter("1*2*3*4*5") result = interpreter.interpret(); self.assertEqual(120, result)
def analyse_buffer_options(globalpos, env, posargs, dictargs, defaults=None, need_complete=True): """ Must be called during type analysis, as analyse is called on the dtype argument. posargs and dictargs should consist of a list and a dict of tuples (value, pos). Defaults should be a dict of values. Returns a dict containing all the options a buffer can have and its value (with the positions stripped). """ if defaults is None: defaults = buffer_defaults posargs, dictargs = Interpreter.interpret_compiletime_options(posargs, dictargs, type_env=env, type_args = (0,'dtype')) if len(posargs) > buffer_positional_options_count: raise CompileError(posargs[-1][1], ERR_BUF_TOO_MANY) options = {} for name, (value, pos) in dictargs.iteritems(): if not name in buffer_options: raise CompileError(pos, ERR_BUF_OPTION_UNKNOWN % name) options[name] = value for name, (value, pos) in zip(buffer_options, posargs): if not name in buffer_options: raise CompileError(pos, ERR_BUF_OPTION_UNKNOWN % name) if name in options: raise CompileError(pos, ERR_BUF_DUP % name) options[name] = value # Check that they are all there and copy defaults for name in buffer_options: if not name in options: try: options[name] = defaults[name] except KeyError: if need_complete: raise CompileError(globalpos, ERR_BUF_MISSING % name) dtype = options.get("dtype") if dtype and dtype.is_extension_type: raise CompileError(globalpos, ERR_BUF_DTYPE) ndim = options.get("ndim") if ndim and (not isinstance(ndim, int) or ndim < 0): raise CompileError(globalpos, ERR_BUF_NDIM) mode = options.get("mode") if mode and not (mode in ('full', 'strided', 'c', 'fortran')): raise CompileError(globalpos, ERR_BUF_MODE) def assert_bool(name): x = options.get(name) if not isinstance(x, bool): raise CompileError(globalpos, ERR_BUF_BOOL % name) assert_bool('negative_indices') assert_bool('cast') return options
def test_MultiplyOnly4(self): interpreter = Interpreter("1*2") result = interpreter.interpret(); self.assertEqual(2, result)
def test_Mixed2(self): interpreter = Interpreter("0/2-3+1*2") result = interpreter.interpret(); self.assertEqual(-1, result)
def test_AddyOnly2(self): interpreter = Interpreter("1 +2+3 ") result = interpreter.interpret(); self.assertEqual(6, result)
def test_AddOnly4(self): interpreter = Interpreter(" 1+2 ") result = interpreter.interpret(); self.assertEqual(3, result)
def test_Mixed1(self): interpreter = Interpreter(" 100 / 2 * 5 +1 -2 ") result = interpreter.interpret(); self.assertEqual(249, result)
def test_DivideOnly3(self): interpreter = Interpreter("1/2/3/4/5") result = interpreter.interpret(); self.assertEqual(0, result)
def test_SubtractOnly1(self): interpreter = Interpreter("101- 2 - 3 ") result = interpreter.interpret(); self.assertEqual(96, result)
def test_DivideOnly2(self): interpreter = Interpreter("0/2/3") result = interpreter.interpret(); self.assertEqual(0, result)
def test_DivideOnly1(self): interpreter = Interpreter(" 100 / 2 / 5 ") result = interpreter.interpret(); self.assertEqual(10, result)
def test_SubtractOnly4(self): interpreter = Interpreter(" 1 - 2 ") result = interpreter.interpret(); self.assertEqual(-1, result)
def test_SubtractOnly3(self): interpreter = Interpreter("1-2-3-4-5") result = interpreter.interpret(); self.assertEqual(-13, result)
def test_SubtractOnly2(self): interpreter = Interpreter("0 - 2-3") result = interpreter.interpret(); self.assertEqual(-5, result)
def test_OnlyNumber1(self): interpreter = Interpreter("3") result = interpreter.interpret(); self.assertEqual(3, result)
def test_AddOnly3(self): interpreter = Interpreter("1+2+3+4+5") result = interpreter.interpret(); self.assertEqual(15, result)