Merge pull request #52 from thejoeejoee/feature/escapes-solution

Final string escapes solution

Author: thejoeejoee

ifj2017/interpreter/exceptions.py

@@ -50,6 +50,15 @@ def __str__(self):
         return 'Unknown data type error{}'.format(self.on_line)
 
 
+class StringError(BaseInterpreterError):
+    def __init__(self, source, index):
+        self._source = source
+        self._index = index
+
+    def __str__(self):
+        return 'Invalid index {} on string "{}"{}'.format(self._index, self._source, self.on_line)
+
+
 class EmptyDataStackError(BaseInterpreterError):
     def __str__(self):
         return 'Empty data stack error{}'.format(self.on_line)

ifj2017/interpreter/instruction.py

@@ -151,10 +151,7 @@ def operands(self):
             state.get_value(op1),
         ))),
         'STRLEN': State.str_len,
-        'GETCHAR': lambda state, target, string, index: state.set_value(
-            target,
-            state.get_value(string)[state.get_value(index)]
-        ),
+        'GETCHAR': State.get_char,
         'SETCHAR': State.set_char,
 
         'INT2FLOAT': lambda state, op0, op1: state.set_value(op1, float(state.get_value(op1))),

ifj2017/interpreter/operand.py

@@ -22,6 +22,17 @@ def float(value):
         return float_.fromhex(value)
 
 
+ESCAPE_RE = re.compile(r'\\([0-9]{3})')
+
+
+def unquote_escape_sequences(value):
+    def __(m):
+        # magic for decimal \ddd to octal \ooo
+        return chr(int(m.group(1)))
+
+    return ESCAPE_RE.sub(__, value)
+
+
 class TypeOperand(IntEnum):
     VARIABLE = 1
     CONSTANT = 2
@@ -75,20 +86,22 @@ def __init__(self, value):
 
         raise InvalidCodeException(InvalidCodeException.INVALID_OPERAND)
 
-    def _resolve_constant(self, constant_match):
-        # type: (Match) -> None
-        type_, value = constant_match.groups()
+    def _resolve_constant(self, constant_match: Match[str]) -> None:
+        type_, value = constant_match.groups()  # type: str, str
+        type_ = type_.lower().strip()
         try:
-            self.value = self.CONSTANT_MAPPING.get(type_.lower())(value)
-            if type_.lower() == self.CONSTANT_MAPPING_REVERSE.get(bool):
+            self.value = self.CONSTANT_MAPPING.get(type_)(value)
+            if type_ == self.CONSTANT_MAPPING_REVERSE.get(bool):
                 self.value = self.BOOL_LITERAL_MAPPING.get(value.lower())
+            elif type_ == self.CONSTANT_MAPPING_REVERSE.get(str):
+                self.value = unquote_escape_sequences(value=self.value)
         except ValueError:
             pass
         if self.value is None:
             raise InvalidCodeException(type_=InvalidCodeException.INVALID_OPERAND)
         self.type = TypeOperand.CONSTANT
 
-    def _resolve_variable(self, variable_match):
+    def _resolve_variable(self, variable_match: Match[str]) -> None:
         # type: (Match) -> None
         frame, name = variable_match.groups()
         if not (frame and name):
@@ -97,8 +110,8 @@ def _resolve_variable(self, variable_match):
         self.name = name
         self.type = TypeOperand.VARIABLE
 
-    def _resolve_type(self, type_match):
-        # type: (Match) -> None
+    def _resolve_type(self, type_match: Match[str]) -> None:
+        # type: (Match[str]) -> None
         self.data_type = type_match.group(1).lower()
         if self.data_type not in self.CONSTANT_MAPPING:
             raise InvalidCodeException(type_=InvalidCodeException.INVALID_OPERAND)

ifj2017/interpreter/state.py

@@ -1,10 +1,10 @@
 # coding=utf-8
-import codecs
 import logging
 import re
 from io import StringIO
+from typing import Optional, Union
 
-from ifj2017.interpreter.exceptions import UnknownDataTypeError
+from ifj2017.interpreter.exceptions import UnknownDataTypeError, StringError
 from .exceptions import EmptyDataStackError, UndefinedVariableError, UndeclaredVariableError, \
     FrameError, UnknownLabelError, InvalidReturnError, InvalidOperandTypeError
 from .operand import Operand, TypeOperand
