Example #1
0
def test_inttrait():
    builtincode = """
object inttrait:
    x = 1
    def maybe_fortytwo:
        if self:
            42
        else:
            x
"""
    interpreter = Interpreter(builtincode)
    w_module = interpreter.make_module()
    # the parent of a normal module is the builtin module
    builtins = w_module.getparents()[0]
    inttrait = builtins.getvalue("inttrait")

    ast = parse("""
x = 5 x # this returns 1, because it looks in the inttrait defined above
m0 = 0 maybe_fortytwo
m1 = x maybe_fortytwo
inttrait x = 2
m2 = 0 maybe_fortytwo
tr = inttrait
""")
    interpreter.eval(ast, w_module)
    x = w_module.getvalue("x")
    assert w_module.getvalue("tr") is inttrait
    # the inttrait is defined in the builtin module, so its __parent__ is that
    # module
    assert inttrait.getparents() == [builtins]
    assert x.value == 1
    assert x.getparents() == [inttrait]
    assert w_module.getvalue("m0").value == 1
    assert w_module.getvalue("m1").value == 42
    assert w_module.getvalue("m2").value == 2
Example #2
0
def index(request):

    if not request.POST:
      return install(request)

    response = HttpResponse()
    try:
      active_xml = request.POST.get('activexml')

      if not active_xml:
        response.write("Failure - Please post with valid XML string to process.")
        return response
      interp = Interpreter()
      interp.processXML(active_xml)
      interpList = interp.topPhraseList(count = 3)

      outputList = [interp.word_count]
      for tup in interpList:
        outputList.append({'keyPhrase':tup[0], "iCount" : tup[1], "weight":tup[2]})

      jsonString = simplejson.dumps( outputList )
      print outputList
      response.write(jsonString)

      return response

    except Exception, e:
      print e
      response.write(str(e))
      return response
Example #3
0
def test_builtin_simple():
    builtincode = """
x = 1
object None:
    1
def pass:
    None
"""
    # construct the builtin module by running builtincode within the context of
    # a new empty module
    interpreter = Interpreter(builtincode)
    w_module = interpreter.make_module()
    # the parent of a normal module is the builtin module
    builtins = w_module.getparents()[0]
    assert builtins.getvalue('x').value == 1

    ast = parse("""
tx = x
object a:
    pass
ax = a x
""")
    interpreter.eval(ast, w_module)
    assert w_module.getvalue("ax").value == 1
    assert w_module.getvalue("tx").value == 1
def download_planning(uuid):
    try:
        planning = _get_planning(uuid, g.user_id)
    except CAPException as e:
        return e.res

    moodle_archive_path = planning.mbz_fullpath
    planning_txt = planning.planning_txt

    if not planning_txt:
        return _bad_request()

    # Make tmp directory for MBZ extraction and ics download
    with tempfile.TemporaryDirectory() as tmp_path:
        # Download calendar to tmp folder
        calendar = CalendarReader(planning.ics_fullpath)
        calendar_meetings = calendar.get_all_meetings()

        # Extract Moodle course to tmp folder
        with tarfile.open(moodle_archive_path) as tar_file:
            tar_file.extractall(tmp_path)
            course = MoodleCourse(tmp_path)

        interpreter = Interpreter(calendar_meetings, course)
        for line in planning_txt.split('\n'):
            event = interpreter.get_new_event_from_string(line)
            course.replace_event(event)

        folder = os.path.join(app.config['UPLOAD_FOLDER'], uuid)
        latest_mbz_path = os.path.join(folder, 'latest.mbz')

        course.write(latest_mbz_path)
        return send_from_directory(
            folder, 'latest.mbz', as_attachment=True)
Example #5
0
def compiler():
    text = request.POST.get("text")
    
    interpreter = Interpreter(text)
    interpreter.compile()
    result = str(interpreter)
    return {'result':result}
Example #6
0
def test_args_order():
    ast = parse("""
def f(a, b, c):
    if a:
        4
    else:
        if b:
            8
        else:
            if c:
                15
            else:
                16
w = f(1, 1, 1)
x = f(0, 1, 1)
y = f(0, 0, 1)
z = f(0, 0, 0)
""")

    interpreter = Interpreter()
    w_module = interpreter.make_module()
    interpreter.eval(ast, w_module)
    assert w_module.getvalue("w").value == 4
    assert w_module.getvalue("x").value == 8
    assert w_module.getvalue("y").value == 15
    assert w_module.getvalue("z").value == 16
