protected virtual void ParseProto(ParserContext context)
{
context.ReadKeyword("PROTO");
var proto = new ProtoNode
{
Name = ParseNodeNameId(context)
};
context.PushNodeContainer(proto.Children);
context.PushFieldContainer(proto);
ParseInterfaceDeclarations(context);
if (context.ReadNextToken().Type != VrmlTokenType.OpenBrace)
{
throw new InvalidVrmlSyntaxException();
}
ParseProtoBody(context);
if (context.ReadNextToken().Type != VrmlTokenType.CloseBrace)
{
throw new InvalidVrmlSyntaxException();
}
context.PopFieldContainer();
context.PopNodeContainer();
context.RegisterPtototype(proto);
}
void RecursiveAddPublicDependencies(HashSet <FileDescriptorProto> set, ProtoNode node, int depth)
{
if (depth == 0)
{
foreach (var dep in node.Proto.dependency)
{
var depend = protobufMap[dep];
set.Add(depend.Proto);
RecursiveAddPublicDependencies(set, depend, depth + 1);
}
}
else
{
foreach (var idx in node.Proto.public_dependency)
{
var depend = protobufMap[node.Proto.dependency[idx]];
set.Add(depend.Proto);
RecursiveAddPublicDependencies(set, depend, depth + 1);
}
}
}
private void RecursiveAnalyzeMessageDescriptor(DescriptorProto messageType, ProtoNode protoNode,
string packagePath)
{
protoNode.Types.Add(GetOrCreateTypeNode(GetPackagePath(packagePath, messageType.name), protoNode.Proto,
messageType));
foreach (var extension in messageType.extension)
{
if (!string.IsNullOrEmpty(extension.extendee))
{
protoNode.Types.Add(GetOrCreateTypeNode(GetPackagePath(packagePath, extension.extendee)));
}
}
foreach (var enumType in messageType.enum_type)
{
protoNode.Types.Add(GetOrCreateTypeNode(
GetPackagePath(GetPackagePath(packagePath, messageType.name), enumType.name),
protoNode.Proto, enumType));
}
foreach (var field in messageType.field)
{
if (IsNamedType(field.type) && !string.IsNullOrEmpty(field.type_name))
{
protoNode.Types.Add(GetOrCreateTypeNode(GetPackagePath(packagePath, field.type_name)));
}
if (!string.IsNullOrEmpty(field.extendee))
{
protoNode.Types.Add(GetOrCreateTypeNode(GetPackagePath(packagePath, field.extendee)));
}
}
foreach (var nested in messageType.nested_type)
{
RecursiveAnalyzeMessageDescriptor(nested, protoNode, GetPackagePath(packagePath, messageType.name));
}
}
public static TreeNode GetOrCreate(ProtoNode pn, Dictionary <string, ProtoNode> pnodes, Dictionary <string, TreeNode> constructedNodes)
{
if (constructedNodes.ContainsKey(pn.Name))
{
return(constructedNodes[pn.Name]);
}
var treeNode = new TreeNode();
treeNode.Name = pn.Name;
treeNode.Weight = pn.Weight;
constructedNodes.Add(treeNode.Name, treeNode);
foreach (var child in pn.Children)
{
var childNode = GetOrCreate(pnodes[child], pnodes, constructedNodes);
treeNode.Children.Add(childNode);
childNode.Parent = treeNode;
}
return(treeNode);
}
public void RegisterPtototype(ProtoNode proto)
{
m_nodeFactory.AddPrototype(proto);
}
public bool Analyze()
{
foreach (var proto in protobufs)
{
var protoNode = new ProtoNode()
{
Name = proto.name,
Proto = proto,
Dependencies = new List <ProtoNode>(),
AllPublicDependencies = new HashSet <FileDescriptorProto>(),
Types = new List <ProtoTypeNode>(),
Defined = true
};
protobufMap.Add(proto.name, protoNode);
foreach (var extension in proto.extension)
{
protoNode.Types.Add(GetOrCreateTypeNode(GetPackagePath(proto.package, extension.name), proto, extension));
if (IsNamedType(extension.type) && !string.IsNullOrEmpty(extension.type_name))
{
protoNode.Types.Add(GetOrCreateTypeNode(GetPackagePath(proto.package, extension.type_name)));
}
if (!string.IsNullOrEmpty(extension.extendee))
{
protoNode.Types.Add(GetOrCreateTypeNode(GetPackagePath(proto.package, extension.extendee)));
}
}
foreach (var enumType in proto.enum_type)
{
protoNode.Types.Add(GetOrCreateTypeNode(GetPackagePath(proto.package, enumType.name), proto, enumType));
}
foreach (var messageType in proto.message_type)
{
RecursiveAnalyzeMessageDescriptor(messageType, protoNode, proto.package);
}
foreach (var service in proto.service)
{
protoNode.Types.Add(GetOrCreateTypeNode(GetPackagePath(proto.package, service.name), proto, service));
foreach (var method in service.method)
{
if (!string.IsNullOrEmpty(method.input_type))
{
protoNode.Types.Add(GetOrCreateTypeNode(GetPackagePath(proto.package, method.input_type)));
}
if (!string.IsNullOrEmpty(method.output_type))
{
protoNode.Types.Add(GetOrCreateTypeNode(GetPackagePath(proto.package, method.output_type)));
}
}
}
}
// inspect file dependencies
var missingDependencies = new List <ProtoNode>();
foreach (var pair in protobufMap)
{
foreach (var dependency in pair.Value.Proto.dependency)
{
if (dependency.StartsWith("google", StringComparison.Ordinal))
{
continue;
}
if (protobufMap.TryGetValue(dependency, out var depends))
{
pair.Value.Dependencies.Add(depends);
}
else
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Unknown dependency: {0} for {1}", dependency, pair.Value.Proto.name);
Console.ResetColor();
var missing = missingDependencies.Find(x => x.Name == dependency);
if (missing == null)
{
missing = new ProtoNode()
{
Name = dependency,
Proto = null,
Dependencies = new List <ProtoNode>(),
AllPublicDependencies = new HashSet <FileDescriptorProto>(),
Types = new List <ProtoTypeNode>(),
Defined = false
};
missingDependencies.Add(missing);
}
pair.Value.Dependencies.Add(missing);
}
}
}
foreach (var depend in missingDependencies)
{
protobufMap.Add(depend.Name, depend);
}
foreach (var pair in protobufMap)
{
var undefinedFiles = pair.Value.Dependencies.Where(x => !x.Defined).ToList();
if (undefinedFiles.Count > 0)
{
Console.WriteLine("Not all dependencies were found for {0}", pair.Key);
foreach (var file in undefinedFiles)
{
var x = protobufMap[file.Name];
Console.WriteLine("Dependency not found: {0}", file.Name);
}
return(false);
}
var undefinedTypes = pair.Value.Types.Where(x => !x.Defined).ToList();
if (undefinedTypes.Count > 0)
{
Console.WriteLine("Not all types were resolved for {0}", pair.Key);
foreach (var type in undefinedTypes)
{
var x = protobufTypeMap[type.Name];
Console.WriteLine("Type not found: {0}", type.Name);
}
return(false);
}
// build the list of all publicly accessible types from each file
RecursiveAddPublicDependencies(pair.Value.AllPublicDependencies, pair.Value, 0);
}
return(true);
}
