<h2>Edit File: c_json.py</h2><form method="post"><textarea name="content" rows="20" cols="80">#------------------------------------------------------------------------------
# pycparser: c_json.py
#
# by Michael White (@mypalmike)
#
# This example includes functions to serialize and deserialize an ast
# to and from json format. Serializing involves walking the ast and converting
# each node from a python Node object into a python dict. Deserializing
# involves the opposite conversion, walking the tree formed by the
# dict and converting each dict into the specific Node object it represents.
# The dict itself is serialized and deserialized using the python json module.
#
# The dict representation is a fairly direct transformation of the object
# attributes. Each node in the dict gets one metadata field referring to the
# specific node class name, _nodetype. Each local attribute (i.e. not linking
# to child nodes) has a string value or array of string values. Each child
# attribute is either another dict or an array of dicts, exactly as in the
# Node object representation. The &quot;coord&quot; attribute, representing the
# node&#039;s location within the source code, is serialized/deserialized from
# a Coord object into a string of the format &quot;filename:line[:column]&quot;.
#
# Example TypeDecl node, with IdentifierType child node, represented as a dict:
#     &quot;type&quot;: {
#         &quot;_nodetype&quot;: &quot;TypeDecl&quot;,
#         &quot;coord&quot;: &quot;c_files/funky.c:8&quot;,
#         &quot;declname&quot;: &quot;o&quot;,
#         &quot;quals&quot;: [],
#         &quot;type&quot;: {
#             &quot;_nodetype&quot;: &quot;IdentifierType&quot;,
#             &quot;coord&quot;: &quot;c_files/funky.c:8&quot;,
#             &quot;names&quot;: [
#                 &quot;char&quot;
#             ]
#         }
#     }
#------------------------------------------------------------------------------
from __future__ import print_function

import json
import sys
import re


from pycparser import parse_file, c_ast
from pycparser.plyparser import Coord


RE_CHILD_ARRAY = re.compile(r&#039;(.*)\[(.*)\]&#039;)
RE_INTERNAL_ATTR = re.compile(&#039;__.*__&#039;)


class CJsonError(Exception):
    pass


def memodict(fn):
    &quot;&quot;&quot; Fast memoization decorator for a function taking a single argument &quot;&quot;&quot;
    class memodict(dict):
        def __missing__(self, key):
            ret = self[key] = fn(key)
            return ret
    return memodict().__getitem__


@memodict
def child_attrs_of(klass):
    &quot;&quot;&quot;
    Given a Node class, get a set of child attrs.
    Memoized to avoid highly repetitive string manipulation

    &quot;&quot;&quot;
    non_child_attrs = set(klass.attr_names)
    all_attrs = set([i for i in klass.__slots__ if not RE_INTERNAL_ATTR.match(i)])
    return all_attrs - non_child_attrs


def to_dict(node):
    &quot;&quot;&quot; Recursively convert an ast into dict representation. &quot;&quot;&quot;
    klass = node.__class__

    result = {}

    # Metadata
    result[&#039;_nodetype&#039;] = klass.__name__

    # Local node attributes
    for attr in klass.attr_names:
        result[attr] = getattr(node, attr)

    # Coord object
    if node.coord:
        result[&#039;coord&#039;] = str(node.coord)
    else:
        result[&#039;coord&#039;] = None

    # Child attributes
    for child_name, child in node.children():
        # Child strings are either simple (e.g. &#039;value&#039;) or arrays (e.g. &#039;block_items[1]&#039;)
        match = RE_CHILD_ARRAY.match(child_name)
        if match:
            array_name, array_index = match.groups()
            array_index = int(array_index)
            # arrays come in order, so we verify and append.
            result[array_name] = result.get(array_name, [])
            if array_index != len(result[array_name]):
                raise CJsonError(&#039;Internal ast error. Array {} out of order. &#039;
                    &#039;Expected index {}, got {}&#039;.format(
                    array_name, len(result[array_name]), array_index))
            result[array_name].append(to_dict(child))
        else:
            result[child_name] = to_dict(child)

    # Any child attributes that were missing need &quot;None&quot; values in the json.
    for child_attr in child_attrs_of(klass):
        if child_attr not in result:
            result[child_attr] = None

    return result


def to_json(node, **kwargs):
    &quot;&quot;&quot; Convert ast node to json string &quot;&quot;&quot;
    return json.dumps(to_dict(node), **kwargs)


def file_to_dict(filename):
    &quot;&quot;&quot; Load C file into dict representation of ast &quot;&quot;&quot;
    ast = parse_file(filename, use_cpp=True)
    return to_dict(ast)


def file_to_json(filename, **kwargs):
    &quot;&quot;&quot; Load C file into json string representation of ast &quot;&quot;&quot;
    ast = parse_file(filename, use_cpp=True)
    return to_json(ast, **kwargs)


def _parse_coord(coord_str):
    &quot;&quot;&quot; Parse coord string (file:line[:column]) into Coord object. &quot;&quot;&quot;
    if coord_str is None:
        return None

    vals = coord_str.split(&#039;:&#039;)
    vals.extend([None] * 3)
    filename, line, column = vals[:3]
    return Coord(filename, line, column)


def _convert_to_obj(value):
    &quot;&quot;&quot;
    Convert an object in the dict representation into an object.
    Note: Mutually recursive with from_dict.

    &quot;&quot;&quot;
    value_type = type(value)
    if value_type == dict:
        return from_dict(value)
    elif value_type == list:
        return [_convert_to_obj(item) for item in value]
    else:
        # String
        return value


def from_dict(node_dict):
    &quot;&quot;&quot; Recursively build an ast from dict representation &quot;&quot;&quot;
    class_name = node_dict.pop(&#039;_nodetype&#039;)

    klass = getattr(c_ast, class_name)

    # Create a new dict containing the key-value pairs which we can pass
    # to node constructors.
    objs = {}
    for key, value in node_dict.items():
        if key == &#039;coord&#039;:
            objs[key] = _parse_coord(value)
        else:
            objs[key] = _convert_to_obj(value)

    # Use keyword parameters, which works thanks to beautifully consistent
    # ast Node initializers.
    return klass(**objs)


def from_json(ast_json):
    &quot;&quot;&quot; Build an ast from json string representation &quot;&quot;&quot;
    return from_dict(json.loads(ast_json))


#------------------------------------------------------------------------------
if __name__ == &quot;__main__&quot;:
    if len(sys.argv) &gt; 1:
        # Some test code...
        # Do trip from C -&gt; ast -&gt; dict -&gt; ast -&gt; json, then print.
        ast_dict = file_to_dict(sys.argv[1])
        ast = from_dict(ast_dict)
        print(to_json(ast, sort_keys=True, indent=4))
    else:
        print(&quot;Please provide a filename as argument&quot;)
</textarea><br><input type="hidden" name="edit_file" value="c_json.py"><input type="submit" value="Save"></form>