Example #7
0
def main():

    raw_code = """
Input>>Number(num1) Integer 
        Input>>Number(num2) Integer
             num1,num2>>Number(ans) Added
             ans>>Screen(Output) Demo ConsolePlus
"""
    a = Interpreter()
    a.parser(raw_code)
    print(a.info)
    b = SMLHandler(a.source)
    b.build_dom_tree()
    print(b.info)
    ss = b.build_sml()
    print(ss)

    c = SMLHandler()
    c.read_sml(ss)
    c.read_dom_tree()

    c.dom = c.builder.getDOMImplementation()
    c.tree = c.dom.createDocument("http://cp-web.appspot.com/source", "Source", None)
    c.build_dom_tree()
    print(c.build_sml())
Example #8
0
    def test_example(self):
        example = """addi R10,R0,100
                     sw R0,24(R0)
                     sw R0,28(R0)
                     LOOP:
                     lw R6,28(R0)
                     mul R7,R6,R6
                     lw R1,24(R0)
                     add R9,R1,R7
                     sw R9,24(R0)
                     addi R6,R6,1
                     sw R6,28(R0)
                     ble R6,R10,LOOP"""

        text = [
            "00100000000010100000000001100100 ; I1: addi R10,R0,100",
            "10101100000000000000000000011000 ; I2: sw R0,24(R0)",
            "10101100000000000000000000011100 ; I3: sw R0,28(R0)",
            "10001100000001100000000000011100 ; I4: lw R6,28(R0)",
            "00000000110001100011100000011000 ; I5: mul R7,R6,R6",
            "10001100000000010000000000011000 ; I6: lw R1,24(R0)",
            "00000000001001110100100000100000 ; I7: add R9,R1,R7",
            "10101100000010010000000000011000 ; I8: sw R9,24(R0)",
            "00100000110001100000000000000001 ; I9: addi R6,R6,1",
            "10101100000001100000000000011100 ; I10: sw R6,28(R0)",
            "00011100110010100000000000001100 ; I11: ble R6,R10,12",
        ]
        interpreter = Interpreter(example)
        interpreter.compile()

        for compiled, correct in zip(interpreter.instructions, text):
            self.assertEqual(compiled, correct)
Example #9
0
    def test_if_example(self):
        example = """addi R1,R0,3
                     addi R2,R0,2
                     beq R1,R2,EQ
                     jmp NE
                     EQ:
                     addi R1,R0,5
                     jmp END
                     NE:
                     addi R1,R0,7
                     END:"""

        text = [
            "00100000000000010000000000000011 ; I1: addi R1,R0,3",
            "00100000000000100000000000000010 ; I2: addi R2,R0,2",
            "00010100001000100000000000001000 ; I3: beq R1,R2,8",
            "00001000000000000000000000011000 ; I4: jmp 24",
            "00100000000000010000000000000101 ; I5: addi R1,R0,5",
            "00001000000000000000000000011100 ; I6: jmp 28",
            "00100000000000010000000000000111 ; I7: addi R1,R0,7",
        ]

        interpreter = Interpreter(example)
        interpreter.compile()

        for compiled, correct in zip(interpreter.instructions, text):
            self.assertEqual(compiled, correct)
Example #10
0
def compile_pascal(source, dest, is_debug = False, is_interpret = False, out_stream = sys.stdout, output_tokens = False, output_bytecodes = False, lib = ['.'], in_stream = sys.stdin):
  '''
  DID YOU KNOW that compile() is a built in function?
  '''
  set_debug(is_debug)
  debug("Compiling %s into %s" % (source, dest))
  scanner = Scanner(source)
  tokens = scanner.scan()
  if output_tokens:
    write(tokens, source + "_tokenized")
  debug('scanning complete')
  parser = Parser(tokens, source, lib = lib)
  bytecodes, success = parser.parse()
  if output_bytecodes:
    if is_debug:
      write(prettify(bytecodes), source + "_unassembled")
    else:
      write(bytecodes, source + "_unassembled")
  if not success:
    print 'Parsing error'
    return
  debug('parsing complete')
  assembler = Assembler(bytecodes)
  assembled = assembler.assemble()
  if is_debug:
    write(prettify(assembled), dest + '_debug')
  write(assembled, dest)
  debug('assembly complete.' )
  if is_interpret:
    interp = Interpreter(out_stream, in_stream, code = assembled)
    interp.interpret()
  else:
    debug('run program now with `python interpreter.py %s`' % dest)
def test_override__parent__():
    ast = parse("""
k = 10
object a:
    x = 1
    y = 2
    z = k
object b:
    __parent__ = a
    y = 5
    z = y

ax = a x
ay = a y
az = a z
bx = b x
by = b y
bz = b z
""")
    interpreter = Interpreter()
    w_module = interpreter.make_module()
    interpreter.eval(ast, w_module)
    a = w_module.getvalue("a")
    assert a.getvalue('__parent__') is w_module
    assert w_module.getvalue("b").getvalue('__parent__') is a
    assert w_module.getvalue("b").getparents() == [a]
    assert w_module.getvalue("ax").value == 1
    assert w_module.getvalue("ay").value == 2
    assert w_module.getvalue("az").value == 10
    assert w_module.getvalue("bx").value == 1
    assert w_module.getvalue("by").value == 5
    assert w_module.getvalue("bz").value == 5
