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 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 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 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 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 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 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)
