def print_children(i_children,
module,
fd,
prefix,
path,
ctx,
level=0,
exdata=None):
global depth
if len(i_children) > 0:
depth = max(depth, level)
for ch in i_children:
disabled_feature = False
iffeature = ch.search('if-feature')
for f in iffeature:
# find a feature in imported module [by robot]
if ":" in f.arg:
import_prefix, import_feature = util.split_identifier(f.arg)
if import_prefix is not None and import_feature is not None:
import_pos = None
import_err = []
import_module = util.prefix_to_module(
module, import_prefix, import_pos, import_err)
if import_module is not None:
if import_module in ctx.features and import_feature not in ctx.features[
import_module.arg]:
print(ch.search("feature"),
ch.search('if-feature'),
ctx.features[module.arg], "disabled feature")
# ignore disabled feature
disabled_feature = True
else:
if f.arg not in ctx.features[module.arg]:
print(ch.search("feature"), ch.search('if-feature'),
ctx.features[module.arg], "disabled feature")
# ignore disabled feature
disabled_feature = True
# if f.arg not in ctx.features[module.arg]:
# print (ch.search("feature"), ch.search('if-feature'), ctx.features[module.arg], "disabled feature")
# # ignore disabled feature
# disabled_feature = True
if not disabled_feature:
print_node(ch, module, fd, prefix, path, ctx, level, exdata=exdata)
def typestring(node):
def get_nontypedefstring(node):
s = ""
found = False
t = node.search_one('type')
if t is not None:
s = t.arg + '\n'
if t.arg == 'enumeration':
found = True
s = s + ' : {'
for enums in t.substmts:
s = s + enums.arg + ','
s = s + '}'
elif t.arg == 'leafref':
found = True
s = s + ' : '
p = t.search_one('path')
if p is not None:
s = s + p.arg
elif t.arg == 'identityref':
found = True
b = t.search_one('base')
if b is not None:
s = s + ' {' + b.arg + '}'
elif t.arg == 'union':
found = True
uniontypes = t.search('type')
s = s + '{' + uniontypes[0].arg
for uniontype in uniontypes[1:]:
s = s + ', ' + uniontype.arg
s = s + '}'
typerange = t.search_one('range')
if typerange is not None:
found = True
s = s + ' [' + typerange.arg + ']'
length = t.search_one('length')
if length is not None:
found = True
s = s + ' {length = ' + length.arg + '}'
pattern = t.search_one('pattern')
if pattern is not None: # truncate long patterns
found = True
s = s + ' {pattern = ' + pattern.arg + '}'
return s
s = get_nontypedefstring(node)
if s != "":
t = node.search_one('type')
# chase typedef
type_namespace = None
i_type_name = None
name = t.arg
if name.find(":") == -1:
prefix = None
else:
[prefix, name] = name.split(':', 1)
if prefix is None or t.i_module.i_prefix == prefix:
# check local typedefs
pmodule = node.i_module
typedef = statements.search_typedef(t, name)
else:
# this is a prefixed name, check the imported modules
err = []
pmodule = util.prefix_to_module(t.i_module, prefix, t.pos, err)
if pmodule is None:
return
typedef = statements.search_typedef(pmodule, name)
if typedef != None:
s = s + get_nontypedefstring(typedef)
return s
def getType(node):
global codegenTypesToYangTypesMap
xpath = statements.mk_path_str(node, True)
def resolveType(stmt, nodeType):
if nodeType == "string" \
or nodeType == "instance-identifier" \
or nodeType == "identityref":
return codegenTypesToYangTypesMap["string"]
elif nodeType == "enumeration":
enums = []
for enum in stmt.substmts:
if enum.keyword == "enum":
enums.append(enum.arg)
return codegenTypesToYangTypesMap["string"], enums
elif nodeType == "empty" or nodeType == "boolean":
return {"type": "boolean", "format": "boolean"}
elif nodeType == "leafref":
return handle_leafref(node, xpath)
elif nodeType == "union":
return codegenTypesToYangTypesMap["string"]
elif nodeType == "decimal64":
return codegenTypesToYangTypesMap[nodeType]
elif nodeType in [
'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32',
'uint64', 'binary', 'bits'
]:
return codegenTypesToYangTypesMap[nodeType]
else:
print("no base type found")
sys.exit(2)
base_types = [
'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32',
'uint64', 'decimal64', 'string', 'boolean', 'enumeration', 'bits',
'binary', 'leafref', 'identityref', 'empty', 'union',
'instance-identifier'
]
# Get Type of a node
t = node.search_one('type')
while t.arg not in base_types:
# chase typedef
name = t.arg
if name.find(":") == -1:
prefix = None
else:
[prefix, name] = name.split(':', 1)
if prefix is None or t.i_module.i_prefix == prefix:
# check local typedefs
pmodule = node.i_module
typedef = statements.search_typedef(t, name)
else:
# this is a prefixed name, check the imported modules
err = []
pmodule = util.prefix_to_module(t.i_module, prefix, t.pos, err)
if pmodule is None:
return
typedef = statements.search_typedef(pmodule, name)
if typedef is None:
print(
"Typedef ", name,
" is not found, make sure all dependent modules are present")
sys.exit(2)
t = typedef.search_one('type')
return resolveType(t, t.arg)
def typestring(node):
def get_nontypedefstring(node):
s = {}
found = False
t = node.search_one('type')
if t is not None:
s['type'] = t.arg
if t.arg == 'enumeration':
found = True
s['enumeration'] = []
for enums in t.substmts:
s['enumeration'].append(enums.arg)
elif t.arg == 'leafref':
found = True
p = t.search_one('path')
if p is not None:
s['path'] = p.arg
elif t.arg == 'identityref':
found = True
b = t.search_one('base')
if b is not None:
s['base'] = b.arg
elif t.arg == 'union':
found = True
uniontypes = t.search('type')
s['union'] = [uniontypes[0].arg]
for uniontype in uniontypes[1:]:
s['union'].append(uniontype.arg)
typerange = t.search_one('range')
if typerange is not None:
found = True
s['type_range'] = typerange.arg
length = t.search_one('length')
if length is not None:
found = True
s['length'] = length.arg
pattern = t.search_one('pattern')
if pattern is not None:
found = True
s['pattern'] = json_escape(pattern.arg)
return s
s = get_nontypedefstring(node)
if len(s) != 0:
t = node.search_one('type')
# chase typedef
type_namespace = None
i_type_name = None
name = t.arg
if name.find(":") == -1:
prefix = None
else:
[prefix, name] = name.split(':', 1)
if prefix is None or t.i_module.i_prefix == prefix:
# check local typedefs
pmodule = node.i_module
typedef = statements.search_typedef(t, name)
else:
# this is a prefixed name, check the imported modules
err = []
pmodule = util.prefix_to_module(
t.i_module, prefix, t.pos, err)
if pmodule is None:
return
typedef = statements.search_typedef(pmodule, name)
if typedef != None:
s['typedef'] = get_nontypedefstring(typedef)
return s
def build_store_from_definitions(self, ctx, defnd):
unresolved_identities = list(defnd.keys())
unresolved_identity_count = {k: 0 for k in defnd}
error_ids = []
mod_ref_prefixes = module_import_prefixes(ctx)
while len(unresolved_identities):
this_id = unresolved_identities.pop(0)
iddef = defnd[this_id]
base = iddef.search_one("base")
try:
mainmod = iddef.main_module()
except AttributeError:
mainmod = None
if mainmod is not None:
defmod = mainmod
defining_module = defmod.arg
namespace = defmod.search_one("namespace").arg
prefix = defmod.search_one("prefix").arg
if base is None:
# Add a new identity which can be a base
tid = Identity(iddef.arg)
tid.source_module = defining_module
tid.source_namespace = namespace
tid.add_prefix(prefix)
self.add_identity(tid)
if defining_module in mod_ref_prefixes:
for i in mod_ref_prefixes[defining_module]:
tid.add_prefix(i)
else:
# Determine what the name of the base and the prefix for
# the base should be
if ":" in base.arg:
base_pfx, base_name = base.arg.split(":")
else:
base_pfx, base_name = prefix, base.arg
parent_module = util.prefix_to_module(defmod, base_pfx,
base.pos, ctx.errors)
# Find whether we have the base in the store
base_id = self.find_identity_by_source_name(
parent_module.arg, base_name)
if base_id is None:
# and if not, then push this identity back onto the stack
unresolved_identities.append(this_id)
unresolved_identity_count[this_id] += 1
# FIXME(Joey Wilhelm): `unresolved_idc` and `ident` are both undefined. What is the intent of this code?
# if unresolved_identity_count[this_id] > 1000:
# if unresolved_idc[ident] > 1000:
# sys.stderr.write("could not find a match for %s base: %s\n" %
# (iddef.arg, base_name))
# error_ids.append(ident)
else:
# Check we don't already have this identity defined
if self.find_identity_by_source_name(
defining_module, iddef.arg) is None:
# otherwise, create a new identity that reflects this one
tid = Identity(iddef.arg)
tid.source_module = defining_module
tid.source_namespace = namespace
tid.add_prefix(prefix)
base_id.add_child(tid)
self.add_identity(tid)
if defining_module in mod_ref_prefixes:
for i in mod_ref_prefixes[defining_module]:
tid.add_prefix(i)
if error_ids:
raise TypeError("could not resolve identities %s" % error_ids)
self._build_inheritance()
def build_store_from_definitions(self, ctx, defnd):
unresolved_identities = list(defnd.keys())
unresolved_identity_count = {k: 0 for k in defnd}
error_ids = []
mod_ref_prefixes = module_import_prefixes(ctx)
while len(unresolved_identities):
this_id = unresolved_identities.pop(0)
iddef = defnd[this_id]
base = iddef.search_one("base")
try:
mainmod = iddef.main_module()
except AttributeError:
mainmod = None
if mainmod is not None:
defmod = mainmod
defining_module = defmod.arg
namespace = defmod.search_one("namespace").arg
prefix = defmod.search_one("prefix").arg
if base is None:
# Add a new identity which can be a base
tid = Identity(iddef.arg)
tid.source_module = defining_module
tid.source_namespace = namespace
tid.add_prefix(prefix)
self.add_identity(tid)
if defining_module in mod_ref_prefixes:
for i in mod_ref_prefixes[defining_module]:
tid.add_prefix(i)
else:
# Determine what the name of the base and the prefix for
# the base should be
if ":" in base.arg:
base_pfx, base_name = base.arg.split(":")
else:
base_pfx, base_name = prefix, base.arg
parent_module = util.prefix_to_module(defmod, base_pfx, base.pos, ctx.errors)
# Find whether we have the base in the store
base_id = self.find_identity_by_source_name(parent_module.arg, base_name)
if base_id is None:
# and if not, then push this identity back onto the stack
unresolved_identities.append(this_id)
unresolved_identity_count[this_id] += 1
# FIXME(Joey Wilhelm): `unresolved_idc` and `ident` are both undefined. What is the intent of this code?
# if unresolved_identity_count[this_id] > 1000:
# if unresolved_idc[ident] > 1000:
# sys.stderr.write("could not find a match for %s base: %s\n" %
# (iddef.arg, base_name))
# error_ids.append(ident)
else:
# Check we don't already have this identity defined
if self.find_identity_by_source_name(defining_module, iddef.arg) is None:
# otherwise, create a new identity that reflects this one
tid = Identity(iddef.arg)
tid.source_module = defining_module
tid.source_namespace = namespace
tid.add_prefix(prefix)
base_id.add_child(tid)
self.add_identity(tid)
if defining_module in mod_ref_prefixes:
for i in mod_ref_prefixes[defining_module]:
tid.add_prefix(i)
if error_ids:
raise TypeError("could not resolve identities %s" % error_ids)
self._build_inheritance()
def find_target_node(self, stmt):
inthismod = True
if stmt.arg.startswith('/'):
is_absolute = True
arg = stmt.arg
else:
is_absolute = False
arg = "/" + stmt.arg
# parse the path into a list of two-tuples of (prefix,identifier)
path = [(m[1], m[2])
for m in syntax.re_schema_node_id_part.findall(arg)]
# find the module of the first node in the path
(prefix, identifier) = path[0]
if prefix == '':
inthismod = True
else:
inthismod = (prefix == self.thismod_prefix)
# sys.stderr.write("prefix for %s : %s \n" %(path, prefix))
module = util.prefix_to_module(stmt.i_module, prefix, stmt.pos,
self._ctx.errors)
if module is None:
# error is reported by prefix_to_module
return inthismod, None
if is_absolute:
# find the first node
node = statements.search_data_keyword_child(
module.i_children, module.i_modulename, identifier)
if node is None:
# check all our submodules
for inc in module.search('include'):
submod = self._ctx.get_module(inc.arg)
if submod is not None:
node = statements.search_data_keyword_child(
submod.i_children, submod.i_modulename, identifier)
if node is not None:
break
if node is None:
err_add(self._ctx.errors, stmt.pos, 'NODE_NOT_FOUND',
(module.arg, identifier))
return inthismod, None
path = path[1:]
else:
if hasattr(stmt.parent, 'i_annotate_node'):
node = stmt.parent.i_annotate_node
else:
err_add(self._ctx.errors, stmt.pos, 'BAD_ANNOTATE', ())
return inthismod, None
# then recurse down the path
for prefix, identifier in path:
module = util.prefix_to_module(stmt.i_module, prefix, stmt.pos,
self._ctx.errors)
if module is None:
return None
if hasattr(node, 'i_children'):
children = node.i_children
else:
children = []
child = statements.search_data_keyword_child(
children, module.i_modulename, identifier)
if child is None:
err_add(self._ctx.errors, stmt.pos, 'NODE_NOT_FOUND',
(module.arg, identifier))
return inthismod, None
node = child
stmt.i_annotate_node = node
return inthismod, node