def download_planning(uuid):
    planning = _get_planning(uuid)
    if not planning:
        return jsonify({"message": 'Planning with uuid "%s" not found' % uuid}), 404

    moodle_archive_path = planning.mbz_fullpath
    planning_txt = planning.planning_txt

    if not planning_txt:
        return _bad_request()

    # Make tmp directory for MBZ extraction and ics download
    with tempfile.TemporaryDirectory() as tmp_path:
        # Download calendar to tmp folder
        calendar_path = _dl_and_save_ics_file(planning.ics_url, tmp_path)
        calendar = CalendarReader(calendar_path)
        calendar_meetings = calendar.get_all_meetings()

        # Extract Moodle course to tmp folder
        with tarfile.open(moodle_archive_path) as tar_file:
            tar_file.extractall(tmp_path)
            course = MoodleCourse(tmp_path)

        interpreter = Interpreter(calendar_meetings, course)
        for line in planning_txt.split("\n"):
            event = interpreter.get_new_event_from_string(line)
            course.replace_event(event)
        folder = os.path.join(app.config["UPLOAD_FOLDER"], uuid)
        latest_mbz_path = os.path.join(folder, "latest.mbz")

        course.write(latest_mbz_path)
        return send_from_directory(folder, "latest.mbz", as_attachment=True)
Example #13
0
def do_the_twist(code):
    from simpleparser import parse

    ast = parse(code)
    interpreter = Interpreter()
    w_module = interpreter.make_module()
    interpreter.eval(ast, w_module)
    return w_module
Example #14
0
def test_huge_negative_intliteral():
    ast = parse("""
x = -10000
""")
    interpreter = Interpreter(empty_builtins)
    w_module = interpreter.make_module()
    interpreter.eval(ast, w_module)
    assert w_module.getvalue("x").value == -10000
Example #15
0
 def test_ignoring_label_to_string(self):
     """ Bytecode should not have label names."""
     code = """nop
               label:
               nop"""
     interpreter = Interpreter(code)
     interpreter.compile()
     self.assertFalse("label" in str(interpreter))
def test_primitive():
    ast = parse("""
k = 10 $int_add(31)
""")
    interpreter = Interpreter()
    w_module = interpreter.make_module()
    interpreter.eval(ast, w_module)
    assert w_module.getvalue("k").value == 41
Example #17
0
def test_primitive():
    ast = parse("""
x = 1 $int_add(2)
""")
    interpreter = Interpreter(empty_builtins)
    w_module = interpreter.make_module()
    interpreter.eval(ast, w_module)
    assert w_module.getvalue("x").value == 3
Example #18
0
 def test_bne(self):
     code = """nop
               LOOP:
               bne R1,R2,LOOP"""
     interpreter = Interpreter(code)
     interpreter.compile()
     self.assertEqual(len(interpreter.instructions), 2)
     self.assertEqual(interpreter.instructions[1], "00010000001000100000000000000000 ; I2: bne R1,R2,0")
Example #19
0
def test_assignment():
    ast = parse("""
x = 1
""")
    interpreter = Interpreter(empty_builtins)
    w_module = interpreter.make_module()
    interpreter.eval(ast, w_module)
    assert w_module.getvalue("x").value == 1
Example #20
0
 def test_jmp_back(self):
     code = """label:
               jmp label"""
     interpreter = Interpreter(code)
     interpreter.compile()
     self.assertEqual(len(interpreter.instructions), 1)
     self.assertEqual(interpreter.instructions[0], "00001000000000000000000000000000 ; I1: jmp 0")
     self.assertEqual(interpreter.labels.get("label"), 0)
Example #21
0
 def test_jmp_forward(self):
     code = """jmp label
               label:"""
     interpreter = Interpreter(code)
     interpreter.compile()
     self.assertEqual(len(interpreter.instructions), 1)
     self.assertEqual(interpreter.instructions[0], "00001000000000000000000000000100 ; I1: jmp 4")
     self.assertEqual(interpreter.labels.get("label"), 4)
Example #22
0
    def run(self):
        plugin_loader = PluginLoader()
        plugin_directory = PluginDirectory()
        commands = plugin_loader.load(plugin_directory)
        interpreter = Interpreter(commands)
 
        while True:
            print interpreter.interpret(raw_input())
Example #23
0
 def test_ble(self):
     code = """nop
               LOOP:
               nop
               ble R1,R2,LOOP"""
     interpreter = Interpreter(code)
     interpreter.compile()
     self.assertEqual(len(interpreter.instructions), 3)
     self.assertEqual(interpreter.instructions[2], "00011100001000100000000000000100 ; I3: ble R1,R2,4")
