FLANG
char-block.h
1//===-- include/flang/Parser/char-block.h -----------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef FORTRAN_PARSER_CHAR_BLOCK_H_
10#define FORTRAN_PARSER_CHAR_BLOCK_H_
11
12// Describes a contiguous block of characters; does not own their storage.
13
14#include "flang/Common/interval.h"
15#include <algorithm>
16#include <cstddef>
17#include <cstring>
18#include <iosfwd>
19#include <string>
20#include <utility>
21
22namespace llvm {
23class raw_ostream;
24}
25
26namespace Fortran::parser {
27
28class CharBlock {
29public:
30 constexpr CharBlock() {}
31 constexpr CharBlock(const char *x, std::size_t n = 1) : interval_{x, n} {}
32 constexpr CharBlock(const char *b, const char *ep1)
33 : interval_{b, static_cast<std::size_t>(ep1 - b)} {}
34 CharBlock(const std::string &s) : interval_{s.data(), s.size()} {}
35 constexpr CharBlock(const CharBlock &) = default;
36 constexpr CharBlock(CharBlock &&) = default;
37 constexpr CharBlock &operator=(const CharBlock &) = default;
38 constexpr CharBlock &operator=(CharBlock &&) = default;
39
40 constexpr bool empty() const { return interval_.empty(); }
41 constexpr std::size_t size() const { return interval_.size(); }
42 constexpr const char *begin() const { return interval_.start(); }
43 constexpr const char *end() const {
44 return interval_.start() + interval_.size();
45 }
46 constexpr const char &operator[](std::size_t j) const {
47 return interval_.start()[j];
48 }
49 constexpr const char &front() const { return (*this)[0]; }
50 constexpr const char &back() const { return (*this)[size() - 1]; }
51
52 bool Contains(const CharBlock &that) const {
53 return interval_.Contains(that.interval_);
54 }
55
56 void ExtendToCover(const CharBlock &that) {
57 interval_.ExtendToCover(that.interval_);
58 }
59
60 // Returns the block's first non-blank character, if it has
61 // one; otherwise ' '.
62 char FirstNonBlank() const {
63 for (char ch : *this) {
64 if (ch != ' ' && ch != '\t') {
65 return ch;
66 }
67 }
68 return ' '; // non no-blank character
69 }
70
71 // Returns the block's only non-blank character, if it has
72 // exactly one non-blank character; otherwise ' '.
73 char OnlyNonBlank() const {
74 char result{' '};
75 for (char ch : *this) {
76 if (ch != ' ' && ch != '\t') {
77 if (result == ' ') {
78 result = ch;
79 } else {
80 return ' ';
81 }
82 }
83 }
84 return result;
85 }
86
87 std::size_t CountLeadingBlanks() const {
88 std::size_t n{size()};
89 std::size_t j{0};
90 for (; j < n; ++j) {
91 char ch{(*this)[j]};
92 if (ch != ' ' && ch != '\t') {
93 break;
94 }
95 }
96 return j;
97 }
98
99 bool IsBlank() const { return FirstNonBlank() == ' '; }
100
101 std::string ToString() const {
102 return std::string{interval_.start(), interval_.size()};
103 }
104
105 // Convert to string, stopping early at any embedded '\0'.
106 std::string NULTerminatedToString() const {
107 return std::string{interval_.start(),
108 /*not in std::*/ strnlen(interval_.start(), interval_.size())};
109 }
110
111 bool operator<(const CharBlock &that) const { return Compare(that) < 0; }
112 bool operator<=(const CharBlock &that) const { return Compare(that) <= 0; }
113 bool operator==(const CharBlock &that) const { return Compare(that) == 0; }
114 bool operator!=(const CharBlock &that) const { return Compare(that) != 0; }
115 bool operator>=(const CharBlock &that) const { return Compare(that) >= 0; }
116 bool operator>(const CharBlock &that) const { return Compare(that) > 0; }
117
118 bool operator<(const char *that) const { return Compare(that) < 0; }
119 bool operator<=(const char *that) const { return Compare(that) <= 0; }
120 bool operator==(const char *that) const { return Compare(that) == 0; }
121 bool operator!=(const char *that) const { return Compare(that) != 0; }
122 bool operator>=(const char *that) const { return Compare(that) >= 0; }
123 bool operator>(const char *that) const { return Compare(that) > 0; }
124
125 friend bool operator<(const char *, const CharBlock &);
126 friend bool operator<=(const char *, const CharBlock &);
127 friend bool operator==(const char *, const CharBlock &);
128 friend bool operator!=(const char *, const CharBlock &);
129 friend bool operator>=(const char *, const CharBlock &);
130 friend bool operator>(const char *, const CharBlock &);
131
132private:
133 int Compare(const CharBlock &that) const {
134 // "memcmp" in glibc has "nonnull" attributes on the input pointers.
135 // Avoid passing null pointers, since it would result in an undefined
136 // behavior.
137 if (size() == 0) {
138 return that.size() == 0 ? 0 : -1;
139 } else if (that.size() == 0) {
140 return 1;
141 } else {
142 std::size_t bytes{std::min(size(), that.size())};
143 int cmp{std::memcmp(static_cast<const void *>(begin()),
144 static_cast<const void *>(that.begin()), bytes)};
145 if (cmp != 0) {
146 return cmp;
147 } else {
148 return size() < that.size() ? -1 : size() > that.size();
149 }
150 }
151 }
152
153 int Compare(const char *that) const {
154 std::size_t bytes{size()};
155 // strncmp is undefined if either pointer is null.
156 if (!bytes) {
157 return that == nullptr ? 0 : -1;
158 } else if (!that) {
159 return 1;
160 } else if (int cmp{std::strncmp(begin(), that, bytes)}) {
161 return cmp;
162 }
163 return that[bytes] == '\0' ? 0 : -1;
164 }
165
166 common::Interval<const char *> interval_{nullptr, 0};
167};
168
169inline bool operator<(const char *left, const CharBlock &right) {
170 return right > left;
171}
172inline bool operator<=(const char *left, const CharBlock &right) {
173 return right >= left;
174}
175inline bool operator==(const char *left, const CharBlock &right) {
176 return right == left;
177}
178inline bool operator!=(const char *left, const CharBlock &right) {
179 return right != left;
180}
181inline bool operator>=(const char *left, const CharBlock &right) {
182 return right <= left;
183}
184inline bool operator>(const char *left, const CharBlock &right) {
185 return right < left;
186}
187
188// An alternative comparator based on pointer values; use with care!
190 bool operator()(CharBlock x, CharBlock y) const {
191 return x.end() < y.begin();
192 }
193};
194
195llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const CharBlock &x);
196
197} // namespace Fortran::parser
198
199// Specializations to enable std::unordered_map<CharBlock, ...> &c.
200template <> struct std::hash<Fortran::parser::CharBlock> {
201 std::size_t operator()(const Fortran::parser::CharBlock &x) const {
202 std::size_t hash{0}, bytes{x.size()};
203 for (std::size_t j{0}; j < bytes; ++j) {
204 hash = (hash * 31) ^ x[j];
205 }
206 return hash;
207 }
208};
209#endif // FORTRAN_PARSER_CHAR_BLOCK_H_
Definition: interval.h:22
Definition: char-block.h:28
Definition: check-expression.h:19
Definition: bit-population-count.h:20