Example #1
0
        /// <summary>
        /// Generate the C# source code for this enumerant.
        /// </summary>
        /// <param name="sw">
        /// A <see cref="SourceStreamWriter"/> used for writing the source code.
        /// </param>
        internal void GenerateSource(SourceStreamWriter sw, RegistryContext ctx)
        {
            if (sw == null)
            {
                throw new ArgumentNullException("sw");
            }

            RegistryDocumentation.GenerateDocumentation(sw, ctx, this);

            foreach (Enumerant aliasOf in AliasOf)
            {
                sw.WriteLine("[AliasOf(\"{0}\")]", aliasOf.Name);
            }

            foreach (IFeature feature in RequiredBy)
            {
                sw.WriteLine("[RequiredByFeature(\"{0}\")]", feature.Name);
            }
            foreach (Enumerant aliasOf in AliasOf)
            {
                foreach (IFeature feature in aliasOf.RequiredBy)
                {
                    sw.WriteLine("[RequiredByFeature(\"{0}\")]", feature.Name);
                }
            }
            foreach (IFeature feature in RemovedBy)
            {
                sw.WriteLine("[RemovedByFeature(\"{0}\")]", feature.Name);
            }

            // This metadata is used for procedure logging function
            bool requiresLogAttribute = ParentEnumerantBlock.Type == "bitmask";

            if (requiresLogAttribute == true)
            {
                if (ParentEnumerantBlock.Type == "bitmask")
                {
                    sw.WriteLine("[Log(BitmaskName = \"{0}\")]", ParentEnumerantBlock.Namespace);
                }
            }

            if (IsDeprecated)
            {
                sw.Write("#if DEBUG && !OPENGL_NET_COMPATIBILITY_PROFILE" + Environment.NewLine);
                sw.WriteLine("[Obsolete(\"Deprecated/removed by {0}.\")]", SpecificationStyle.GetKhronosVersionHumanReadable(RemovedBy[0].Name));
                sw.Write("#endif" + Environment.NewLine);
            }

            sw.WriteLine(Declaration);
        }
Example #2
0
        /// <summary>
        /// Generate the command implementation signature and the method documentation.
        /// </summary>
        /// <param name="sw">
        /// The <see cref="SourceStreamWriter"/> used to write the source code.
        /// </param>
        /// <param name="ctx">
        /// The <see cref="RegistryContext"/> defining the OpenGL registry information.
        /// </param>
        /// <param name="commandParams">
        /// A <see cref="T:List{CommandParameter}"/> determining the method overload.
        /// </param>
        private void GenerateImplementation_Signature(SourceStreamWriter sw, RegistryContext ctx, List <CommandParameter> commandParams, string implementationName, string returnType)
        {
#if !DEBUG
            // Documentation
            RegistryDocumentation.GenerateDocumentation(sw, ctx, this, commandParams);
#endif

            foreach (IFeature feature in RequiredBy)
            {
                sw.WriteLine("[RequiredByFeature(\"{0}\")]", feature.Name);
            }
            foreach (IFeature feature in RemovedBy)
            {
                sw.WriteLine("[RemovedByFeature(\"{0}\")]", feature.Name);
            }

            #region Signature

            sw.WriteIdentation();

            // Signature
            sw.Write("{0} static ", CommandFlagsDatabase.GetCommandVisibility(this));
            if (IsUnsafeImplementationSignature(ctx, commandParams))
            {
                sw.Write("unsafe ");
            }
            sw.Write("{0} {1}(", returnType, implementationName);
            // Signature - Parameters
            int paramCount = commandParams.FindAll(delegate(CommandParameter item) { return(!item.IsImplicit(ctx, this)); }).Count;

            foreach (CommandParameter param in commandParams)
            {
                // Skip in signature implicit parameters
                if (param.IsImplicit(ctx, this))
                {
                    continue;
                }

                string paramAttributes = param.GetImplementationTypeAttributes(ctx, this);
                string paramModifier   = param.GetImplementationTypeModifier(ctx, this);

                if (paramAttributes != null)
                {
                    sw.Write("{0} ", paramAttributes);
                }
                if (paramModifier != null)
                {
                    sw.Write("{0} ", paramModifier);
                }

                if ((paramCount == 1) && (param.IsManagedArray) && ((Flags & CommandFlags.VariadicParams) != 0))
                {
                    sw.Write("params ");
                }

                sw.Write("{0} {1}", param.GetImplementationType(ctx, this), param.ImplementationName);
                paramCount--;
                if (paramCount > 0)
                {
                    sw.Write(", ");
                }
            }
            sw.Write(")");
            sw.WriteLine();

            #endregion
        }