YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

// Copyright (c) YugaByte, Inc.

//

// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except

// in compliance with the License.  You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software distributed under the License

// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express

// or implied.  See the License for the specific language governing permissions and limitations

// under the License.

//

#include "yb/util/split.h"

#include "yb/util/status.h"

using std::string;

namespace yb {

namespace util {

using yb::Status;

using yb::Slice;

template<class Out>

Status SplitArgsImpl(const Slice& line, Out* out_vector) {

  out_vector->clear();

  // Points to the current position we are looking at.

  const char* current_position = line.cdata();

  // Points to the end.

  const char* ptr_end = line.cend();

  while (current_position != ptr_end) {

    // Skip blanks.

    while (current_position != ptr_end && 
isspace(*current_position)34
) {

      current_position++;

    }

    if (current_position != ptr_end) {

      const char* current_token = current_position;

      int current_token_length = 0;

      // Get a token.

      if (*current_position == '"' || 
*current_position == '\''13
) {

        const char quotation = *current_position;

        current_token++;  // Skip the begining quote.

        current_position++;

        while (true) {

          if (current_position == ptr_end) {

            // Unterminated quotes.

            out_vector->clear();

            return STATUS(Corruption, "Unterminated quotes.");

          }

          if (quotation == *current_position) {

            // Reached the end of the quoted token.

            //

            // Closing quote must be followed by a space or nothing at all.

            current_position++;

            if (current_position != ptr_end && 
!isspace(*current_position)2
) {

              out_vector->clear();

              return STATUS(Corruption, "A closing quote must be followed by a white space "

                  "or end of input");

            }

            break;

          }

          current_token_length++;

          current_position++;

        }

      } else {

        // Token is not begining with quotes. Process until the next space character.

        while (current_position != ptr_end && 
!isspace(*current_position)47
) {

          if (*current_position == '"' || 
*current_position == '\''37
) {

            out_vector->clear();

            return STATUS(Corruption, "A closing quote must be followed by a white space "

                "or end of input");

          }

          current_token_length++;

          current_position++;

        }

      }

      // Save the token. Get ready for the next one.

      out_vector->emplace_back(current_token, current_token_length);

    }

  }

  return Status::OK();

}

yb::Status yb::util::SplitArgsImpl<std::__1::vector<yb::Slice, std::__1::allocator<yb::Slice> > >(yb::Slice const&, std::__1::vector<yb::Slice, std::__1::allocator<yb::Slice> >*)

Line

Count

Source

27

8

Status SplitArgsImpl(const Slice& line, Out* out_vector) {

28

8

  out_vector->clear();

29

30

  // Points to the current position we are looking at.

31

8

  const char* current_position = line.cdata();

32

  // Points to the end.

33

8

  const char* ptr_end = line.cend();

34

35

21

  while (current_position != ptr_end) {

36

    // Skip blanks.

37

35

    while (current_position != ptr_end && 
isspace(*current_position)34
) {

38

18

      current_position++;

39

18

    }

40

41

17

    if (current_position != ptr_end) {

42

16

      const char* current_token = current_position;

43

16

      int current_token_length = 0;

44

      // Get a token.

45

16

      if (*current_position == '"' || 
*current_position == '\''13
) {

46

5

        const char quotation = *current_position;

47

5

        current_token++;  // Skip the begining quote.

48

5

        current_position++;

49

42

        while (true) {

50

42

          if (current_position == ptr_end) {

51

            // Unterminated quotes.

52

2

            out_vector->clear();

53

2

            return STATUS(Corruption, "Unterminated quotes.");

54

2

          }

55

56

40

          if (quotation == *current_position) {

57

            // Reached the end of the quoted token.

58

            //

59

            // Closing quote must be followed by a space or nothing at all.

60

3

            current_position++;

61

3

            if (current_position != ptr_end && 
!isspace(*current_position)2
) {

62

1

              out_vector->clear();

63

1

              return STATUS(Corruption, "A closing quote must be followed by a white space "

64

1

                  "or end of input");

65

1

            }

66

2

            break;

67

3

          }

68

37

          current_token_length++;

69

37

          current_position++;

70

37

        }

71

11

      } else {

72

        // Token is not begining with quotes. Process until the next space character.

73

48

        while (current_position != ptr_end && 
!isspace(*current_position)47
) {

74

38

          if (*current_position == '"' || 
*current_position == '\''37
) {

75

1

            out_vector->clear();

76

1

            return STATUS(Corruption, "A closing quote must be followed by a white space "

77

1

                "or end of input");

78

1

          }

79

37

          current_token_length++;

80

37

          current_position++;

81

37

        }

82

11

      }

83

      // Save the token. Get ready for the next one.

84

12

      out_vector->emplace_back(current_token, current_token_length);

85

12

    }

86

17

  }

87

4

  return Status::OK();

88

8

}

Unexecuted instantiation: yb::Status yb::util::SplitArgsImpl<boost::container::small_vector_base<yb::Slice, void, void> >(yb::Slice const&, boost::container::small_vector_base<yb::Slice, void, void>*)

Status SplitArgs(const Slice& line, std::vector<Slice>* out_vector) {

  return SplitArgsImpl(line, out_vector);

}

Status SplitArgs(const Slice& line, boost::container::small_vector_base<Slice>* out_vector) {

  return SplitArgsImpl(line, out_vector);

}

}  // namespace util

}  // namespace yb