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         if data[0] in ['{', '}', ':', ',', '[', ']']:
  17             yield data[0]
  18             data = data[1:]
  19         elif data[0] in ' \n':
  20             data = data[1:]
  21         elif data[0] == "'":
  22             data = data[1:]
  23             string = ''
  24             while data[0] != "'":
  25                 string += data[0]
  26                 data = data[1:]
  27             data = data[1:]
  28             yield string
  29
  30 def parse(tokens):
  31     if tokens[0] == '{':
  32         ret = OrderedDict()
  33         tokens = tokens[1:]
  34         while tokens[0] != '}':
  35             key = tokens[0]
  36             tokens = tokens[1:]
  37
  38             tokens = tokens[1:] # :
  39
  40             value, tokens = parse(tokens)
  41
  42             if tokens[0] == ',':
  43                 tokens = tokens[1:]
  44
  45             ret[key] = value
  46         tokens = tokens[1:]
  47         return ret, tokens
  48     elif tokens[0] == '[':
  49         ret = []
  50         tokens = tokens[1:]
  51         while tokens[0] != ']':
  52             value, tokens = parse(tokens)
  53             if tokens[0] == ',':
  54                 tokens = tokens[1:]
  55             ret.append(value)
  56         tokens = tokens[1:]
  57         return ret, tokens
  58     else:
  59         return tokens[0], tokens[1:]
  60
  61 def evaluate(string):
  62     return parse(map(lambda x: x, tokenize(string)))[0]
  63
  64 def parse_schema(fp):
  65     exprs = []
  66     expr = ''
  67     expr_eval = None
  68
  69     for line in fp:
  70         if line.startswith('#') or line == '\n':
  71             continue
  72
  73         if line.startswith(' '):
  74             expr += line
  75         elif expr:
  76             expr_eval = evaluate(expr)
  77             if expr_eval.has_key('enum'):
  78                 add_enum(expr_eval['enum'])
  79             elif expr_eval.has_key('union'):
  80                 add_enum('%sKind' % expr_eval['union'])
  81             exprs.append(expr_eval)
  82             expr = line
  83         else:
  84             expr += line
  85
  86     if 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
  94     return exprs
  95
  96 def parse_args(typeinfo):
  97     for member in typeinfo:
  98         argname = member
  99         argentry = typeinfo[member]
 100         optional = False
 101         structured = False
 102         if member.startswith('*'):
 103             argname = member[1:]
 104             optional = True
 105         if isinstance(argentry, OrderedDict):
 106             structured = True
 107         yield (argname, argentry, optional, structured)
 108
 109 def de_camel_case(name):
 110     new_name = ''
 111     for ch in name:
 112         if ch.isupper() and new_name:
 113             new_name += '_'
 114         if ch == '-':
 115             new_name += '_'
 116         else:
 117             new_name += ch.lower()
 118     return new_name
 119
 120 def camel_case(name):
 121     new_name = ''
 122     first = True
 123     for ch in name:
 124         if ch in ['_', '-']:
 125             first = True
 126         elif first:
 127             new_name += ch.upper()
 128             first = False
 129         else:
 130             new_name += ch.lower()
 131     return new_name
 132
 133 def c_var(name):
 134     return name.replace('-', '_').lstrip("*")
 135
 136 def c_fun(name):
 137     return c_var(name).replace('.', '_')
 138
 139 def c_list_type(name):
 140     return '%sList' % name
 141
 142 def type_name(name):
 143     if type(name) == list:
 144         return c_list_type(name[0])
 145     return name
 146
 147 enum_types = []
 148
 149 def add_enum(name):
 150     global enum_types
 151     enum_types.append(name)
 152
 153 def is_enum(name):
 154     global enum_types
 155     return (name in enum_types)
 156
 157 def c_type(name):
 158     if name == 'str':
 159         return 'char *'
 160     elif name == 'int':
 161         return 'int64_t'
 162     elif name == 'bool':
 163         return 'bool'
 164     elif name == 'number':
 165         return 'double'
 166     elif type(name) == list:
 167         return '%s *' % c_list_type(name[0])
 168     elif is_enum(name):
 169         return name
 170     elif name == None or len(name) == 0:
 171         return 'void'
 172     elif name == name.upper():
 173         return '%sEvent *' % camel_case(name)
 174     else:
 175         return '%s *' % name
 176
 177 def genindent(count):
 178     ret = ""
 179     for i in range(count):
 180         ret += " "
 181     return ret
 182
 183 indent_level = 0
 184
 185 def push_indent(indent_amount=4):
 186     global indent_level
 187     indent_level += indent_amount
 188
 189 def pop_indent(indent_amount=4):
 190     global indent_level
 191     indent_level -= indent_amount
 192
 193 def cgen(code, **kwds):
 194     indent = genindent(indent_level)
 195     lines = code.split('\n')
 196     lines = map(lambda x: indent + x, lines)
 197     return '\n'.join(lines) % kwds + '\n'
 198
 199 def mcgen(code, **kwds):
 200     return cgen('\n'.join(code.split('\n')[1:-1]), **kwds)
 201
 202 def basename(filename):
 203     return filename.split("/")[-1]
 204
 205 def guardname(filename):
 206     guard = basename(filename).rsplit(".", 1)[0]
 207     for substr in [".", " ", "-"]:
 208         guard = guard.replace(substr, "_")
 209     return guard.upper() + '_H'