[nfc][flang] Eliminate the dependency on cctype by using characters.h

flang/include/flang/Parser/characters.h

 inline constexpr bool IsLegalIdentifierStart(char ch) {
   return IsLetter(ch) || ch == '_' || ch == '@' || ch == '$';
 }
 
 inline constexpr bool IsLegalInIdentifier(char ch) {
   return IsLegalIdentifierStart(ch) || IsDecimalDigit(ch);
 }
 
+inline constexpr bool IsPrintable(char ch) { return ch >= ' ' && ch <= '~'; }
+
+inline constexpr bool IsWhiteSpace(char ch) {
+  return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\v' || ch == '\f' ||
+      ch == '\r';
+}
+
 inline constexpr char ToLowerCaseLetter(char ch) {
   return IsUpperCaseLetter(ch) ? ch - 'A' + 'a' : ch;
 }
 
 inline constexpr char ToLowerCaseLetter(char &&ch) {
   return IsUpperCaseLetter(ch) ? ch - 'A' + 'a' : ch;
 }
 

flang/lib/Parser/token-parsers.h

 
 #include "basic-parsers.h"
 #include "type-parsers.h"
 #include "flang/Common/idioms.h"
 #include "flang/Parser/char-set.h"
 #include "flang/Parser/characters.h"
 #include "flang/Parser/instrumented-parser.h"
 #include "flang/Parser/provenance.h"
-#include <cctype>
 #include <cstddef>
 #include <cstring>
 #include <functional>
 #include <limits>
 #include <list>
 #include <optional>
 #include <string>
 
static std::optional<std::string> Parse(ParseState &state) {
     if (!h) {
       return std::nullopt;
     }
     std::string content;
     for (auto j{*charCount}; j-- > 0;) {
       int chBytes{UTF_8CharacterBytes(state.GetLocation())};
       for (int bytes{chBytes}; bytes > 0; --bytes) {
         if (std::optional<const char *> at{nextCh.Parse(state)}) {
-          if (chBytes == 1 && !std::isprint(**at)) {
+          if (chBytes == 1 && !IsPrintable(**at)) {
             state.Say(start, "Bad character in Hollerith"_err_en_US);
             return std::nullopt;
           }
           content += **at;
         } else {
           state.Say(start, "Insufficient characters in Hollerith"_err_en_US);
           return std::nullopt;
         }

flang/lib/Semantics/resolve-labels.cpp

 //===-- lib/Semantics/resolve-labels.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "resolve-labels.h"
 #include "flang/Common/enum-set.h"
 #include "flang/Common/template.h"
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Semantics/semantics.h"
-#include <cctype>
 #include <cstdarg>
 #include <type_traits>
 
 namespace Fortran::semantics {
 
 using namespace parser::literals;
 
 ENUM_CLASS(

 }
 
 parser::CharBlock SkipLabel(const parser::CharBlock &position) {
   const std::size_t maxPosition{position.size()};
   if (maxPosition && parser::IsDecimalDigit(position[0])) {
     std::size_t i{1l};
     for (; (i < maxPosition) && parser::IsDecimalDigit(position[i]); ++i) {
     }
-    for (; (i < maxPosition) && std::isspace(position[i]); ++i) {
+    for (; (i < maxPosition) && parser::IsWhiteSpace(position[i]); ++i) {
     }
     return parser::CharBlock{position.begin() + i, position.end()};
   }
   return position;
 }
 
 ProxyForScope ParentScope(
     const std::vector<ScopeInfo> &scopes, ProxyForScope scope) {