1 files changed, 41 insertions, 37 deletions

diff --git a/src/pki/parser.cc b/src/pki/parser.cc
index 623da92..51f2661 100644
--- a/src/pki/parser.cc
+++ b/src/pki/parser.cc
@@ -4,24 +4,20 @@
 
 #include "parser.h"
 
-#include "parse_values.h"
 #include <openssl/base.h>
+#include "parse_values.h"
 
 namespace bssl::der {
 
-Parser::Parser() {
-  CBS_init(&cbs_, nullptr, 0);
-}
+Parser::Parser() { CBS_init(&cbs_, nullptr, 0); }
 
-Parser::Parser(const Input& input) {
-  CBS_init(&cbs_, input.UnsafeData(), input.Length());
-}
+Parser::Parser(Input input) { CBS_init(&cbs_, input.data(), input.size()); }
 
-bool Parser::PeekTagAndValue(Tag* tag, Input* out) {
+bool Parser::PeekTagAndValue(CBS_ASN1_TAG *tag, Input *out) {
   CBS peeker = cbs_;
   CBS tmp_out;
   size_t header_len;
-  unsigned tag_value;
+  CBS_ASN1_TAG tag_value;
   if (!CBS_get_any_asn1_element(&peeker, &tmp_out, &tag_value, &header_len) ||
       !CBS_skip(&tmp_out, header_len)) {
     return false;
@@ -33,38 +29,39 @@ bool Parser::PeekTagAndValue(Tag* tag, Input* out) {
 }
 
 bool Parser::Advance() {
-  if (advance_len_ == 0)
+  if (advance_len_ == 0) {
     return false;
+  }
   bool ret = !!CBS_skip(&cbs_, advance_len_);
   advance_len_ = 0;
   return ret;
 }
 
-bool Parser::HasMore() {
-  return CBS_len(&cbs_) > 0;
-}
+bool Parser::HasMore() { return CBS_len(&cbs_) > 0; }
 
-bool Parser::ReadRawTLV(Input* out) {
+bool Parser::ReadRawTLV(Input *out) {
   CBS tmp_out;
-  if (!CBS_get_any_asn1_element(&cbs_, &tmp_out, nullptr, nullptr))
+  if (!CBS_get_any_asn1_element(&cbs_, &tmp_out, nullptr, nullptr)) {
     return false;
+  }
   *out = Input(CBS_data(&tmp_out), CBS_len(&tmp_out));
   return true;
 }
 
-bool Parser::ReadTagAndValue(Tag* tag, Input* out) {
-  if (!PeekTagAndValue(tag, out))
+bool Parser::ReadTagAndValue(CBS_ASN1_TAG *tag, Input *out) {
+  if (!PeekTagAndValue(tag, out)) {
     return false;
+  }
   BSSL_CHECK(Advance());
   return true;
 }
 
-bool Parser::ReadOptionalTag(Tag tag, std::optional<Input>* out) {
+bool Parser::ReadOptionalTag(CBS_ASN1_TAG tag, std::optional<Input> *out) {
   if (!HasMore()) {
     *out = std::nullopt;
     return true;
   }
-  Tag actual_tag;
+  CBS_ASN1_TAG actual_tag;
   Input value;
   if (!PeekTagAndValue(&actual_tag, &value)) {
     return false;
@@ -79,22 +76,23 @@ bool Parser::ReadOptionalTag(Tag tag, std::optional<Input>* out) {
   return true;
 }
 
-bool Parser::ReadOptionalTag(Tag tag, Input* out, bool* present) {
+bool Parser::ReadOptionalTag(CBS_ASN1_TAG tag, Input *out, bool *present) {
   std::optional<Input> tmp_out;
-  if (!ReadOptionalTag(tag, &tmp_out))
+  if (!ReadOptionalTag(tag, &tmp_out)) {
     return false;
+  }
   *present = tmp_out.has_value();
   *out = tmp_out.value_or(der::Input());
   return true;
 }
 
-bool Parser::SkipOptionalTag(Tag tag, bool* present) {
+bool Parser::SkipOptionalTag(CBS_ASN1_TAG tag, bool *present) {
   Input out;
   return ReadOptionalTag(tag, &out, present);
 }
 
-bool Parser::ReadTag(Tag tag, Input* out) {
-  Tag actual_tag;
+bool Parser::ReadTag(CBS_ASN1_TAG tag, Input *out) {
+  CBS_ASN1_TAG actual_tag;
   Input value;
   if (!PeekTagAndValue(&actual_tag, &value) || actual_tag != tag) {
     return false;
@@ -104,52 +102,58 @@ bool Parser::ReadTag(Tag tag, Input* out) {
   return true;
 }
 
-bool Parser::SkipTag(Tag tag) {
+bool Parser::SkipTag(CBS_ASN1_TAG tag) {
   Input out;
   return ReadTag(tag, &out);
 }
 
 // Type-specific variants of ReadTag
 
-bool Parser::ReadConstructed(Tag tag, Parser* out) {
-  if (!IsConstructed(tag))
+bool Parser::ReadConstructed(CBS_ASN1_TAG tag, Parser *out) {
+  if (!(tag & CBS_ASN1_CONSTRUCTED)) {
     return false;
+  }
   Input data;
-  if (!ReadTag(tag, &data))
+  if (!ReadTag(tag, &data)) {
     return false;
+  }
   *out = Parser(data);
   return true;
 }
 
-bool Parser::ReadSequence(Parser* out) {
-  return ReadConstructed(kSequence, out);
+bool Parser::ReadSequence(Parser *out) {
+  return ReadConstructed(CBS_ASN1_SEQUENCE, out);
 }
 
-bool Parser::ReadUint8(uint8_t* out) {
+bool Parser::ReadUint8(uint8_t *out) {
   Input encoded_int;
-  if (!ReadTag(kInteger, &encoded_int))
+  if (!ReadTag(CBS_ASN1_INTEGER, &encoded_int)) {
     return false;
+  }
   return ParseUint8(encoded_int, out);
 }
 
-bool Parser::ReadUint64(uint64_t* out) {
+bool Parser::ReadUint64(uint64_t *out) {
   Input encoded_int;
-  if (!ReadTag(kInteger, &encoded_int))
+  if (!ReadTag(CBS_ASN1_INTEGER, &encoded_int)) {
     return false;
+  }
   return ParseUint64(encoded_int, out);
 }
 
 std::optional<BitString> Parser::ReadBitString() {
   Input value;
-  if (!ReadTag(kBitString, &value))
+  if (!ReadTag(CBS_ASN1_BITSTRING, &value)) {
     return std::nullopt;
+  }
   return ParseBitString(value);
 }
 
-bool Parser::ReadGeneralizedTime(GeneralizedTime* out) {
+bool Parser::ReadGeneralizedTime(GeneralizedTime *out) {
   Input value;
-  if (!ReadTag(kGeneralizedTime, &value))
+  if (!ReadTag(CBS_ASN1_GENERALIZEDTIME, &value)) {
     return false;
+  }
   return ParseGeneralizedTime(value, out);
 }