plomlompom.com Git - plomrogue2/blob - plomrogue/parser.py

   1 import unittest
   2 from plomrogue.errors import ArgError
   3 from plomrogue.mapping import YX
   4
   5
   6 class Parser:
   7
   8     def __init__(self, game=None):
   9         self.game = game
  10
  11     def tokenize(self, msg):
  12         """Parse msg string into tokens.
  13
  14         Separates by ' ' and '\n', but allows whitespace in tokens quoted by
  15         '"', and allows escaping within quoted tokens by a prefixed backslash.
  16         """
  17         tokens = []
  18         token = ''
  19         quoted = False
  20         escaped = False
  21         for c in msg:
  22             if quoted:
  23                 if escaped:
  24                     token += c
  25                     escaped = False
  26                 elif c == '\\':
  27                     escaped = True
  28                 elif c == '"':
  29                     quoted = False
  30                 else:
  31                     token += c
  32             elif c == '"':
  33                 quoted = True
  34             elif c in {' ', '\n'}:
  35                 if len(token) > 0:
  36                     tokens += [token]
  37                     token = ''
  38             else:
  39                 token += c
  40         if len(token) > 0:
  41             tokens += [token]
  42         return tokens
  43
  44     def parse_yx_tuple(self, yx_string, range_=None):
  45         """Parse yx_string as yx_tuple, return result.
  46
  47         The range_ argument may be 'nonneg' (non-negative, including
  48         0) or 'pos' (positive, excluding 0).
  49
  50         """
  51
  52         def get_axis_position_from_argument(axis, token):
  53             if len(token) < 3 or token[:2] != axis + ':' or \
  54                     not (token[2:].isdigit() or token[2] == '-'):
  55                 raise ArgError('Non-int arg for ' + axis + ' position.')
  56             n = int(token[2:])
  57             if n < 1 and range_ == 'pos':
  58                 raise ArgError('Arg for ' + axis + ' position < 1.')
  59             elif n < 0 and range_ == 'nonneg':
  60                 raise ArgError('Arg for ' + axis + ' position < 0.')
  61             return n
  62
  63         tokens = yx_string.split(',')
  64         if len(tokens) != 2:
  65             raise ArgError('Wrong number of yx-tuple arguments.')
  66         y = get_axis_position_from_argument('Y', tokens[0])
  67         x = get_axis_position_from_argument('X', tokens[1])
  68         return YX(y, x)
  69
  70     def parse(self, msg):
  71         """Parse msg as call to function, return function with args tuple.
  72
  73         Respects function signature defined in function's .argtypes attribute.
  74         """
  75         tokens = self.tokenize(msg)
  76         if len(tokens) == 0:
  77             return None, ()
  78         func = self.game.get_command(tokens[0])
  79         argtypes = ''
  80         if hasattr(func, 'argtypes'):
  81             argtypes = func.argtypes
  82         if func is None:
  83             return None, ()
  84         if len(argtypes) == 0:
  85             if len(tokens) > 1:
  86                 raise ArgError('Command expects no argument(s).')
  87             return func, ()
  88         if len(tokens) == 1:
  89             raise ArgError('Command expects argument(s).')
  90         args_candidates = tokens[1:]
  91         args = self.argsparse(argtypes, args_candidates)
  92         return func, args
  93
  94     def argsparse(self, signature, args_tokens):
  95         tmpl_tokens = signature.split()
  96         if len(tmpl_tokens) != len(args_tokens):
  97             raise ArgError('Number of arguments (' + str(len(args_tokens)) +
  98                            ') not expected number (' + str(len(tmpl_tokens))
  99                            + ').')
 100         args = []
 101         string_string = 'string'
 102         for i in range(len(tmpl_tokens)):
 103             tmpl = tmpl_tokens[i]
 104             arg = args_tokens[i]
 105             if tmpl == 'int:nonneg':
 106                 if not arg.isdigit():
 107                     raise ArgError('Argument must be non-negative integer.')
 108                 args += [int(arg)]
 109             elif tmpl == 'int:pos':
 110                 if not arg.isdigit() or int(arg) < 1:
 111                     raise ArgError('Argument must be positive integer.')
 112                 args += [int(arg)]
 113             elif tmpl == 'char':
 114                 try:
 115                     ord(arg)
 116                 except TypeError:
 117                     raise ArgError('Argument must be single character.')
 118                 args += [arg]
 119             elif tmpl == 'yx_tuple:nonneg':
 120                 args += [self.parse_yx_tuple(arg, 'nonneg')]
 121             elif tmpl == 'yx_tuple:pos':
 122                 args += [self.parse_yx_tuple(arg, 'pos')]
 123             elif tmpl == string_string:
 124                 args += [arg]
 125             elif tmpl[:len(string_string) + 1] == string_string + ':':
 126                 if not hasattr(self.game, 'get_string_options'):
 127                     raise ArgError('No string option directory.')
 128                 string_option_type = tmpl[len(string_string) + 1:]
 129                 options = self.game.get_string_options(string_option_type)
 130                 if options is None:
 131                     raise ArgError('Unknown string option type.')
 132                 if arg not in options:
 133                     msg = 'Argument #%s must be one of: %s' % (i + 1, options)
 134                     raise ArgError(msg)
 135                 args += [arg]
 136             else:
 137                 raise ArgError('Unknown argument type: %s' % tmpl)
 138         return args