scripts/qapi.py

   1 #
   2 # QAPI helper library
   3 #
   4 # Copyright IBM, Corp. 2011
   5 #
   6 # Authors:
   7 #  Anthony Liguori <aliguori@us.ibm.com>
   8 #
   9 # This work is licensed under the terms of the GNU GPLv2.
  10 # See the COPYING.LIB file in the top-level directory.
  11
  12 from ordereddict import OrderedDict
  13
  14 def tokenize(data):
  15     while len(data):
  16         ch = data[0]
  17         data = data[1:]
  18         if ch in ['{', '}', ':', ',', '[', ']']:
  19             yield ch
  20         elif ch in ' \n':
  21             None
  22         elif ch == "'":
  23             string = ''
  24             esc = False
  25             while True:
  26                 if (data == ''):
  27                     raise Exception("Mismatched quotes")
  28                 ch = data[0]
  29                 data = data[1:]
  30                 if esc:
  31                     string += ch
  32                     esc = False
  33                 elif ch == "\\":
  34                     esc = True
  35                 elif ch == "'":
  36                     break
  37                 else:
  38                     string += ch
  39             yield string
  40
  41 def parse(tokens):
  42     if tokens[0] == '{':
  43         ret = OrderedDict()
  44         tokens = tokens[1:]
  45         while tokens[0] != '}':
  46             key = tokens[0]
  47             tokens = tokens[1:]
  48
  49             tokens = tokens[1:] # :
  50
  51             value, tokens = parse(tokens)
  52
  53             if tokens[0] == ',':
  54                 tokens = tokens[1:]
  55
  56             ret[key] = value
  57         tokens = tokens[1:]
  58         return ret, tokens
  59     elif tokens[0] == '[':
  60         ret = []
  61         tokens = tokens[1:]
  62         while tokens[0] != ']':
  63             value, tokens = parse(tokens)
  64             if tokens[0] == ',':
  65                 tokens = tokens[1:]
  66             ret.append(value)
  67         tokens = tokens[1:]
  68         return ret, tokens
  69     else:
  70         return tokens[0], tokens[1:]
  71
  72 def evaluate(string):
  73     return parse(map(lambda x: x, tokenize(string)))[0]
  74
  75 def parse_schema(fp):
  76     exprs = []
  77     expr = ''
  78     expr_eval = None
  79
  80     for line in fp:
  81         if line.startswith('#') or line == '\n':
  82             continue
  83
  84         if line.startswith(' '):
  85             expr += line
  86         elif expr:
  87             expr_eval = evaluate(expr)
  88             if expr_eval.has_key('enum'):
  89                 add_enum(expr_eval['enum'])
  90             elif expr_eval.has_key('union'):
  91                 add_enum('%sKind' % expr_eval['union'])
  92             exprs.append(expr_eval)
  93             expr = line
  94         else:
  95             expr += line
  96
  97     if expr:
  98         expr_eval = evaluate(expr)
  99         if expr_eval.has_key('enum'):
 100             add_enum(expr_eval['enum'])
 101         elif expr_eval.has_key('union'):
 102             add_enum('%sKind' % expr_eval['union'])
 103         exprs.append(expr_eval)
 104
 105     return exprs
 106
 107 def parse_args(typeinfo):
 108     for member in typeinfo:
 109         argname = member
 110         argentry = typeinfo[member]
 111         optional = False
 112         structured = False
 113         if member.startswith('*'):
 114             argname = member[1:]
 115             optional = True
 116         if isinstance(argentry, OrderedDict):
 117             structured = True
 118         yield (argname, argentry, optional, structured)
 119
 120 def de_camel_case(name):
 121     new_name = ''
 122     for ch in name:
 123         if ch.isupper() and new_name:
 124             new_name += '_'
 125         if ch == '-':
 126             new_name += '_'
 127         else:
 128             new_name += ch.lower()
 129     return new_name
 130
 131 def camel_case(name):
 132     new_name = ''
 133     first = True
 134     for ch in name:
 135         if ch in ['_', '-']:
 136             first = True
 137         elif first:
 138             new_name += ch.upper()
 139             first = False
 140         else:
 141             new_name += ch.lower()
 142     return new_name
 143
 144 def c_var(name):
 145     return name.replace('-', '_').lstrip("*")
 146
 147 def c_fun(name):
 148     return c_var(name).replace('.', '_')
 149
 150 def c_list_type(name):
 151     return '%sList' % name
 152
 153 def type_name(name):
 154     if type(name) == list:
 155         return c_list_type(name[0])
 156     return name
 157
 158 enum_types = []
 159
 160 def add_enum(name):
 161     global enum_types
 162     enum_types.append(name)
 163
 164 def is_enum(name):
 165     global enum_types
 166     return (name in enum_types)
 167
 168 def c_type(name):
 169     if name == 'str':
 170         return 'char *'
 171     elif name == 'int':
 172         return 'int64_t'
 173     elif (name == 'int8' or name == 'int16' or name == 'int32' or
 174           name == 'int64' or name == 'uint8' or name == 'uint16' or
 175           name == 'uint32' or name == 'uint64'):
 176         return name + '_t'
 177     elif name == 'size':
 178         return 'uint64_t'
 179     elif name == 'bool':
 180         return 'bool'
 181     elif name == 'number':
 182         return 'double'
 183     elif type(name) == list:
 184         return '%s *' % c_list_type(name[0])
 185     elif is_enum(name):
 186         return name
 187     elif name == None or len(name) == 0:
 188         return 'void'
 189     elif name == name.upper():
 190         return '%sEvent *' % camel_case(name)
 191     else:
 192         return '%s *' % name
 193
 194 def genindent(count):
 195     ret = ""
 196     for i in range(count):
 197         ret += " "
 198     return ret
 199
 200 indent_level = 0
 201
 202 def push_indent(indent_amount=4):
 203     global indent_level
 204     indent_level += indent_amount
 205
 206 def pop_indent(indent_amount=4):
 207     global indent_level
 208     indent_level -= indent_amount
 209
 210 def cgen(code, **kwds):
 211     indent = genindent(indent_level)
 212     lines = code.split('\n')
 213     lines = map(lambda x: indent + x, lines)
 214     return '\n'.join(lines) % kwds + '\n'
 215
 216 def mcgen(code, **kwds):
 217     return cgen('\n'.join(code.split('\n')[1:-1]), **kwds)
 218
 219 def basename(filename):
 220     return filename.split("/")[-1]
 221
 222 def guardname(filename):
 223     guard = basename(filename).rsplit(".", 1)[0]
 224     for substr in [".", " ", "-"]:
 225         guard = guard.replace(substr, "_")
 226     return guard.upper() + '_H'