/// <summary> /// Processes authorization node. /// </summary> /// <param name="node">The node.</param> private void Process_Authorization(dynamic node) { Authorization authorization = context.GetObject(node); // Namespace is processed already // Name is processed already // Interface (obligatory) SourceLocationInfo location = new SourceLocationInfo(node.Interface, context); try { authorization.Interface = this.Process_NamespacedTypeReference(node.Interface, typeof(Interface)); } catch (NameNotFoundException exception) { Error_NameNotFound(location, exception); } catch (NameCollisionException exception) { Error_NameCollision(location, exception); } // OperationAuthorizations are not processed in this phase }
/// <summary> /// Processes namespace node. /// </summary> /// <param name="node">The node.</param> private void Process_Namespace(dynamic node) { // Find or create the namespace (and its parents, if necessary) Namespace @namespace = this.Process_NamespaceReference(node.Name); // Map source location and node to object SourceLocationInfo location = new SourceLocationInfo(node, context); @namespace.AddMetaInfo(location); context.AddObject(node, @namespace); // Uri (optional) if (node.Uri != null) { if (@namespace.Uri != null) { Error_NamespaceUri(location, @namespace); } else { @namespace.Uri = node.Uri.Replace("\"", ""); } } // Enter scope using (new NameContextScope(@namespace)) { // Imports are not processed yet // Declarations (optional) if (node.Declarations != null) { foreach (dynamic decl in node.Declarations) { this.Process(decl); } } } }
/// <summary> /// Processes struct node. /// </summary> /// <param name="node">The node.</param> private void Process_StructType(dynamic node) { StructType structType = context.GetObject(node); // Namespace is processed already // Name is processed already // Fields (optional) if (node.Fields != null) { // Enter scope using (new NameContextScope(structType)) { foreach (dynamic field in node.Fields) { this.Process_StructField(field); } } } // SuperType (optional) if (node.SuperType != null) { SourceLocationInfo location = new SourceLocationInfo(node.SuperType, context); try { structType.SuperType = this.Process_NamespacedTypeReference(node.SuperType, typeof(StructType)); } catch (NameNotFoundException exception) { Error_NameNotFound(location, exception); } catch (NameCollisionException exception) { Error_NameCollision(location, exception); } } }
private void Process_Operation(dynamic node) { Operation operation = new Operation(); // Map source location and node to object operation.AddMetaInfo(new SourceLocationInfo(node, context)); context.AddObject(node, operation); // Interface try { NameContext.Current.CheckName(node.Name, typeof(Operation)); operation.Interface = (Interface)NameContext.Current.Scope; } catch (NameCollisionException exception) { Error_NameExists(operation, exception); } // Name (obligatory) operation.Name = node.Name; // ReturnType (obligatory) try { operation.ReturnType = this.Process_ReturnTypeReference(node.ReturnType); } catch (NameNotFoundException exception) { Error_NameNotFound(operation, exception); } catch (NameCollisionException exception) { Error_NameCollision(operation, exception); } // Enter scope using (new NameContextScope(operation)) { // Parameters (optional) if (node.Parameters != null) { foreach (dynamic param in node.Parameters) { this.Process_OperationParameter(param); } } // Exceptions (optional) if (node.Exceptions != null) { foreach (dynamic exc in node.Exceptions) { SourceLocationInfo location = new SourceLocationInfo(exc, context); try { ExceptionType exceptionType = this.Process_NamespacedTypeReference(exc, typeof(ExceptionType)); if (operation.Exceptions.Contains(exceptionType)) { Error_NameRedundant(location, typeof(ExceptionType), exceptionType.FullName); } else { operation.Exceptions.Add(exceptionType); } } catch (NameNotFoundException exception) { Error_NameNotFound(location, exception); } catch (NameCollisionException exception) { Error_NameCollision(location, exception); } } } } }
/// <summary> /// Processes namespace node. /// </summary> /// <param name="node">The node.</param> private void Process_Namespace(dynamic node) { // Find object Namespace @namespace = context.GetObject(node); // Uri is processed already // Enter scope using (new NameContextScope(@namespace)) { // Imports (optional) if (node.Imports != null) { foreach (dynamic import in node.Imports) { SourceLocationInfo location = new SourceLocationInfo(import, context); try { Namespace importedNamespace = this.Process_NamespaceReference(import.Name); if (!NameContext.Current.Imports.Add(importedNamespace)) { Error_NamespaceImport(location, importedNamespace); } } catch (NameNotFoundException exception) { Error_NameNotFound(location, exception); } } } // Declarations (optional) if (node.Declarations != null) { foreach (dynamic decl in node.Declarations) { this.Process(decl); } } } }
/// <summary> /// Processes interface node. /// </summary> /// <param name="node">The node.</param> private void Process_Interface(dynamic node) { Interface @interface = context.GetObject(node); // Namespace is processed already // Name is processed already // Version is processed already // Operations (optional) if (node.Operations != null) { // Enter scope using (new NameContextScope(@interface)) { foreach (dynamic op in node.Operations) { this.Process_Operation(op); } } } // SuperInterfaces (optional) if (node.SuperInterfaces != null) { foreach (dynamic super in node.SuperInterfaces) { SourceLocationInfo location = new SourceLocationInfo(super, context); try { @interface.SuperInterfaces.Add(this.Process_NamespacedTypeReference(super, typeof(Interface))); } catch (NameNotFoundException exception) { Error_NameNotFound(location, exception); } catch (NameCollisionException exception) { Error_NameCollision(location, exception); } } } }
/// <summary> /// Processes endpoint node. /// </summary> /// <param name="node">The node.</param> private void Process_Endpoint(dynamic node) { Endpoint endpoint = context.GetObject(node); // Namespace is processed already // Name is processed already // Interface (obligatory) SourceLocationInfo interfaceLocation = new SourceLocationInfo(node.Interface, context); try { endpoint.Interface = this.Process_NamespacedTypeReference(node.Interface, typeof(Interface)); } catch (NameNotFoundException exception) { Error_NameNotFound(interfaceLocation, exception); } catch (NameCollisionException exception) { Error_NameCollision(interfaceLocation, exception); } // Binding (optional) if (node.Properties.Binding != null) { SourceLocationInfo bindingLocation = new SourceLocationInfo(node.Properties.Binding, context); try { endpoint.Binding = this.Process_NamespacedTypeReference(node.Properties.Binding, typeof(Binding)); } catch (NameNotFoundException exception) { Error_NameNotFound(bindingLocation, exception); } catch (NameCollisionException exception) { Error_NameCollision(bindingLocation, exception); } } // Authorization is not processed yet // Contract is not processed yet // Address is processed already }
/// <summary> /// Processes endpoint node. /// </summary> /// <param name="node">The node.</param> private void Process_Endpoint(dynamic node) { Endpoint endpoint = context.GetObject(node); // Namespace is processed already // Name is processed already // Interface is processed already // Binding is processed already // Authorization (optional) if (node.Properties.Authorization != null) { SourceLocationInfo authorizationLocation = new SourceLocationInfo(node.Properties.Authorization, context); try { endpoint.Authorization = this.Process_NamespacedTypeReference(node.Properties.Authorization, typeof(Authorization)); if (endpoint.Authorization.Interface != endpoint.Interface) { if (endpoint.Authorization.Interface.GetSuperTypes().Contains(endpoint.Interface)) { // Authorization's interface is stronger than endpoint's Warning_InterfaceMismatch(authorizationLocation, typeof(Authorization)); } else if(endpoint.Interface.GetSuperTypes().Contains(endpoint.Authorization.Interface)) { // Authorization's interface is weaker than endpoints's Warning_InterfaceMismatch(authorizationLocation, typeof(Authorization)); } else { // Authorization's interface does not match endpoint's Error_InterfaceMismatch(authorizationLocation, typeof(Authorization)); } } } catch (NameNotFoundException exception) { Error_NameNotFound(authorizationLocation, exception); } catch (NameCollisionException exception) { Error_NameCollision(authorizationLocation, exception); } } // Contract (optional) if (node.Properties.Contract != null) { SourceLocationInfo contractLocation = new SourceLocationInfo(node.Properties.Contract, context); try { endpoint.Contract = this.Process_NamespacedTypeReference(node.Properties.Contract, typeof(Contract)); if (endpoint.Contract.Interface != endpoint.Interface) { if (endpoint.Contract.Interface.GetSuperTypes().Contains(endpoint.Interface)) { // Contract's interface is stronger than endpoint's Warning_InterfaceMismatch(contractLocation, typeof(Contract)); } else if (endpoint.Interface.GetSuperTypes().Contains(endpoint.Contract.Interface)) { // Contract's interface is weaker than endpoints's Warning_InterfaceMismatch(contractLocation, typeof(Contract)); } else { // Contract's interface does not match endpoint's Error_InterfaceMismatch(contractLocation, typeof(Contract)); } } } catch (NameNotFoundException exception) { Error_NameNotFound(contractLocation, exception); } catch (NameCollisionException exception) { Error_NameCollision(contractLocation, exception); } } // Address is processed already }