/// <summary>
		/// Reduce a <see cref="Command"/> name, removing type suffixes.
		/// </summary>
		/// <param name="ctx">
		/// A <see cref="RegistryContext"/> defining OpenGL specification information.
		/// </param>
		/// <param name="specificationName">
		/// A <see cref="String"/> that specifies the command name.
		/// </param>
		/// <returns>
		/// It returns a <see cref="String"/> that is the reduced name (suitable for overriding commands) of
		/// <paramref name="specificationName"/>.
		/// </returns>
		public string GetOverridableName(RegistryContext ctx, string specificationName)
		{
			if (String.IsNullOrEmpty(specificationName))
				throw new ArgumentNullException("specificationName");

			// Extract extension
			string nameExtension = null;

			foreach (string word in ctx.ExtensionsDictionary.Words) {
				if (specificationName.EndsWith(word)) {
					nameExtension = word;
					break;
				}
			}

			if (nameExtension != null)
				specificationName = specificationName.Substring(0, specificationName.Length - nameExtension.Length);

			string postfix = specificationName;

			foreach (string word in Words) {
				postfix = postfix.Replace(word, String.Empty);

				if (postfix.Length == 0)
					break;
			}

			if ((postfix.Length > 0) && specificationName.EndsWith(postfix) && (ctx.ExtensionsDictionary.HasWord(postfix) == false))
				specificationName = specificationName.Substring(0, specificationName.Length - postfix.Length);

			if (nameExtension != null)
				specificationName += nameExtension;

			return (specificationName);
		}

		public override void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand)
		{
			if (mIsStrong) {
				// Strongly typed enum must be casted to delegate call type (int or uint)
				sw.Write("({0}){1}", OverridenParameter.ImportType, DelegateCallVarName);
			} else
				base.WriteDelegateParam(sw, ctx, parentCommand);
		}

		/// <summary>
		/// Construct a CommandParameterArray from the original parameter.
		/// </summary>
		/// <param name="otherParam"></param>
		/// <param name="ctx"></param>
		/// <param name="parentCommand"></param>
		public CommandParameterArrayLength(CommandParameter otherParam, RegistryContext ctx, Command parentCommand)
			: base(otherParam, ctx, parentCommand)
		{
			if (otherParam == null)
				throw new ArgumentNullException("otherParam");

			
		}

		/// <summary>
		/// Construct a CommandParameterUnsafe from the original parameter.
		/// </summary>
		/// <param name="otherParam"></param>
		/// <param name="ctx"></param>
		/// <param name="parentCommand"></param>
		public CommandParameterUnsafe(CommandParameter otherParam, RegistryContext ctx, Command parentCommand)
			: base(otherParam)
		{
			if (otherParam == null)
				throw new ArgumentNullException("otherParam");

			if (IsCompatible(ctx, parentCommand, otherParam)) {
				_IsPointer = true;
			}
		}

		/// <summary>
		/// Construct a CommandParameterStrong from the original parameter.
		/// </summary>
		/// <param name="otherParam"></param>
		/// <param name="ctx"></param>
		/// <param name="parentCommand"></param>
		public CommandParameterStrong(CommandParameter otherParam, RegistryContext ctx, Command parentCommand)
			: base(otherParam)
		{
			if (otherParam == null)
				throw new ArgumentNullException("otherParam");

			if (IsCompatible(otherParam, ctx, parentCommand)) {
				Type = otherParam.Group;
				mIsStrong = true;
			}
		}

		internal static CommandParameter GetArrayLengthParameter(CommandParameter param, RegistryContext ctx, Command parentCommand)
		{
			List<CommandParameter> arrayLengthParams = parentCommand.Parameters.FindAll(delegate(CommandParameter item) {
				return (parentCommand.Parameters.FindIndex(delegate(CommandParameter subitem) { return (item.Length == param.Name); }) >= 0);
			});

			if (arrayLengthParams.Count > 0)
				return (arrayLengthParams[0]);
			else
				return (null);
		}

		internal static new bool IsCompatible(RegistryContext ctx, Command parentCommand, CommandParameter param)
		{
			if (!param.IsManagedArray || param.Length == null)
				return (false);

			int sizeParamIndex = parentCommand.Parameters.FindIndex(delegate (CommandParameter item) { return (item.Name == param.Length); });

			if (sizeParamIndex < 0)
				return (false);

			return (true);
		}

		public void Link(RegistryContext ctx)
		{
			foreach (Command command in Commands)
				command.Link(ctx);

			// Remove enumerants not required by anyone
			Commands.RemoveAll(delegate(Command item) {
				if (item.RequiredBy.Count == 0)
					return (true);
				return (false);
			});
		}

		internal static bool IsCompatible(CommandParameter param, RegistryContext ctx, Command parentCommand)
		{
			// 'bool' parameters are in Boolean group: conditions below will pass
			if (param.GetImplementationType(ctx, parentCommand) == "bool")
				return (false);

			// Unsafe parameters are not allowed, Group is a requirement
			if (!param.IsSafe || param.Group == null)
				return (false);

			// Check actual existence of strongly typed enum
			return (ctx.Registry.Groups.FindIndex(delegate(EnumerantGroup item) { return (item.Name == param.Group); }) >= 0);
		}

		/// <summary>
		/// Construct a CommandParameterOut from the original parameter.
		/// </summary>
		/// <param name="otherParam"></param>
		/// <param name="ctx"></param>
		/// <param name="parentCommand"></param>
		public CommandParameterOut(CommandParameter otherParam, RegistryContext ctx, Command parentCommand, bool strong)
			: base(otherParam)
		{
			if (otherParam == null)
				throw new ArgumentNullException("otherParam");

			if (IsCompatible(ctx, parentCommand, otherParam))
				Length = "1";
			else if (strong && CommandParameterStrong.IsCompatible(ctx, parentCommand, otherParam)) {
				Type = otherParam.Group;
				mIsStrong = true;
			}
		}

		/// <summary>
		/// Construct a CommandParameterPinned from the original parameter.
		/// </summary>
		/// <param name="otherParam"></param>
		/// <param name="ctx"></param>
		/// <param name="parentCommand"></param>
		public CommandParameterPinned(CommandParameter otherParam, RegistryContext ctx, Command parentCommand, bool strong)
			: base(otherParam)
		{
			if (otherParam == null)
				throw new ArgumentNullException("otherParam");

			if (IsCompatible(ctx, parentCommand, otherParam)) {
				Type = "Object";
				TypeDecorators.Clear();
				mIsPinned = true;
			} else if (strong && CommandParameterStrong.IsCompatible(ctx, parentCommand, otherParam)) {
				Type = otherParam.Group;
			}
		}

		internal static bool IsCompatible(RegistryContext ctx, Command command, CommandParameter param)
		{
			// Already "out" param?
			if (param.GetImplementationTypeModifier(ctx, command) == "out")
				return (false);

			string implementationType = param.ManagedImplementationType;

			// Type[] + IsGetImplementation -> out Type
			// Type[] + OutParam -> out Type
			// Type[] + OutParamLast -> out Type
			if ((param.IsConstant == false) && implementationType.EndsWith("[]") && (param.Length != "1") && ((command.Flags & (CommandFlags.OutParam | CommandFlags.OutParamLast)) != 0))
				return (true);

			return (false);
		}

		internal static bool IsCompatible(RegistryContext ctx, Command command, CommandParameter param)
		{
			switch (ctx.Class.ToLower()) {
				case "gl":
					break;
				default:
					return (false);
			}

			if (param.GetImplementationType(ctx, command) != "IntPtr")
				return (false);
			if (Regex.IsMatch(param.Name, "offset"))
				return (false);
			if (param.IsConstant || command.IsGetImplementation(ctx))
				return (true);

			return (false);
		}

		public string GetDelegateTypeModifier(RegistryContext ctx, Command parentCommand)
		{
			return (null);
		}

		public override void WriteUnpinCommand(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand)
		{
			if (GetImplementationType(ctx, parentCommand) == "Object")
				sw.WriteLine("{0}.Free();", PinnedLocalVarName);
		}

		public override void WritePinnedVariable(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand)
		{
			if (GetImplementationType(ctx, parentCommand) == "Object")
				sw.WriteLine("GCHandle {0} = GCHandle.Alloc({1}, GCHandleType.Pinned);", PinnedLocalVarName, ImplementationName);
		}

		public virtual void WriteUnpinCommand(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand)
		{
			// No code for common parameter
		}

		public virtual void WritePinnedVariable(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand)
		{
			// No code for common parameter
		}

		public virtual void WriteCallLogArgParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand)
		{
			WriteCallLogArgParam(sw, ImplementationName, GetImplementationType(ctx, parentCommand));
		}

		public virtual void WriteCallLogFormatParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand, int paramIndex)
		{
			string implementationType = GetImplementationType(ctx, parentCommand);
			bool safeImplementationType = !implementationType.EndsWith("*") && implementationType != "IntPtr";

			if (safeImplementationType == false)
				sw.Write("0x{{{0}}}", paramIndex);
			else
				sw.Write("{{{0}}}", paramIndex);
		}