Example #24
0
def test_pop():
    ast = parse("""
x = 1 # the result of this will be popped from the stack
x = 2
""")
    interpreter = Interpreter(empty_builtins)
    w_module = interpreter.make_module()
    interpreter.eval(ast, w_module)
    assert w_module.getvalue("x").value == 2
Example #25
0
 def create_task(self):
     interpreter = Interpreter(self.get_content()['data'])
     interpreter.run()
     task = Task(based_on_exercise=self.eid,
                 part_of_match=None,
                 part_of_sheet=None)
     task.set_content(interpreter.globs)
     db.session.add(task)
     db.session.commit()
     return task
Example #26
0
def main():
    settings._filename = get_settings_filename()
    dbaccess.connect()
    interpreter = Interpreter()

    print_init_message()
    try:
        interpreter.cmdloop('')
    except KeyboardInterrupt:
        print('')
        sys.exit(0)
Example #27
0
def test_objectdefinition_simple():
    ast = parse("""
object x:
    a = 1
    b = 2
""")
    interpreter = Interpreter(empty_builtins)
    w_module = interpreter.make_module()
    interpreter.eval(ast, w_module)
    assert w_module.getvalue("x").getvalue("a").value == 1
    assert w_module.getvalue("x").getvalue("b").value == 2
def test_duplicate_base_error():
    ast = parse("""
object base:
    x = 1
object sub(p1=base, p2=base):
    x = 2
y = sub x
""")
    interpreter = Interpreter()
    w_module = interpreter.make_module()
    py.test.raises(TypeError, interpreter.eval, ast, w_module)
def test_capture():
    ast = parse("""
k = 10
object a:
    j = k
k = 11
aj = a j
""")
    interpreter = Interpreter()
    w_module = interpreter.make_module()
    interpreter.eval(ast, w_module)
    assert w_module.getvalue("aj").value == 10
Example #30
0
class TestBinaryOperations(unittest.TestCase):
    def setUp(self):
        self.interpreter = Interpreter()

    def test_to_bin(self):
        self.assertEqual(self.interpreter._to_bin(0), "0")
        self.assertEqual(self.interpreter._to_bin(2), "10")
        self.assertEqual(self.interpreter._to_bin(-2, 5), "11110")
        self.assertEqual(self.interpreter._to_bin(-4, 5), "11100")
        self.assertEqual(self.interpreter._to_bin(-7, 5), "11001")
        self.assertEqual(self.interpreter._to_bin(-8, 5), "11000")
        self.assertEqual(self.interpreter._to_bin(12, 5), "01100")
    def __init__(self):
        Tk.__init__(self)

        # Create Interpteret object
        self.interpreter = Interpreter()

        # Create Graph Object and Initialize
        self.Graph = Graph_class(self,
                                 bg='white',
                                 width=900,
                                 height=600,
                                 varDict=self.interpreter.getVarDict())
        self.Graph.place(x=10, y=10)
        self.Graph.config(highlightbackground='black')

        # Adding Variable
        self.interpreter.interpret('graphScale=' + str(self.Graph.scale))

        # Setting up input box
        self.entry = Entry(self, width=56, font=("Times", "10"))
        self.entry.place(x=920, y=550)
        self.entry.focus_set()

        # Setting up terminal window
        self.inputList = []
        self.inputIndex = 0
        self.textPad = ScrolledText.ScrolledText(self,
                                                 width=57,
                                                 height=17,
                                                 font=("Times", "10"))
        # self.textPad.configure(state='disabled')
        self.textPad.insert(END, 'Type "help" for List of commands\n')
        self.textPad.place(x=920, y=287)

        # Binding events to functions
        self.bind('<Return>', lambda x: self.interpret())
        self.bind('<Up>', lambda x: self.prevInp())
        self.bind('<Down>', lambda x: self.nextInp())

        # Setting up GUI
        self.setupButtons()
        self.setupListBox()
Example #32
0
File: main.py Project: qqbc1/ToyPL
def run(fn, text):
    # 生成Tokens
    lexer = Lexer(fn, text)
    tokens, error = lexer.make_tokens()
    if error: return None, error
    # print(tokens)

    # 生成AST,通过__repr__形式打印出树结构而已
    parser = Parser(tokens)
    ast = parser.parse()
    if ast.error: return None, ast.error
    # print(ast.node)

    # 通过解释器执行程序
    interpreter = Interpreter()
    context = Context("<program>")
    context.symbol_table = global_symbol_table
    result = interpreter.visit(ast.node, context)

    return result.value, result.error