@@ -61,8 +61,7 @@ def pop_frame(self):
         self.temp_frame = self.frame_stack[-1]
         self.frame_stack = self.frame_stack[:-1]
 
-    def get_value(self, value):
-        # type: (Operand) -> object
+    def get_value(self, value: Optional[Operand]) -> Union[None, int, str, float]:
         if value is None:
             # variable declaration
             return None
@@ -153,8 +152,18 @@ def set_char(self, where, index, from_):
         changed[self.get_value(index)] = self.get_value(from_)[0]
         self.set_value(where, changed)
 
+    def get_char(self, target, string, index):
+        source = self.get_value(string)
+        try:
+            self.set_value(
+                target,
+                source[self.get_value(index)]
+            )
+        except IndexError:
+            raise StringError(source, self.get_value(index))
+
     def str_len(self, target, string):
-        return self.set_value(target, len(self.ESCAPE_RE.sub('_', self.get_value(string))))
+        return self.set_value(target, len(('_', self.get_value(string))))
 
     def read(self, to, type_):
         # type: (Operand, Operand) -> None
@@ -211,22 +220,7 @@ def write(self, op):
         elif isinstance(value, float):
             rendered = '{: g}'.format(value)
 
-        def __(m):
-            # magic for decimal \ddd to octal \ooo
-            return '\\{}'.format(
-                oct(
-                    int(
-                        m.group(1)
-                    )
-                ).lstrip('0o').zfill(3)
-            )
-
-        self.stdout.write(
-            codecs.decode(
-                self.ESCAPE_RE.sub(repl=__, string=rendered),
-                'unicode_escape'
-            )
-        )
+        self.stdout.write(rendered)
 
     def string_to_int_stack(self):
         index = self.pop_stack()

ifj2017/test/loader.py

@@ -185,21 +185,23 @@ def _parse_wildcards(tests_wildcards):
         return wildcards
 
     def _load_test_file(self, section_dir, test_name, type_):
-        return ((
-                    self.load_file(
-                        path.join(
-                            section_dir,
-                            '.'.join((test_name, type_))
-                        ),
-                        allow_fail=True
-                    ) or '').replace('\r\n', '\n').replace('\r', '\n')  # normalize newlines to \n
-                ) or ''
+        # splitlines is not possible due endlines at and of file
+        return (
+                   (
+                       self.load_file(
+                           path.join(
+                               section_dir,
+                               '.'.join((test_name, type_))
+                           ),
+                           allow_fail=True
+                       ) or '').replace('\r\n', '\n').replace('\r', '\n')  # normalize newlines to \n
+               ) or ''
 
     @staticmethod
     def load_file(file, allow_fail=False):
         assert allow_fail or (path.isfile(file) and os.access(file, os.R_OK))
         try:
-            with open(file, 'rb') as f:
+            with open(file, 'rbU') as f:
                 return f.read().decode('utf-8')
         except IOError:
             if not allow_fail:

ifj2017/test/runner.py

@@ -265,18 +265,22 @@ def _interpret(self, code, test_info):
 
         process = Popen([self._interpreter_binary, '-v', code_temp], stdout=PIPE, stdin=PIPE, stderr=PIPE)
         try:
-            out, err = process.communicate(input=bytes(test_info.stdin, encoding='utf-8'),
-                                           timeout=test_info.timeout)
+            out, err = process.communicate(
+                input=bytes(test_info.stdin, encoding='utf-8'),
+                timeout=test_info.timeout
+            )
         except (TimeoutError, TimeoutExpired):
             process.kill()
             raise
         finally:
             os.remove(code_temp)
         # err has non-escaped characters
-        return out.decode('ascii'), err.decode('unicode_escape'), process.returncode
+        return out.decode('raw_unicode_escape'), err.decode('raw_unicode_escape'), process.returncode
 
     def _interpret_price(self, code, test_info):
-        interpreter = Interpreter(code=code, state_kwargs=dict(stdin=StringIO(test_info.stdin)))
+        interpreter = Interpreter(code=code, state_kwargs=dict(
+            stdin=StringIO(test_info.stdin),
+        ))
         return interpreter.run()
 
     def _save_report(self, test_info, report):

ifj2017/tests/01_basic/tests.json

@@ -84,7 +84,7 @@
     {
       "info": "Print string with char 238",
       "code": "scope \n print !\"\\238\"; \n end scope",
-      "stdout": "Todo"
+      "stdout": "\u00ee"
     },
     {
       "name": "29",