Пример #1
0
        private bool FixPathFragmentLiteral(ILiteralLikeNode node, bool maintainCaseOfLast)
        {
            var fragments = node.Text.Split(ExpectedPathSeparator, IllegalPathSeparator);

            if (LowerCaseDirectories)
            {
                int charOffSetForError = 0;
                int nrOfFragmentsToFix = fragments.Length;
                if (maintainCaseOfLast)
                {
                    // Don't address the case of the last fragment.
                    nrOfFragmentsToFix--;
                }

                // lowercase all parts of the path when requested.
                for (int i = 0; i < nrOfFragmentsToFix; i++)
                {
                    var fragment      = fragments[i];
                    var lowerFragment = fragment.ToLowerInvariant();
                    fragments[i]        = lowerFragment;
                    charOffSetForError += fragment.Length + 1; /*1 extra for the path separator*/
                }
            }

            node.Text = string.Join(ExpectedPathSeparator.ToString(), fragments);
            return(true);
        }
Пример #2
0
        private bool AnalyzePathFragmentLiteral(ILiteralLikeNode node, bool maintainCaseOfLast, DiagnosticsContext context, Logger logger, LoggingContext loggingContext)
        {
            Contract.Requires(context != null, "context is required when analyzing and validating.");

            var illegalIndex = node.Text.IndexOf(IllegalPathSeparator);

            if (illegalIndex >= 0)
            {
                var location = node.LocationForLogging(context.SourceFile);
                location.Position += illegalIndex;

                logger.PathFixerIllegalPathSeparator(loggingContext, location, node.Text, ExpectedPathSeparator, IllegalPathSeparator);
                return(false);
            }

            if (!LowerCaseDirectories)
            {
                return(true);
            }

            var fragments = node.Text.Split(ExpectedPathSeparator, IllegalPathSeparator);

            int charOffSetForError = 0;
            int nrOfFragmentsToFix = fragments.Length;

            if (maintainCaseOfLast)
            {
                // Don't address the case of the last fragment.
                nrOfFragmentsToFix--;
            }

            // lowercase all parts of the path when requested.
            for (int i = 0; i < nrOfFragmentsToFix; i++)
            {
                var fragment      = fragments[i];
                var lowerFragment = fragment.ToLowerInvariant();

                if (!string.Equals(lowerFragment, fragment, StringComparison.Ordinal))
                {
                    // Try to find an estimate of the exact character that is a mismatch
                    var upperBound = Math.Min(lowerFragment.Length, fragment.Length);
                    for (int posInFragment = 0; posInFragment < upperBound; posInFragment++)
                    {
                        if (lowerFragment[posInFragment] != fragment[posInFragment])
                        {
                            charOffSetForError += posInFragment;
                        }
                    }

                    var location = node.LocationForLogging(context.SourceFile);
                    location.Position += charOffSetForError;

                    logger.PathFixerIllegalCasing(loggingContext, location, node.Text, fragment, lowerFragment);
                    return(false);
                }

                charOffSetForError += fragment.Length + 1; /*1 extra for the path separator*/
            }

            return(true);
        }