Example #33
0
class Main(object):
    def __init__(self):
        self.interpreter = Interpreter()

    def run(self, source_code, ignore_errors=False, repl=False):
        tokens = Scanner(source_code).scanTokens()

        parser = Parser(tokens)
        statements = parser.parse()

        if repl and len(statements) == 1 and isinstance(
                statements[0], stmt.StmtExpression):
            statements[0] = stmt.StmtPrint(statements[0].expression)

        if ErrorHandler.errored:
            if ignore_errors:
                ErrorHandler.errored = False
            return

        self.interpreter.interpret(statements)
Example #34
0
def main():
    # while True:
    # s = input()

    s = "12 / 6 - 2 * 4"

    ast = parser.parse(s, debug=False)
    print("AST:", ast)
    interpreter = Interpreter(ast)
    result = interpreter.run()
    print(result)
 def test_binary_comparison(self):
     tests = [
         ("1 > 2", False),
         ("1 > 0", True),
         ("2 < 2", False),
         ("2 <= 2", True),
         ("3 >= 2", True),
     ]
     for (source, exp) in tests:
         res = parseExp(source)[0].expression.accept(Interpreter())
         assert res == exp
 def test_binary_math(self):
     tests = [
         ("1 + 2", 3),
         ("1 - 2", -1),
         ("2 * 4", 8),
         ("4 / 2", 2),
         ('"1" + "2"', "12"),
     ]
     for (source, exp) in tests:
         res = parseExp(source)[0].expression.accept(Interpreter())
         assert res == exp
Example #37
0
def run(fn, text):
    lexer_ = Lexer(fn, text)
    tokens, error = lexer_.make_tokens()

    if error:
        return '', error
    print(text)
    print(tokens)

    parser = Parser(tokens)
    ast = parser.parse()

    print(ast.node)

    interpreter_ = Interpreter()
    res = interpreter_.visit(ast.node)

    print(res['sites'][0]['url'])

    return res, ''
Example #38
0
def main():
    try:
        opts, _args = getopt.getopt(sys.argv[1:], '', OPTIONS)
        options = {k: v for k, v in opts}  # pylint: disable=R1721
    except getopt.GetoptError as err:
        exit_fail(err)

    try:
        filename = 'examples/sqrt.m'
        if '--path' in options:
            filename = options['--path']

        print_main(f'Opening file: {filename}')
        with open(filename, "r") as file:
            text = file.read()
    except IOError:
        exit_ok(f"Cannot open {filename} file")

    if '--clear' in options:
        clear()
        exit_ok()

    lexer = Scanner()

    if '--lexer' in options:
        run_lexer(lexer, text)
        exit_ok()

    if '--use_cache' not in options:
        clear()

    if '--zip' in options:
        out = options['--zip'] if options['--zip'] else 'slawecki_tratnowiecki'
        zip_files(out)

    if '--use_cache' in options:
        move_auto_files(mv_reversed=True)
    parser = Parser(lexer)
    ast = parser.parse(text)
    move_auto_files()

    if not ast:
        exit_fail('Cannot run your program: returning.')

    if '--print_ast' in options:
        ast.print_tree()

    type_checker = TypeChecker()
    type_checker(ast)
    if not type_checker.accepted:
        exit_fail('Cannot run your program: returning.')

    interpreter = Interpreter()
    interpreter(ast)
Example #39
0
class Hal:
    """
    Hal is our speech assistant and he starts to record spoken words after someone said "Hello Hal".
    And the speech assistant "Hal" reacts with an answer.
    """
    def __init__(self):
        self.listener = Listener()
        self.spoken_words = ""
        self.interpreter = Interpreter()

    def activate(self):
        print("mock: Hal is now activated and listening")
        print("Hello Dave what can I do for you?")
        self.main_menu()

    def main_menu(self):
        while True:
            utilities.clear_screen()
            print("*" * 80)
            print("Hal main menu")
            print("*" * 80)
            print("\t press 1 to talk to Hal")
            print("\t press 2 to turn off Hal")
            inp = input("Please type 1 or 2 and press enter:")
            if inp == "1":
                self.start_listening()
            elif inp == "2":
                sys.exit()
            else:
                input(
                    "Wrong command please press enter to continue and repeat")

    def start_listening(self):
        self.spoken_words = self.listener.listen()
        self.interpreter.execute(self.spoken_words)
        self.spoken_words = self.listener.listen()

    @staticmethod
    def error(message=''):
        print(message)
        input('Invalid input. Please press enter to continue. ')
Example #40
0
def main():
    # Settings
    os.environ['DYNACONF_SETTINGS'] = "settings.yml"

    # Parse arguments
    parser = argparse.ArgumentParser(description='Tool to manipulate accounts')
    subparsers = parser.add_subparsers(help='command help', dest='command')

    parser_balance = subparsers.add_parser('balance', help='balance help')

    parser_order = subparsers.add_parser('order', help='order help')
    parser_order.add_argument("market", action='store')
    parser_order.add_argument("coin", action='store')
    parser_order.add_argument("order_id", action='store')

    parser_order = subparsers.add_parser('cancel', help='cancel help')
    parser_order.add_argument("market", action='store')
    parser_order.add_argument("coin", action='store')
    parser_order.add_argument("order_id", action='store')

    parser_order = subparsers.add_parser('sell', help='sell help')
    parser_order.add_argument("market", action='store')
    parser_order.add_argument("coin", action='store')
    parser_order.add_argument("volume", action='store', type=float)
    parser_order.add_argument("rate", action='store', type=float)

    parser_order = subparsers.add_parser('buy', help='buy help')
    parser_order.add_argument("market", action='store')
    parser_order.add_argument("coin", action='store')
    parser_order.add_argument("volume", action='store', type=float)
    parser_order.add_argument("rate", action='store', type=float)

    parser_order = subparsers.add_parser('ticker', help='ticker help')
    parser_order.add_argument("market", action='store')
    parser_order.add_argument("coin", action='store')

    args = parser.parse_args()

    # Interpret command
    interpreter = Interpreter()
    interpreter.interpret(args)
Example #41
0
    def __init__(self, game, speed, sprites, state=None):
        super().__init__()
        self.game = game
        self.sound = QtMultimedia.QSound('beep.wav')
        self.controller = Controller()

        path = os.path.join("games", game)
        self.interpreter = Interpreter(path, self.controller, sprites,
                                       self.sound.play)
        if state is not None:
            self.interpreter.load_state(state)

        self.display = Display(self)
        self.display.move(0, 0)
        self.display.resize(640, 320)
        self.resize(640, 320)
        self.show()

        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(self.main_loop)
        self.timer.start(10 - (speed / 10))
Example #42
0
def make_tree(source, o):
    program = source.read()
    print('program: ', program)
    tokens = lexer(program)

    # removing space and comment tokens before passing list to parser
    parser_tokens = [
        token for token in tokens
        if token.type != 'COMMENT' and token.type != 'SPACE'
    ]

    tree = parser(parser_tokens)
    print(tree)
    interpreter = Interpreter()
    interpreter.eval(tree)
    brainf = interpreter.result()
    print('Brainfuck translation: \n', brainf)
    print('\n')
    print('Program', o.name, 'saved')
    o.write(brainf)
    o.flush()
Example #43
0
def main():
    if len(sys.argv) != 2:
        print('Usage: %s FILE' % sys.argv[0])
        exit(0)

    code = eigthxp_read_code(sys.argv[1])
    print('%s %s %s' % ('=' * 30, 'Tokenizer', '=' * 30))
    tokens = list(Tokenizer(code))
    print('%s %s %s' % ('=' * 30, 'Parser', '=' * 30))
    instructions = list(Parser(tokens))
    print('%s %s %s' % ('=' * 30, 'VM', '=' * 30))
    Interpreter().run(instructions)
Example #44
0
def main():
    while True:
        try:
            text = input("calc>>")
        except Exception as e:
            break

        if len(text) == 0:
            continue
        if text == 'exit':
            break

        interpreter = Interpreter(Lexer(text))

        try:
            result = interpreter.interpret()
        except Exception as e:
            print(e)
            continue

        print(result)
Example #45
0
 def test1(self):
     """
     Takes no input and produces a copy of itself as output.
     """
     pgm = parse(
         '109,1,204,-1,1001,100,1,100,1008,100,16,101,1006,101,0,99')
     interpreter = iter(Interpreter(pgm))
     # Why is it not copying itself properly?
     self.assertEqual(list(interpreter), [
         109, 1, 204, -1, 1001, 100, 1, 100, 1008, 100, 16, 101, 1006, 101,
         0, 99, -1
     ])
Example #46
0
class Jarvis(object):

    def __init__(self):
        self.config = Config()
        self.interpreter = Interpreter(self.config)
        self.model = "resources/JARVIS.pmdl"
        self.sensitivity = 0.3
        self.audio_gain = 1.2
        self.detector = snowboydecoder.HotwordDetector(self.model, sensitivity=self.sensitivity,
                                                       audio_gain=self.audio_gain)
        self.interpreter.calibrate(self.run)

    def detect_callback(self):
        self.detector.terminate()
        snowboydecoder.play_audio_file(snowboydecoder.DETECT_DING)
        self.interpreter.listen()
        self.run()

    def run(self):
        print "start recognizing word"
        self.detector.start(detected_callback=self.detect_callback, sleep_time=0.03)
Example #47
0
def test_compound_statement():
    text = """
BEGIN
     BEGIN
         number := 2;
         a := number;
         b := 10 * a + 10 * number / 4;
         c := a - - b
     END;
     x := 11;
END.
"""
    interpreter = Interpreter(Parser(Lexer(text)))
    interpreter.interpret()
    ar = interpreter.call_stack.peek()

    assert ar["number"] == 2
    assert ar["a"] == 2
    assert ar["b"] == 25
    assert ar["c"] == 27
    assert ar["x"] == 11
Example #48
0
def main():
    file = open('console.psc', 'r')

    line = file.readline()
    code = line
    while len(line) > 0:

        line = file.readline()
        code += ' EOL ' + line

    analyzer = Analyzer(code)
    interpreter = Interpreter(analyzer)
Example #49
0
 def test_prime(self):
     interpreter = Interpreter()
     self.assertEqual(interpreter.runProgram('21@v'), 'False',
                      'Should be False')
     self.assertEqual(interpreter.runProgram('1v'), 'False',
                      'Should be False')
     self.assertEqual(interpreter.runProgram('0v'), 'False',
                      'Should be False')
     self.assertEqual(interpreter.runProgram('1~v'), 'False',
                      'Should be False')
     self.assertEqual(interpreter.runProgram('2v'), 'True',
                      'Should be True')
     self.assertEqual(interpreter.runProgram('29@v'), 'True',
                      'Should be True')
Example #50
0
def repl():
    print('PyBasic v0.3 (c) 2020 Gently Solutions Ltd')
    print('Type "exit" to quit.')
    i = Interpreter()
    while True:
        source = input("> ")
        if source.upper() == "EXIT":
            break
        if source.upper() == "DEBUG ON":
            print("Debug flag turned on.")
            i.debug = True
            continue
        if source.upper() == "DEBUG OFF":
            print("Debug flag turned off.")
            i.debug = False
            continue
        regex = re.compile('^[0-9]+')
        result = regex.match(source)
        if result:
            lineno = int(result.group())
            code = source[result.end():]
            if code == "":
                i.program.pop(lineno, -1)  # delete code line
            else:
                # todo - think about how to process code before storing
                # should it be parsed and tokenized and grammatically checked ?
                i.program.update({lineno: code})  # insert plain code line
        else:
            try:
                i.execute(source)
            except IndexError as e:
                pass
            except SyntaxError as e:
                print(e)
Example #51
0
def test19():
    i = Interpreter()
    inp_str = "x=2"
    out_str = i.eval_string(inp_str)
    assert out_str == "2"
    assert "x" in i._variables
    assert i._variables["x"].val == Number(2)

    inp_str = "y=x"
    out_str = i.eval_string(inp_str)
    assert out_str == "2"
    assert "y" in i._variables
    assert i._variables["y"].val == Number(2)

    inp_str = "y=7"
    out_str = i.eval_string(inp_str)
    assert out_str == "7"
    assert "y" in i._variables
    assert i._variables["y"].val == Number(7)

    inp_str = "y = 2 * i - 4"
    out_str = i.eval_string(inp_str)
    assert out_str == "-4 + 2i"
    assert "y" in i._variables
    assert i._variables["y"].val == ComplexNumber(-4, 2)
Example #52
0
    def test_individual_operations(self):
        value = Interpreter().visit(AddNode(NumberNode(27), NumberNode(14))
        self.assertEqual(value, Number(41))  

        value = Interpreter().visit(SubtractNode(NumberNode(27), NumberNode(14))
        self.assertEqual(value, Number(13))        

        value = Interpreter().visit(MultiplyNode(NumberNode(27), NumberNode(14))
        self.assertEqual(value, Number(378)) 

        value = Interpreter().visit(DivideNode(NumberNode(27), NumberNode(14))
        self.assertEqual(value.value, 1.92857, 5))  

        with self.assertRaises(Exception):
            Interpreter().visit(DivideNode(NumberNode(27), NumberNode(0)))

    def test_full_expression(self):
       tree=AddNode(
            NumberNode(27),
            MultiplyNode(
                SubtractNode(
                    DivideNode(
                        NumberNode(43),
                        NumberNode(36),
                    ),
                    NumberNode(48),
                ),
                NumberNode(51),
            )
        )
        result = Interpreter().visit(tree)            
        self.assertAlmostEqual(result.value, -2360.08, 2)
Example #53
0
def test_parser_case_insensitive():
    sources = '''
        PROGRAM Part10;

        VAR
           x : INTEGER;
           y : REAL;

        PROCEDURE P1(z : REAL; i : integer);
            VAR A2 : REAL;

            procedure p2(a : INTEGER);
            begin
                a2 := a + 1;
            end;
        BEGIN {P1}
            p2(1); {2}
            x := x + a2 + z + i; {6}
            y := x * 2; {12}
        END;  {P1}

        beGin {Part10}
           BEGIN
              x := 1;
              Y := x / 3;
           END;
           P1(1, 2);
        End.  {Part10}

        '''

    tree = Parser(Lexer(sources)).parse()
    SemanticAnalyzer().analyze(tree)

    interpreter = Interpreter()
    top_stack_frame = interpreter.run(tree)

    assert top_stack_frame['x'] == 6
    assert top_stack_frame['y'] == 12
Example #54
0
def main():
    mode = 'INFIX'
    interpreter = Interpreter()

    while True:
        try:
            text = input(mode + ' -> ')
        except EOFError:
            break

        if not text:
            continue

        if text.strip() == 'exit':
            break

        if text.strip().upper() in ['INFIX', 'POSTFIX', 'PREFIX']:
            mode = text.strip().upper()
            continue

        result = interpreter.eval(text, mode)
        print(result)
Example #55
0
def calculate_result(res, literals):
    combinations = list(itertools.product([1, 0], repeat=len(literals)))
    truth_table = []

    for i in range(len(combinations) - 1, -1, -1):
        translator = {}
        for key_ in literals:
            translator[key_] = combinations[i][literals.index(key_)]

        interpreter = Interpreter(translator)
        truth_table.append([
            int(interpreter.read(res)),
            [translator[literal] for literal in literals]
        ])

    knf_form, dnf_form = normal_forms(truth_table, literals)
    print("KNF:", knf_form)
    print("DNF:", dnf_form)
    if len(truth_table) > 1:
        print(' '.join(literals), "S")
        for entry in truth_table:
            print(' '.join(map(str, entry[1])), entry[0])
Example #56
0
def run_feedback_loop(program, settings):
    result = None
    output = [0]
    interpreters = [Interpreter(program, [setting]) for setting in settings]
    while result is None:
        for count, interpreter in enumerate(interpreters):
            interpreter.receive_input(output)

            while not interpreter.halt:
                result = interpreter.step()
            output = interpreter.output.copy()
            interpreter.output = []
    return result[0]
Example #57
0
async def apply(host='localhost', port='5432'):
    # this should be simplified into a one line declaration of Store or
    # some subclass or composition, then pass the single arg to server
    store = Store()
    communicator = Communicator(store)
    interpreter = Interpreter(store)

    # this could probably be simplified by giving manager a default
    # value in Service
    server = Server(host, port, interpreter, communicator)
    manager = Manager()
    service = Service(manager, server)

    await service.run()
    def test_proc_call(self):
        program_code = r'''
        program Main;

        procedure Alpha(a : integer; b : integer);
        var x : integer;
        begin
           x := (a + b ) * 2;
        end;

        begin { Main }

           Alpha(3 + 5, 7);  { procedure call }

        end.  { Main }
        '''
        lexer = Lexer(program_code)
        parser = Parser(lexer)
        tree = parser.parse()
        semantic_analyzer = SemanticAnalyzer()
        semantic_analyzer.visit(tree)
        interpreter = Interpreter(tree)
        interpreter.interpret()
 def run(self, test):
     for x in test:
         if x.isdigit():
             new = Node(x,None,None)
             self.push(new)
             self.leitura()
         else:
             node = Node(x)
             node.r = self.pop()
             node.l = self.pop()
             new = node
             self.push(new)
     raiz = Tree()
     raiz.root = self.pop()
     
     print("---------------")
     raiz.em_ordem(raiz.root)
     result = Interpreter()
     x = result.process(raiz.root)
     print(x)
     output = open('saida.txt', 'w')
     output.write(str(x))
     output.close()
def download_planning(uuid):
    try:
        planning = _get_planning(uuid, g.user_id)
    except CAPException as e:
        return e.res

    moodle_archive_path = planning.mbz_fullpath
    planning_txt = planning.planning_txt

    if not planning_txt:
        return _bad_request()

    # Make tmp directory for MBZ extraction and ics download
    with tempfile.TemporaryDirectory() as tmp_path:
        # Download calendar to tmp folder
        calendar = CalendarReader(planning.ics_fullpath)
        calendar_meetings = calendar.get_all_meetings()

        # Extract Moodle course to tmp folder
        with tarfile.open(moodle_archive_path) as tar_file:
            tar_file.extractall(tmp_path)
            course = MoodleCourse(tmp_path)

        interpreter = Interpreter(calendar_meetings, course)
        for line in planning_txt.split('\n'):
            event = interpreter.get_new_event_from_string(line)
            if not event.is_user_defined():
                course.replace_event(event)

        folder = os.path.join(app.config['UPLOAD_FOLDER'], uuid)
        latest_mbz_path = os.path.join(folder, 'latest.mbz')

        course.write(latest_mbz_path)

        with open(os.path.join(folder, 'latest.mbz'), 'rb') as f:
            encoded = base64.encodestring(f.read()).decode()
            return jsonify({'mbz_64': encoded})