From 4be8d80eea82640e20d678f77c08d03a96afb8b6 Mon Sep 17 00:00:00 2001 From: Henri Chataing Date: Wed, 6 May 2026 10:19:37 +0200 Subject: [PATCH] Cxx backend cleanup and improvements --- pdl-compiler/src/backends/cxx.rs | 926 ++++++----- pdl-compiler/tests/generated/cxx/le_backend.h | 1448 +++++++++++++---- 2 files changed, 1630 insertions(+), 744 deletions(-) diff --git a/pdl-compiler/src/backends/cxx.rs b/pdl-compiler/src/backends/cxx.rs index 916f368..393a2a3 100644 --- a/pdl-compiler/src/backends/cxx.rs +++ b/pdl-compiler/src/backends/cxx.rs @@ -1,4 +1,4 @@ -// Copyright 2023 Google LLC +// Copyright (C) 2026 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -26,10 +26,6 @@ fn indent(s: &str, level: usize) -> String { .join("\n") } -fn to_pascal_case(s: &str) -> String { - s.to_upper_camel_case() -} - fn mask(width: usize) -> String { format!("{:#x}", (1u128 << width) - 1) } @@ -63,19 +59,25 @@ pub fn generate( let scope = analyzer::Scope::new(file).unwrap(); let schema = analyzer::Schema::new(file); - code.push_str(&format!("// File generated from {}, with the command:\n", source.name())); - code.push_str("// pdlc ...\n"); - code.push_str("// /!\\ Do not edit by hand\n\n"); + code.push_str(&format!( + r#"// File generated from {source_name}, with the command +// pdlc --output-format cxx {source_name} +// /!\ Do not edit by hand + +#pragma once - code.push_str("#pragma once\n\n"); - code.push_str("#include \n"); - code.push_str("#include \n"); - code.push_str("#include \n"); - code.push_str("#include \n"); - code.push_str("#include \n"); - code.push_str("#include \n"); - code.push_str("#include \n\n"); - code.push_str("#include \n\n"); +#include +#include +#include +#include +#include +#include +#include + +#include +"#, + source_name = source.name() + )); for header in include_headers { code.push_str(&format!("#include <{}>\n", header)); @@ -91,14 +93,19 @@ pub fn generate( code.push('\n'); } - code.push_str("#ifndef _ASSERT_VALID\n"); - code.push_str("#ifdef ASSERT\n"); - code.push_str("#define _ASSERT_VALID ASSERT\n"); - code.push_str("#else\n"); - code.push_str("#include \n"); - code.push_str("#define _ASSERT_VALID assert\n"); - code.push_str("#endif // ASSERT\n"); - code.push_str("#endif // !_ASSERT_VALID\n\n"); + code.push_str( + r#" +#ifndef _ASSERT_VALID +#ifdef ASSERT +#define _ASSERT_VALID ASSERT +#else +#include +#define _ASSERT_VALID assert +#endif // ASSERT +#endif // !_ASSERT_VALID + +"#, + ); if let Some(ns) = namespace { code.push_str(&format!("namespace {} {{\n", ns)); @@ -127,7 +134,7 @@ pub fn generate( ast::DeclDesc::Enum { id, tags, width } => { code.push_str(&generate_enum_declaration(id, tags, *width)); code.push_str(&generate_enum_to_text(id, tags)); - code.push_str(&generate_enum_is_valid(id, tags)); + code.push_str(&generate_enum_is_valid(id, tags, *width)); } ast::DeclDesc::Packet { .. } => { code.push_str(&generate_packet_view(&scope, &schema, decl)); @@ -151,36 +158,26 @@ fn generate_enum_declaration(id: &str, tags: &[ast::Tag], width: usize) -> Strin let enum_type = get_cxx_scalar_type(width); let mut tag_decls = Vec::new(); for tag in tags { - match tag { - ast::Tag::Value(t) => { - tag_decls.push(format!("{} = {:#x},", t.id, t.value)); - } - ast::Tag::Range(t) => { - for subtag in &t.tags { - tag_decls.push(format!("{} = {:#x},", subtag.id, subtag.value)); - } - } - _ => {} + if let ast::Tag::Value(t) = tag { + tag_decls.push(format!("{} = {:#x},", t.id, t.value)); } } - format!("\nenum class {} : {} {{\n{}\n}};\n", id, enum_type, indent(&tag_decls.join("\n"), 1)) + format!( + r#" +enum class {id} : {enum_type} {{ +{tag_declarations} +}}; +"#, + tag_declarations = indent(&tag_decls.join("\n"), 1) + ) } fn generate_enum_to_text(id: &str, tags: &[ast::Tag]) -> String { let mut tag_cases = Vec::new(); for tag in tags { - match tag { - ast::Tag::Value(t) => { - tag_cases.push(format!("case {}::{}: return \"{}\";", id, t.id, t.id)); - } - ast::Tag::Range(t) => { - for subtag in &t.tags { - tag_cases - .push(format!("case {}::{}: return \"{}\";", id, subtag.id, subtag.id)); - } - } - _ => {} + if let ast::Tag::Value(t) = tag { + tag_cases.push(format!("case {}::{}: return \"{}\";", id, t.id, t.id)); } } @@ -195,45 +192,63 @@ inline std::string {id}Text({id} tag) {{ }} }} "#, - id = id, tag_cases = indent(&tag_cases.join("\n"), 2) ) } -fn generate_enum_is_valid(id: &str, tags: &[ast::Tag]) -> String { - let mut check_exprs = Vec::new(); - let mut has_other = false; - for tag in tags { - match tag { - ast::Tag::Value(t) => { - check_exprs.push(format!("tag == {}::{}", id, t.id)); - } - ast::Tag::Range(t) => { - check_exprs.push(format!( - "(static_cast(tag) >= {:#x} && static_cast(tag) <= {:#x})", - t.range.start(), - t.range.end() - )); - } - ast::Tag::Other(_) => { - has_other = true; - } - } +/// Generate the validation function for enum values. +fn generate_enum_is_valid(id: &str, tags: &[ast::Tag], width: usize) -> String { + let is_open = tags.iter().any(|t| matches!(t, ast::Tag::Other(_))); + if is_open { + return String::new(); } - if has_other || check_exprs.is_empty() { - return format!("\ninline bool Is{id}Valid({id} /* tag */) {{ return true; }}\n", id = id); - } + let backing_type = get_cxx_scalar_type(width); + let has_ranges = tags.iter().any(|t| matches!(t, ast::Tag::Range(_))); - format!( - r#" -inline bool Is{id}Valid({id} tag) {{ - return {check_exprs}; + if has_ranges { + let condition = tags + .iter() + .map(|tag| match tag { + ast::Tag::Value(t) => format!("value == {:#x}", t.value), + ast::Tag::Range(t) => { + format!("({:#x} <= value && value <= {:#x})", t.range.start(), t.range.end()) + } + _ => unreachable!(), + }) + .collect::>() + .join("\n || "); + + format!( + r#" +inline bool IsValid{id}({backing_type} value) {{ + return {condition}; }} "#, - id = id, - check_exprs = check_exprs.join(" || ") - ) + ) + } else { + let tag_cases = tags + .iter() + .map(|tag| match tag { + ast::Tag::Value(t) => format!("case {:#x}:", t.value), + _ => unreachable!(), + }) + .collect::>() + .join("\n "); + + format!( + r#" +inline bool IsValid{id}({backing_type} value) {{ + switch (value) {{ + {tag_cases} + return true; + default: + return false; + }} +}} +"#, + ) + } } fn get_unconstrained_parent_fields<'a>( @@ -431,17 +446,31 @@ impl<'a> FieldParser<'a> { } ast::FieldDesc::Typedef { id, type_id, .. } => { let type_decl = self.scope.typedef.get(type_id).unwrap(); - if matches!(type_decl.desc, ast::DeclDesc::Enum { .. }) { - self.unchecked_append(format!( - "{}{}_ = static_cast<{}>( {} );", - self.target_prefix, id, type_id, v - )); - self.unchecked_append(format!( - "if (!Is{}Valid({}{}_)) return false;", - type_id, self.target_prefix, id - )); - } else { - self.unchecked_append(format!("{}{}_ = {};", self.target_prefix, id, v)); + match &type_decl.desc { + ast::DeclDesc::Enum { tags, .. } + if tags.iter().any(|t| matches!(t, ast::Tag::Other(_))) => + { + self.unchecked_append(format!( + "{}{}_ = {}({});", + self.target_prefix, id, type_id, v + )); + } + ast::DeclDesc::Enum { .. } => { + self.unchecked_append(format!("auto raw_value = {v};")); + self.unchecked_append(format!("if (!IsValid{type_id}(raw_value)) {{")); + self.unchecked_append(" return false;".to_string()); + self.unchecked_append("}".to_string()); + self.unchecked_append(format!( + "{}{}_ = {}(raw_value);", + self.target_prefix, id, type_id + )); + } + _ => { + self.unchecked_append(format!( + "{}{}_ = {};", + self.target_prefix, id, v + )); + } } } ast::FieldDesc::Size { field_id, .. } => { @@ -488,31 +517,8 @@ impl<'a> FieldParser<'a> { if self.shift != 0 { panic!("Typedef field does not start on an octet boundary"); } - self.check_code(); - let type_decl = self.scope.typedef.get(type_id).unwrap(); - if let ast::DeclDesc::Enum { width, .. } = &type_decl.desc { - let ty = get_cxx_scalar_type(*width); - let byteorder = match self.endianness { - ast::EndiannessValue::LittleEndian => "le", - ast::EndiannessValue::BigEndian => "be", - }; - self.append(format!("if (span.size() < {}) return false;", width / 8)); - self.append(format!( - "{}{}_ = static_cast<{}>(span.read_{}<{}, {}>());", - self.target_prefix, - id, - type_id, - byteorder, - ty, - width / 8 - )); - self.append(format!( - "if (!Is{}Valid({}{}_)) return false;", - type_id, self.target_prefix, id - )); - return; - } + self.check_code(); let field_size = self.schema.field_size(field.key); if let analyzer::Size::Unknown = field_size { @@ -520,25 +526,22 @@ impl<'a> FieldParser<'a> { if trailing_size > 0 { self.append(format!("if (span.size() < {}) return false;", trailing_size / 8)); let size = format!("span.size() - {}", trailing_size / 8); + self.append(format!("pdl::packet::slice {id}_span = span.subrange(0, {size});",)); self.append(format!( - "pdl::packet::slice {0}_span = span.subrange(0, {1});", - id, size + "if (!{type_id}::Parse({id}_span, &{}{id}_)) return false;", + self.target_prefix )); - self.append(format!( - "if (!{0}::Parse({1}_span, &{2}{1}_)) return false;", - type_id, id, self.target_prefix - )); - self.append(format!("span.skip({0}_span.size());", id)); + self.append(format!("span.skip({id}_span.size());")); } else { self.append(format!( - "if (!{}::Parse(span, &{}{}_)) return false;", - type_id, self.target_prefix, id + "if (!{type_id}::Parse(span, &{}{id}_)) return false;", + self.target_prefix )); } } else { self.append(format!( - "if (!{}::Parse(span, &{}{}_)) return false;", - type_id, self.target_prefix, id + "if (!{type_id}::Parse(span, &{}{id}_)) return false;", + self.target_prefix, )); } } @@ -569,22 +572,34 @@ impl<'a> FieldParser<'a> { ast::FieldDesc::Typedef { id, type_id, .. } => { let type_decl = self.scope.typedef.get(type_id).unwrap(); let cond_value = cond.value.unwrap(); - if let ast::DeclDesc::Enum { width, .. } = &type_decl.desc { + if let ast::DeclDesc::Enum { width, tags, .. } = &type_decl.desc { let backing_type = get_cxx_scalar_type(*width); + let is_open = tags.iter().any(|t| matches!(t, ast::Tag::Other(_))); let size = width / 8; self.append(format!("if ({} == {}) {{", cond.id, cond_value)); self.append(format!(" if (span.size() < {}) {{", size)); self.append(" return false;".to_string()); self.append(" }".to_string()); - self.append(format!( - " {}{}_ = static_cast<{}>(span.read_{}<{}, {}>());", - self.target_prefix, id, type_id, byteorder, backing_type, size - )); - self.append(format!( - " if (!Is{}Valid({}{}_.value())) return false;", - type_id, self.target_prefix, id - )); - self.append("}".to_string()); + if is_open { + self.append(format!( + " {}{}_ = {}(span.read_{}<{}, {}>());", + self.target_prefix, id, type_id, byteorder, backing_type, size + )); + self.append("}".to_string()); + } else { + self.append(format!( + " auto raw_value = span.read_{}<{}, {}>();", + byteorder, backing_type, size + )); + self.append(format!(" if (!IsValid{type_id}(raw_value)) {{")); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + self.append(format!( + " {}{}_ = {}(raw_value);", + self.target_prefix, id, type_id + )); + self.append("}".to_string()); + } } else { self.append(format!("if ({} == {}) {{", cond.id, cond_value)); self.append(format!( @@ -605,104 +620,121 @@ impl<'a> FieldParser<'a> { &mut self, field: &'a ast::Field, id: &str, - _type_id: Option<&str>, - _width: Option, - _size: Option, + type_id: Option<&str>, + size_modifier: Option<&str>, ) { self.check_code(); - match self.schema.field_size(field.key) { - analyzer::Size::Static(bits) => { - let size = bits / 8; - self.check_size(&size.to_string()); - self.append(format!("{}{}_ = span.subrange(0, {});", self.target_prefix, id, size)); - self.append(format!("span.skip({});", size)); + + let element_size = analyzer::element_size(self.scope, self.schema, self.decl, field); + let array_size = analyzer::array_size(self.decl, field); + + // Apply the size modifier. + if let Some(size_modifier) = size_modifier { + self.append(format!("{id}_size_ = {id}_size_ - {size_modifier};")); + } + + // TODO element validation + use analyzer::{ArraySize, ElementSize}; + match (element_size, array_size) { + (ElementSize::Static(element_size), ArraySize::StaticCount(count)) => { + let total_size = element_size * count; + self.check_size(&format!("{total_size}")); + self.append(format!("{id}_ = span.subrange(0, {total_size});")); + self.append(format!("span.skip({total_size});")); } - _ => { - let mut size_expr = "".to_string(); - let mut count_expr = "".to_string(); - - for f in self.decl.fields() { - match &f.desc { - ast::FieldDesc::Size { field_id, .. } if field_id == id => { - let field_name = if field_id == "_payload_" || field_id == "_body_" { - "payload" - } else { - field_id - }; - size_expr = format!("{}{}_size_", self.target_prefix, field_name); - } - ast::FieldDesc::Count { field_id, .. } if field_id == id => { - count_expr = format!("{}{}_count_", self.target_prefix, field_id); - } - _ => {} - } - } - if !size_expr.is_empty() { - let inverted_modifier = match &field.desc { - ast::FieldDesc::Array { size_modifier: Some(m), .. } => { - if let Some(stripped) = m.strip_prefix('+') { - format!("- {}", stripped) - } else if let Some(stripped) = m.strip_prefix('-') { - format!("+ {}", stripped) - } else { - m.clone() - } - } - _ => String::new(), - }; - let actual_size = if inverted_modifier.is_empty() { - size_expr - } else { - format!("({} {})", size_expr, inverted_modifier) - }; - self.append(format!("if (span.size() < {}) return false;", actual_size)); - if let ast::FieldDesc::Array { width: Some(w), .. } = &field.desc { - if w % 8 == 0 { - self.append(format!( - "if (({} % {}) != 0) return false;", - actual_size, - w / 8 - )); - } - } - self.append(format!( - "{}{}_ = span.subrange(0, {});", - self.target_prefix, id, actual_size - )); - self.append(format!("span.skip({});", actual_size)); - } else if !count_expr.is_empty() { - if let ast::FieldDesc::Array { width: Some(w), .. } = &field.desc { - let total_size = format!("{} * {}", count_expr, w / 8); - self.append(format!("if (span.size() < {}) return false;", total_size)); - self.append(format!( - "{}{}_ = span.subrange(0, {});", - self.target_prefix, id, total_size - )); - self.append(format!("span.skip({});", total_size)); - } else { - // Full parse needed - self.append(format!("{}{}_ = span;", self.target_prefix, id)); - self.append("span.clear();".to_string()); - } - } else { - let trailing_size = self.get_trailing_size(field); - if trailing_size > 0 { - self.append(format!( - "if (span.size() < {}) return false;", - trailing_size / 8 - )); - let size = format!("span.size() - {}", trailing_size / 8); - self.append(format!( - "{}{}_ = span.subrange(0, {});", - self.target_prefix, id, size - )); - self.append(format!("span.skip({});", size)); - } else { - self.append(format!("{}{}_ = span;", self.target_prefix, id)); - self.append("span.clear();".to_string()); - } - } + (ElementSize::Static(element_size), ArraySize::DynamicCount) => { + self.check_size(&format!("{element_size} * {id}_count_")); + self.append(format!("{id}_ = span.subrange(0, {element_size} * {id}_count_);")); + self.append(format!("span.skip({element_size} * {id}_count_);")); + } + + (ElementSize::Static(element_size), ArraySize::DynamicSize) => { + self.check_size(&format!("{id}_size_")); + self.append(format!("if (({id}_size_ % {element_size}) != 0) {{")); + self.append(" return false;".to_string()); + self.append("}".to_string()); + self.append(format!("{id}_ = span.subrange(0, {id}_size_);")); + self.append(format!("span.skip({id}_size_);")); + } + + (ElementSize::Static(element_size), ArraySize::Unknown) => { + self.append(format!("if ((span.size() % {element_size}) != 0) {{")); + self.append(" return false;".to_string()); + self.append("}".to_string()); + self.append(format!("{id}_ = span;")); + self.append("span.clear();".to_string()); + } + + (ElementSize::Dynamic, ArraySize::StaticCount(count)) => { + self.check_size(&format!("{id}_element_size_ * {count}")); + self.append(format!("{id}_ = span.subrange(0, {id}_element_size_ * {count});")); + self.append(format!("span.skip({id}_element_size_ * {count});")); + } + + (ElementSize::Dynamic, ArraySize::DynamicCount) => { + self.check_size(&format!("{id}_element_size_ * {id}_count_")); + self.append(format!("{id}_ = span.subrange(0, {id}_element_size_ * {id}_count_);")); + self.append(format!("span.skip({id}_element_size_ * {id}_count_);")); + } + + (ElementSize::Dynamic, ArraySize::DynamicSize) => { + self.check_size(&format!("{id}_size_")); + self.append(format!("if (({id}_size_ % {id}_element_size_) != 0) {{")); + self.append(" return false;".to_string()); + self.append("}".to_string()); + self.append(format!("{id}_ = span.subrange(0, {id}_size_);")); + self.append(format!("span.skip({id}_size_);")); + } + + (ElementSize::Dynamic, ArraySize::Unknown) => { + self.append(format!("if ((span.size() % {id}_element_size_) != 0) {{")); + self.append(" return false;".to_string()); + self.append("}".to_string()); + self.append(format!("{id}_ = span;")); + self.append("span.clear();".to_string()); + } + + (ElementSize::Unknown, ArraySize::StaticCount(count)) => { + let tid = type_id.unwrap(); + self.append(format!("{id}_ = span;")); + self.append(format!("for (size_t n = 0; n < {count}; n++) {{")); + self.append(format!(" {tid} out;")); + self.append(format!(" if (!{tid}::Parse(span, &out)) {{")); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + self.append("}".to_string()); + self.append(format!("{id}_ = {id}_.subrange(0, {id}_.size() - span.size());")); + } + + (ElementSize::Unknown, ArraySize::DynamicCount) => { + let tid = type_id.unwrap(); + self.append(format!("{id}_ = span;")); + self.append(format!("for (size_t n = 0; n < {id}_count_; n++) {{")); + self.append(format!(" {tid} out;")); + self.append(format!(" if (!{tid}::Parse(span, &out)) {{")); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + self.append("}".to_string()); + self.append(format!("{id}_ = {id}_.subrange(0, {id}_.size() - span.size());")); + } + + (ElementSize::Unknown, ArraySize::DynamicSize) => { + self.check_size(&format!("{id}_size_")); + self.append(format!("{id}_ = span.subrange(0, {id}_size_);")); + self.append(format!("span.skip({id}_size_);")); + } + + (ElementSize::Unknown, ArraySize::Unknown) => { + let tid = type_id.unwrap(); + self.append(format!("{id}_ = span;")); + self.append("while (span.size() > 0) {".to_string()); + self.append(format!(" {tid} out;")); + self.append(format!(" if (!{tid}::Parse(span, &out)) {{")); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + self.append("}".to_string()); + self.append(format!("{id}_ = {id}_.subrange(0, {id}_.size() - span.size());")); } } } @@ -784,161 +816,197 @@ impl<'a> FieldParser<'a> { fn parse_array_field_full( &mut self, - _field: &'a ast::Field, + field: &'a ast::Field, id: &str, type_id: Option<&str>, - width: Option, - size: Option, + size_modifier: Option<&str>, ) { self.check_code(); - let byteorder = match self.endianness { - ast::EndiannessValue::LittleEndian => "le", - ast::EndiannessValue::BigEndian => "be", - }; - if let Some(s) = size { - self.append(format!("for (int n = 0; n < {}; n++) {{", s)); - if let Some(tid) = type_id { - let td = self.scope.typedef.get(tid).unwrap(); - match &td.desc { - ast::DeclDesc::Enum { width, .. } => { - let backing_type = get_cxx_scalar_type(*width); - self.append(format!(" if (span.size() < {}) return false;", width / 8)); - self.append(format!( - " {0}{1}_[n] = {2}(span.read_{3}<{4}, {5}>());", - self.target_prefix, - id, - tid, - byteorder, - backing_type, - width / 8 - )); - } - _ => { - self.append(format!( - " if (!{}::Parse(span, &{}{}_[n])) return false;", - tid, self.target_prefix, id - )); - } - } - } else { - let element_width = width.unwrap(); - let backing_type = get_cxx_scalar_type(element_width); - self.append(format!(" if (span.size() < {}) return false;", element_width / 8)); - self.append(format!( - " {0}{1}_[n] = span.read_{2}<{3}, {4}>();", - self.target_prefix, - id, - byteorder, - backing_type, - element_width / 8 - )); + let element_size = analyzer::element_size(self.scope, self.schema, self.decl, field); + let array_size = analyzer::array_size(self.decl, field); + + // Apply the size modifier. + if let Some(size_modifier) = size_modifier { + self.append(format!("output->{id}_size_ = output->{id}_size_ - {size_modifier};")); + } + + use analyzer::{ArraySize, ElementSize}; + match (element_size, array_size) { + (ElementSize::Static(element_size), ArraySize::StaticCount(count)) => { + let total_size = element_size * count; + self.check_size(&format!("{total_size}")); + self.append(format!("for (size_t n = 0; n < {count}; n++) {{")); + let out = self.parse_array_element(field, "span".to_string()); + self.append(format!(" output->{id}_[n] = {out};")); + self.append("}".to_string()); } - self.append("}".to_string()); - } else { - let mut count_expr = "".to_string(); - let mut size_expr = "".to_string(); - for f in self.decl.fields() { - match &f.desc { - ast::FieldDesc::Size { field_id, .. } if field_id == id => { - let field_name = if field_id == "_payload_" || field_id == "_body_" { - "payload" - } else { - field_id - }; - size_expr = format!("{}{}_size_", self.target_prefix, field_name); - } - ast::FieldDesc::Count { field_id, .. } if field_id == id => { - count_expr = format!("{}{}_count_", self.target_prefix, field_id); - } - _ => {} - } + + (ElementSize::Static(element_size), ArraySize::DynamicCount) => { + self.check_size(&format!("{element_size} * output->{id}_count_")); + self.append(format!("for (size_t n = 0; n < output->{id}_count_; n++) {{")); + let out = self.parse_array_element(field, "span".to_string()); + self.append(format!(" output->{id}_.push_back({out});")); + self.append("}".to_string()); } - if !count_expr.is_empty() { - self.append(format!("for (size_t n = 0; n < {}; n++) {{", count_expr)); - } else if !size_expr.is_empty() { - let inverted_modifier = match &_field.desc { - ast::FieldDesc::Array { size_modifier: Some(m), .. } => { - if let Some(stripped) = m.strip_prefix('+') { - format!("- {}", stripped) - } else if let Some(stripped) = m.strip_prefix('-') { - format!("+ {}", stripped) - } else { - m.clone() - } - } - _ => String::new(), - }; - let actual_size = if inverted_modifier.is_empty() { - size_expr - } else { - format!("({} {})", size_expr, inverted_modifier) - }; - self.append(format!("if (span.size() < {}) return false;", actual_size)); + (ElementSize::Static(element_size), ArraySize::DynamicSize) => { + self.check_size(&format!("output->{id}_size_")); + self.append(format!("if ((output->{id}_size_ % {element_size}) != 0) {{")); + self.append(" return false;".to_string()); + self.append("}".to_string()); + self.append(format!("auto {id}_count_ = output->{id}_size_ / {element_size};")); + self.append(format!("for (size_t n = 0; n < {id}_count_; n++) {{")); + let out = self.parse_array_element(field, "span".to_string()); + self.append(format!(" output->{id}_.push_back({out});")); + self.append("}".to_string()); + } - if let Some(w) = width { - self.append(format!("if (({} % {}) != 0) return false;", actual_size, w / 8)); - } else if let Some(tid) = type_id { - let decl = self.scope.typedef.get(tid).unwrap(); - let element_size = self.schema.decl_size(decl.key); - if let analyzer::Size::Static(bits) = element_size { - self.append(format!( - "if (({} % {}) != 0) return false;", - actual_size, - bits / 8 - )); - } - } + (ElementSize::Static(element_size), ArraySize::Unknown) => { + self.append(format!("if ((span.size() % {element_size}) != 0) {{")); + self.append(" return false;".to_string()); + self.append("}".to_string()); + self.append(format!("auto {id}_count_ = span.size() / {element_size};")); + self.append(format!("for (size_t n = 0; n < {id}_count_; n++) {{")); + let out = self.parse_array_element(field, "span".to_string()); + self.append(format!(" output->{id}_.push_back({out});")); + self.append("}".to_string()); + } - self.append(format!("size_t limit = span.size() - {};", actual_size)); - self.append("while (span.size() > limit) {".to_string()); - } else { + (ElementSize::Dynamic, ArraySize::StaticCount(count)) => { + self.check_size(&format!("output->{id}_element_size_ * {count}")); + self.append(format!("for (size_t n = 0; n < {count}; n++) {{")); + self.append(format!(" auto element_span = span.subrange(n * output->{id}_element_size_, output->{id}_element_size_);")); + let out = self.parse_array_element(field, "element_span".to_string()); + self.append(format!(" output->{id}_[n] = {out};")); + self.append("}".to_string()); + self.append(format!("span.skip(output->{id}_element_size_ * {count});")); + } + + (ElementSize::Dynamic, ArraySize::DynamicCount) => { + self.check_size(&format!("output->{id}_element_size_ * output->{id}_count_")); + self.append(format!("for (size_t n = 0; n < output->{id}_count_; n++) {{")); + self.append(format!(" auto element_span = span.subrange(n * output->{id}_element_size_, output->{id}_element_size_);")); + let out = self.parse_array_element(field, "element_span".to_string()); + self.append(format!(" output->{id}_[n] = {out};")); + self.append("}".to_string()); + self.append(format!("span.skip(output->{id}_element_size_ * output->{id}_count_);")); + } + + (ElementSize::Dynamic, ArraySize::DynamicSize) => { + self.check_size(&format!("output->{id}_size_")); + self.append(format!("if ((output->{id}_size_ % output->{id}_element_size_) != 0) {{")); + self.append(" return false;".to_string()); + self.append("}".to_string()); + self.append(format!("auto {id}_count_ = output->{id}_size_ / output->{id}_element_size_;")); + self.append(format!("for (size_t n = 0; n < {id}_count_; n++) {{")); + self.append(format!(" auto element_span = span.subrange(n * output->{id}_element_size_, output->{id}_element_size_);")); + let out = self.parse_array_element(field, "element_span".to_string()); + self.append(format!(" output->{id}_[n] = {out};")); + self.append("}".to_string()); + self.append(format!("span.skip(output->{id}_size_);")); + } + + (ElementSize::Dynamic, ArraySize::Unknown) => { + self.append(format!("if ((span.size() % output->{id}_element_size_) != 0) {{")); + self.append(" return false;".to_string()); + self.append("}".to_string()); + self.append(format!("auto {id}_count_ = span.size() / output->{id}_element_size_;")); + self.append(format!("for (size_t n = 0; n < {id}_count_; n++) {{")); + self.append(format!(" auto element_span = span.subrange(n * output->{id}_element_size_, output->{id}_element_size_);")); + let out = self.parse_array_element(field, "element_span".to_string()); + self.append(format!(" output->{id}_[n] = {out};")); + self.append("}".to_string()); + self.append("span.clear();".to_string()); + } + + (ElementSize::Unknown, ArraySize::StaticCount(count)) => { + let tid = type_id.unwrap(); + self.append(format!("for (size_t n = 0; n < {count}; n++) {{")); + self.append(format!(" {tid} out;")); + self.append(format!(" if (!{tid}::Parse(span, &out)) {{")); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + self.append(format!(" output->{id}_[n] = std::move(out);")); + self.append("}".to_string()); + } + + (ElementSize::Unknown, ArraySize::DynamicCount) => { + let tid = type_id.unwrap(); + self.append(format!("for (size_t n = 0; n < output->{id}_count_; n++) {{")); + self.append(format!(" {tid} out;")); + self.append(format!(" if (!{tid}::Parse(span, &out)) {{")); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + self.append(format!(" output->{id}_.push_back(std::move(out));")); + self.append("}".to_string()); + } + + (ElementSize::Unknown, ArraySize::DynamicSize) => { + let tid = type_id.unwrap(); + self.check_size(&format!("output->{id}_size_")); + self.append(format!("auto {id}_span = span.subrange(0, output->{id}_size_);")); + self.append(format!("while ({id}_span.size() > 0) {{")); + self.append(format!(" {tid} out;")); + self.append(format!(" if (!{tid}::Parse({id}_span, &out)) {{")); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + self.append(format!(" output->{id}_.push_back(std::move(out));")); + self.append("}".to_string()); + self.append(format!("span.skip(output->{id}_size_);")); + } + + (ElementSize::Unknown, ArraySize::Unknown) => { + let tid = type_id.unwrap(); self.append("while (span.size() > 0) {".to_string()); + self.append(format!(" {tid} out;")); + self.append(format!(" if (!{tid}::Parse(span, &out)) {{")); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + self.append(format!(" output->{id}_.push_back(std::move(out));")); + self.append("}".to_string()); } + } + } - if let Some(tid) = type_id { - let td = self.scope.typedef.get(tid).unwrap(); - match &td.desc { - ast::DeclDesc::Enum { width, .. } => { + fn parse_array_element(&mut self, field: &'a ast::Field, span: String) -> String { + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + match &field.desc { + ast::FieldDesc::Array { width: Some(width), type_id: None, .. } => { + let element_size = *width / 8; + let backing_type = get_cxx_scalar_type(*width); + format!("{span}.read_{byteorder}<{backing_type}, {element_size}>()") + } + ast::FieldDesc::Array { type_id: Some(type_id), .. } => { + match &self.scope.typedef.get(type_id).unwrap().desc { + ast::DeclDesc::Enum { width, tags, .. } => { + let element_size = *width / 8; let backing_type = get_cxx_scalar_type(*width); - self.append(format!(" if (span.size() < {}) return false;", width / 8)); - self.append(format!( - " {}{}_.push_back({}(span.read_{}<{}, {}>()));", - self.target_prefix, - id, - tid, - byteorder, - backing_type, - width / 8 - )); + let raw_value = + format!("{span}.read_{byteorder}<{backing_type}, {element_size}>()"); + if tags.iter().any(|t| matches!(t, ast::Tag::Other(_))) { + format!("{type_id}({raw_value})") + } else { + self.append(format!(" auto raw_value = {raw_value};")); + self.append(format!(" if (!IsValid{type_id}(raw_value)) {{")); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + format!("{type_id}(raw_value)") + } } _ => { - self.append(format!(" {} element;", tid)); - self.append(format!( - " if (!{}::Parse(span, &element)) return false;", - tid - )); - self.append(format!( - " {}{}_.emplace_back(std::move(element));", - self.target_prefix, id - )); + self.append(format!(" {type_id} out;")); + self.append(format!(" if (!{type_id}::Parse({span}, &out)) {{")); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + "out".to_string() } } - } else { - let element_width = width.unwrap(); - let backing_type = get_cxx_scalar_type(element_width); - self.append(format!(" if (span.size() < {}) return false;", element_width / 8)); - self.append(format!( - " {}{}_.push_back(span.read_{}<{}, {}>());", - self.target_prefix, - id, - byteorder, - backing_type, - element_width / 8 - )); } - self.append("}".to_string()); + _ => unreachable!(), } } @@ -951,26 +1019,34 @@ impl<'a> FieldParser<'a> { self.check_code(); match &field.desc { ast::FieldDesc::Padding { .. } => {} - ast::FieldDesc::Array { id, type_id, width, size, .. } => { + ast::FieldDesc::Array { id, type_id, size_modifier, .. } => { let padded_size = self.schema.padded_size(field.key); if padded_size.is_some() { - self.append(format!("size_t {0}_start_size = span.size();", id)); + self.append(format!("size_t {id}_start_size = span.size();")); } if !self.extract_arrays { - self.parse_array_field_lite(field, id, type_id.as_deref(), *width, *size); + self.parse_array_field_lite( + field, + id, + type_id.as_deref(), + size_modifier.as_deref(), + ); } else { - self.parse_array_field_full(field, id, type_id.as_deref(), *width, *size); + self.parse_array_field_full( + field, + id, + type_id.as_deref(), + size_modifier.as_deref(), + ); } - if let Some(ps) = padded_size { - let ps_bytes = ps / 8; + if let Some(padded_size) = padded_size { + let padding_bytes = padded_size / 8; self.append(format!( - "if ({0}_start_size - span.size() < {1}) {{", - id, ps_bytes + "if ({id}_start_size - span.size() < {padding_bytes}) {{", )); - self.append(format!(" if (span.size() < {1} - ({0}_start_size - span.size())) return false;", id, ps_bytes)); + self.append(format!(" if (span.size() < {padding_bytes} - ({id}_start_size - span.size())) return false;")); self.append(format!( - " span.skip({1} - ({0}_start_size - span.size()));", - id, ps_bytes + " span.skip({padding_bytes} - ({id}_start_size - span.size()));", )); self.append("}".to_string()); } @@ -989,11 +1065,8 @@ impl<'a> FieldParser<'a> { }; self.append(format!("if (span.size() < {}) return false;", width / 8)); self.append(format!( - "{}{}_ = span.read_{}<{}, {}>();", + "{}{id}_ = span.read_{byteorder}<{ty}, {}>();", self.target_prefix, - id, - byteorder, - ty, width / 8 )); } @@ -1010,11 +1083,8 @@ impl<'a> FieldParser<'a> { }; self.append(format!("if (span.size() < {}) return false;", width / 8)); self.append(format!( - "{}{}_size_ = span.read_{}<{}, {}>();", + "{}{field_name}_size_ = span.read_{byteorder}<{ty}, {}>();", self.target_prefix, - field_name, - byteorder, - ty, width / 8 )); } @@ -1026,11 +1096,8 @@ impl<'a> FieldParser<'a> { }; self.append(format!("if (span.size() < {}) return false;", width / 8)); self.append(format!( - "{}{}_count_ = span.read_{}<{}, {}>();", + "{}{field_id}_count_ = span.read_{byteorder}<{ty}, {}>();", self.target_prefix, - field_id, - byteorder, - ty, width / 8 )); } @@ -1047,11 +1114,8 @@ impl<'a> FieldParser<'a> { }; self.append(format!("if (span.size() < {}) return false;", width / 8)); self.append(format!( - "{}{}_element_size_ = span.read_{}<{}, {}>();", + "{}{field_name}_element_size_ = span.read_{byteorder}<{ty}, {}>();", self.target_prefix, - field_name, - byteorder, - ty, width / 8 )); } @@ -1063,11 +1127,8 @@ impl<'a> FieldParser<'a> { }; self.append(format!("if (span.size() < {}) return false;", width / 8)); self.append(format!( - "if (span.read_{}<{}, {}>() != {:#x}) return false;", - byteorder, - ty, + "if (span.read_{byteorder}<{ty}, {}>() != {value:#x}) return false;", width / 8, - value )); } ast::FieldDesc::FixedEnum { enum_id, tag_id, .. } => { @@ -1082,13 +1143,8 @@ impl<'a> FieldParser<'a> { }; self.append(format!("if (span.size() < {}) return false;", width / 8)); self.append(format!( - "if (span.read_{}<{}, {}>() != static_cast<{}>( {}::{} )) return false;", - byteorder, - ty, + "if (span.read_{byteorder}<{ty}, {}>() != static_cast<{ty}>( {enum_id}::{tag_id} )) return false;", width / 8, - ty, - enum_id, - tag_id )); } ast::FieldDesc::Typedef { id, type_id, .. } => { @@ -1217,7 +1273,7 @@ impl<'a> FieldSerializer<'a> { id, element_size ) } else { - format!("({0}_.size() * {1})", id, element_size) + format!("({id}_.size() * {element_size})") } } ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body => { @@ -1260,7 +1316,7 @@ impl<'a> FieldSerializer<'a> { _ => None, }; if let Some(m) = size_modifier { - return format!("({} {})", size_expr, m); + return format!("({size_expr} {m})"); } size_expr } @@ -1279,8 +1335,7 @@ impl<'a> FieldSerializer<'a> { if self.values.is_empty() { self.append(&format!( - "pdl::packet::Builder::write_{}<{}, {}>(output, 0);", - byteorder, backing_type, size + "pdl::packet::Builder::write_{byteorder}<{backing_type}, {size}>(output, 0);", )); } else { let packed_val = self @@ -1288,16 +1343,15 @@ impl<'a> FieldSerializer<'a> { .iter() .map(|(v, s)| { if *s == 0 { - format!("(static_cast<{}>({}))", backing_type, v) + format!("(static_cast<{backing_type}>({v}))") } else { - format!("(static_cast<{}>({}) << {})", backing_type, v, s) + format!("(static_cast<{backing_type}>({v}) << {s})") } }) .collect::>() .join(" | "); self.append(&format!( - "pdl::packet::Builder::write_{}<{}, {}>(output, {});", - byteorder, backing_type, size, packed_val + "pdl::packet::Builder::write_{byteorder}<{backing_type}, {size}>(output, {packed_val});", )); } @@ -1332,10 +1386,8 @@ impl<'a> FieldSerializer<'a> { let (opt_id, val_present) = &optional_field_ids[0]; let val_absent = if *val_present == 0 { 1 } else { 0 }; format!( - "({0}.has_value() ? {1} : {2})", + "({0}.has_value() ? {val_present} : {val_absent})", deref(var, &format!("{}_", opt_id)), - val_present, - val_absent ) } _ => deref(var, &format!("{}_", f.id().unwrap())), @@ -1615,7 +1667,7 @@ fn generate_packet_view( if is_constrained { // Constrained fields still get accessors returning their constant values. let fid = field.id().unwrap(); - let accessor_name = to_pascal_case(fid); + let accessor_name = fid.to_upper_camel_case(); let constraint = constraint.unwrap(); match &field.desc { ast::FieldDesc::Typedef { type_id, .. } => { @@ -1664,7 +1716,7 @@ fn generate_packet_view( } ast::FieldDesc::Array { id, type_id, width, size, .. } => { field_members.push(format!("pdl::packet::slice {}_;", id)); - let accessor_name = to_pascal_case(id); + let accessor_name = id.to_upper_camel_case(); let element_type = type_id .as_deref() .map(|t| t.to_string()) @@ -1781,7 +1833,7 @@ fn generate_packet_view( } ast::FieldDesc::Scalar { id, width } => { let ty = get_cxx_scalar_type(*width); - let accessor_name = to_pascal_case(id); + let accessor_name = id.to_upper_camel_case(); if field.cond.is_some() { field_members.push(format!("std::optional<{}> {}_;", ty, id)); field_accessors.push(format!(" std::optional<{}> Get{}() const {{ _ASSERT_VALID(valid_); return {}_; }}\n", ty, accessor_name, id)); @@ -1795,7 +1847,7 @@ fn generate_packet_view( } ast::FieldDesc::Typedef { id, type_id, .. } => { let ty = type_id; - let accessor_name = to_pascal_case(id); + let accessor_name = id.to_upper_camel_case(); if field.cond.is_some() { field_members.push(format!("std::optional<{}> {}_;", ty, id)); field_accessors.push(format!(" std::optional<{}> Get{}() const {{ _ASSERT_VALID(valid_); return {}_; }}\n", ty, accessor_name, id)); @@ -1866,14 +1918,11 @@ fn generate_packet_view( } parser.done(); field_parsers.extend(parser.code); - - let has_payload = decl - .fields() - .any(|f| matches!(f.desc, ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body)); - if !has_payload { - field_parsers.push("if (span.size() != 0) { return false; }".to_string()); - } } + + field_parsers.push("if (span.size() > 0) {".to_string()); + field_parsers.push(" return false;".to_string()); + field_parsers.push("}".to_string()); field_parsers.push("return true;".to_string()); let friend_classes = scope @@ -2401,22 +2450,21 @@ fn generate_struct_declaration( } let size_expr = if variable_widths.is_empty() { - format!("return {};", static_bits / 8) + format!("{}", static_bits / 8) } else if static_bits > 0 { - format!("return {} + ({});", static_bits / 8, variable_widths.join(" + ")) + format!("{} + ({})", static_bits / 8, variable_widths.join(" + ")) } else { - format!("return {};", variable_widths.join(" + ")) + variable_widths.join(" + ").to_string() }; - let constructor = if constructor_params.is_empty() { - format!(" {0}() = default;", id) - } else { + let constructor = if !constructor_params.is_empty() { format!( - " {0}() = default;\n explicit {0}({1}) : {2} {{}}", - id, - constructor_params.join(", "), - constructor_inits.join(", ") + " explicit {id}({constructor_parameters}) : {initializer_list} {{}}", + constructor_parameters = constructor_params.join(", "), + initializer_list = constructor_inits.join(", ") ) + } else { + String::new() }; format!( @@ -2424,9 +2472,10 @@ fn generate_struct_declaration( class {id} : public pdl::packet::Builder {{ public: ~{id}() override = default; -{constructor} + {id}() = default; {id}({id} const&) = default; {id}({id}&&) = default; +{constructor} {id}& operator=({id} const&) = default; static bool Parse(pdl::packet::slice& parent_span, {id}* output) {{ @@ -2438,7 +2487,7 @@ public: }} size_t GetSize() const override {{ - {size_expr} + return {size_expr}; }} std::string ToString() const {{ return ""; }} @@ -2446,11 +2495,8 @@ public: {field_members} }}; "#, - id = id, - constructor = constructor, struct_parse_code = indent(&field_parsers.join("\n"), 2), field_serializers = indent(&field_serializers.join("\n"), 2), - size_expr = size_expr, field_members = indent(&field_members.join("\n"), 1) ) } @@ -2478,10 +2524,6 @@ mod test { "Packet_Custom_Field_VariableSize".to_string(), "Packet_Checksum_Field_FromStart".to_string(), "Packet_Checksum_Field_FromEnd".to_string(), - "Packet_Array_Field_VariableElementSize_ConstantSize".to_string(), - "Packet_Array_Field_VariableElementSize_VariableSize".to_string(), - "Packet_Array_Field_VariableElementSize_VariableCount".to_string(), - "Packet_Array_Field_VariableElementSize_UnknownSize".to_string(), "Struct_Custom_Field_ConstantSize".to_string(), "Struct_Custom_Field_VariableSize".to_string(), "Struct_Checksum_Field_FromStart".to_string(), diff --git a/pdl-compiler/tests/generated/cxx/le_backend.h b/pdl-compiler/tests/generated/cxx/le_backend.h index aa586be..f8b7191 100644 --- a/pdl-compiler/tests/generated/cxx/le_backend.h +++ b/pdl-compiler/tests/generated/cxx/le_backend.h @@ -1,5 +1,5 @@ -// File generated from tests/canonical/le_test_file.pdl, with the command: -// pdlc ... +// File generated from tests/canonical/le_test_file.pdl, with the command +// pdlc --output-format cxx tests/canonical/le_test_file.pdl // /!\ Do not edit by hand #pragma once @@ -67,6 +67,10 @@ class Packet_Array_Field_UnsizedElement_UnknownSizeView; class Packet_Array_Field_UnsizedElement_SizeModifierView; class Packet_Array_Field_SizedElement_VariableSize_PaddedView; class Packet_Array_Field_UnsizedElement_VariableCount_PaddedView; +class Packet_Array_Field_VariableElementSize_ConstantSizeView; +class Packet_Array_Field_VariableElementSize_VariableSizeView; +class Packet_Array_Field_VariableElementSize_VariableCountView; +class Packet_Array_Field_VariableElementSize_UnknownSizeView; class Packet_Optional_Scalar_FieldView; class Packet_Optional_Enum_FieldView; class Packet_Optional_Struct_FieldView; @@ -134,8 +138,14 @@ inline std::string Enum7Text(Enum7 tag) { } } -inline bool IsEnum7Valid(Enum7 tag) { - return tag == Enum7::A || tag == Enum7::B; +inline bool IsValidEnum7(uint8_t value) { + switch (value) { + case 0x1: + case 0x2: + return true; + default: + return false; + } } enum class Enum16 : uint16_t { @@ -153,17 +163,23 @@ inline std::string Enum16Text(Enum16 tag) { } } -inline bool IsEnum16Valid(Enum16 tag) { - return tag == Enum16::A || tag == Enum16::B; +inline bool IsValidEnum16(uint16_t value) { + switch (value) { + case 0xaabb: + case 0xccdd: + return true; + default: + return false; + } } class SizedStruct : public pdl::packet::Builder { public: ~SizedStruct() override = default; SizedStruct() = default; - explicit SizedStruct(uint8_t a) : a_(std::move(a)) {} SizedStruct(SizedStruct const&) = default; SizedStruct(SizedStruct&&) = default; + explicit SizedStruct(uint8_t a) : a_(std::move(a)) {} SizedStruct& operator=(SizedStruct const&) = default; static bool Parse(pdl::packet::slice& parent_span, SizedStruct* output) { @@ -193,9 +209,9 @@ class UnsizedStruct : public pdl::packet::Builder { public: ~UnsizedStruct() override = default; UnsizedStruct() = default; - explicit UnsizedStruct(std::vector array) : array_(std::move(array)) {} UnsizedStruct(UnsizedStruct const&) = default; UnsizedStruct(UnsizedStruct&&) = default; + explicit UnsizedStruct(std::vector array) : array_(std::move(array)) {} UnsizedStruct& operator=(UnsizedStruct const&) = default; static bool Parse(pdl::packet::slice& parent_span, UnsizedStruct* output) { @@ -205,11 +221,14 @@ class UnsizedStruct : public pdl::packet::Builder { } uint8_t chunk0 = span.read_le(); output->array_size_ = (chunk0 >> 0) & 0x3; - if (span.size() < output->array_size_) return false; - if ((output->array_size_ % 1) != 0) return false; - size_t limit = span.size() - output->array_size_; - while (span.size() > limit) { - if (span.size() < 1) return false; + if (span.size() < output->array_size_) { + return false; + } + if ((output->array_size_ % 1) != 0) { + return false; + } + auto array_count_ = output->array_size_ / 1; + for (size_t n = 0; n < array_count_; n++) { output->array_.push_back(span.read_le()); } parent_span = span; @@ -238,15 +257,18 @@ class UnknownSizeStruct : public pdl::packet::Builder { public: ~UnknownSizeStruct() override = default; UnknownSizeStruct() = default; - explicit UnknownSizeStruct(std::vector array) : array_(std::move(array)) {} UnknownSizeStruct(UnknownSizeStruct const&) = default; UnknownSizeStruct(UnknownSizeStruct&&) = default; + explicit UnknownSizeStruct(std::vector array) : array_(std::move(array)) {} UnknownSizeStruct& operator=(UnknownSizeStruct const&) = default; static bool Parse(pdl::packet::slice& parent_span, UnknownSizeStruct* output) { pdl::packet::slice span = parent_span; - while (span.size() > 0) { - if (span.size() < 1) return false; + if ((span.size() % 1) != 0) { + return false; + } + auto array_count_ = span.size() / 1; + for (size_t n = 0; n < array_count_; n++) { output->array_.push_back(span.read_le()); } parent_span = span; @@ -307,6 +329,9 @@ class ScalarParentView { if (span.size() < payload_size_) return false; payload_ = span.subrange(0, payload_size_); span.skip(payload_size_); + if (span.size() > 0) { + return false; + } return true; } @@ -382,12 +407,18 @@ class EnumParentView { if (span.size() < 3) { return false; } - a_ = static_cast( span.read_le() ); - if (!IsEnum16Valid(a_)) return false; + auto raw_value = span.read_le(); + if (!IsValidEnum16(raw_value)) { + return false; + } + a_ = Enum16(raw_value); payload_size_ = span.read_le(); if (span.size() < payload_size_) return false; payload_ = span.subrange(0, payload_size_); span.skip(payload_size_); + if (span.size() > 0) { + return false; + } return true; } @@ -465,6 +496,9 @@ class EmptyParentView { pdl::packet::slice span = parent.payload_; payload_ = span; span.clear(); + if (span.size() > 0) { + return false; + } return true; } @@ -540,7 +574,9 @@ class Packet_Scalar_FieldView { uint64_t chunk0 = span.read_le(); a_ = (chunk0 >> 0) & 0x7f; c_ = (chunk0 >> 7) & 0x1ffffffffffffff; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -608,10 +644,15 @@ class Packet_Enum_FieldView { return false; } uint64_t chunk0 = span.read_le(); - a_ = static_cast( (chunk0 >> 0) & 0x7f ); - if (!IsEnum7Valid(a_)) return false; + auto raw_value = (chunk0 >> 0) & 0x7f; + if (!IsValidEnum7(raw_value)) { + return false; + } + a_ = Enum7(raw_value); c_ = (chunk0 >> 7) & 0x1ffffffffffffff; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -681,7 +722,9 @@ class Packet_Reserved_FieldView { uint64_t chunk0 = span.read_le(); a_ = (chunk0 >> 0) & 0x7f; c_ = (chunk0 >> 9) & 0x7fffffffffffff; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -759,11 +802,17 @@ class Packet_Size_FieldView { uint64_t chunk0 = span.read_le(); b_size_ = (chunk0 >> 0) & 0x7; a_ = (chunk0 >> 3) & 0x1fffffffffffffff; - if (span.size() < b_size_) return false; - if ((b_size_ % 1) != 0) return false; + if (span.size() < b_size_) { + return false; + } + if ((b_size_ % 1) != 0) { + return false; + } b_ = span.subrange(0, b_size_); span.skip(b_size_); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -847,10 +896,14 @@ class Packet_Count_FieldView { uint64_t chunk0 = span.read_le(); b_count_ = (chunk0 >> 0) & 0x7; a_ = (chunk0 >> 3) & 0x1fffffffffffffff; - if (span.size() < b_count_ * 1) return false; - b_ = span.subrange(0, b_count_ * 1); - span.skip(b_count_ * 1); - if (span.size() != 0) { return false; } + if (span.size() < 1 * b_count_) { + return false; + } + b_ = span.subrange(0, 1 * b_count_); + span.skip(1 * b_count_); + if (span.size() > 0) { + return false; + } return true; } @@ -925,7 +978,9 @@ class Packet_FixedScalar_FieldView { return false; } b_ = (chunk0 >> 7) & 0x1ffffffffffffff; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -993,7 +1048,9 @@ class Packet_FixedEnum_FieldView { return false; } b_ = (chunk0 >> 7) & 0x1ffffffffffffff; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -1063,6 +1120,9 @@ class Packet_Payload_Field_VariableSizeView { if (span.size() < payload_size_) return false; payload_ = span.subrange(0, payload_size_); span.skip(payload_size_); + if (span.size() > 0) { + return false; + } return true; } @@ -1136,6 +1196,9 @@ class Packet_Payload_Field_SizeModifierView { if (span.size() < (payload_size_ - 2)) return false; payload_ = span.subrange(0, (payload_size_ - 2)); span.skip((payload_size_ - 2)); + if (span.size() > 0) { + return false; + } return true; } @@ -1210,6 +1273,9 @@ class Packet_Payload_Field_UnknownSizeView { return false; } a_ = span.read_le(); + if (span.size() > 0) { + return false; + } return true; } @@ -1282,6 +1348,9 @@ class Packet_Payload_Field_UnknownSize_TerminalView { a_ = span.read_le(); payload_ = span; span.clear(); + if (span.size() > 0) { + return false; + } return true; } @@ -1354,6 +1423,9 @@ class Packet_Body_Field_VariableSizeView { if (span.size() < payload_size_) return false; payload_ = span.subrange(0, payload_size_); span.skip(payload_size_); + if (span.size() > 0) { + return false; + } return true; } @@ -1428,6 +1500,9 @@ class Packet_Body_Field_UnknownSizeView { return false; } a_ = span.read_le(); + if (span.size() > 0) { + return false; + } return true; } @@ -1500,6 +1575,9 @@ class Packet_Body_Field_UnknownSize_TerminalView { a_ = span.read_le(); payload_ = span; span.clear(); + if (span.size() > 0) { + return false; + } return true; } @@ -1567,7 +1645,9 @@ class Packet_ScalarGroup_FieldView { if (static_cast(span.read_le()) != 0x2a) { return false; } - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -1631,7 +1711,9 @@ class Packet_EnumGroup_FieldView { if (Enum16(span.read_le()) != Enum16::A) { return false; } - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -1694,7 +1776,9 @@ class Packet_Struct_FieldView { pdl::packet::slice span = parent; if (!SizedStruct::Parse(span, &a_)) return false; if (!UnsizedStruct::Parse(span, &b_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -1770,7 +1854,9 @@ class Packet_Array_Field_ByteElement_ConstantSizeView { } array_ = span.subrange(0, 4); span.skip(4); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -1845,11 +1931,17 @@ class Packet_Array_Field_ByteElement_VariableSizeView { } uint8_t chunk0 = span.read_le(); array_size_ = (chunk0 >> 0) & 0xf; - if (span.size() < array_size_) return false; - if ((array_size_ % 1) != 0) return false; + if (span.size() < array_size_) { + return false; + } + if ((array_size_ % 1) != 0) { + return false; + } array_ = span.subrange(0, array_size_); span.skip(array_size_); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -1928,10 +2020,14 @@ class Packet_Array_Field_ByteElement_VariableCountView { } uint8_t chunk0 = span.read_le(); array_count_ = (chunk0 >> 0) & 0xf; - if (span.size() < array_count_ * 1) return false; - array_ = span.subrange(0, array_count_ * 1); - span.skip(array_count_ * 1); - if (span.size() != 0) { return false; } + if (span.size() < 1 * array_count_) { + return false; + } + array_ = span.subrange(0, 1 * array_count_); + span.skip(1 * array_count_); + if (span.size() > 0) { + return false; + } return true; } @@ -2004,9 +2100,14 @@ class Packet_Array_Field_ByteElement_UnknownSizeView { bool Parse(pdl::packet::slice const& parent) { // Parse packet field values. pdl::packet::slice span = parent; + if ((span.size() % 1) != 0) { + return false; + } array_ = span; span.clear(); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -2081,7 +2182,9 @@ class Packet_Array_Field_ScalarElement_ConstantSizeView { } array_ = span.subrange(0, 8); span.skip(8); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -2156,11 +2259,17 @@ class Packet_Array_Field_ScalarElement_VariableSizeView { } uint8_t chunk0 = span.read_le(); array_size_ = (chunk0 >> 0) & 0xf; - if (span.size() < array_size_) return false; - if ((array_size_ % 2) != 0) return false; + if (span.size() < array_size_) { + return false; + } + if ((array_size_ % 2) != 0) { + return false; + } array_ = span.subrange(0, array_size_); span.skip(array_size_); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -2239,10 +2348,14 @@ class Packet_Array_Field_ScalarElement_VariableCountView { } uint8_t chunk0 = span.read_le(); array_count_ = (chunk0 >> 0) & 0xf; - if (span.size() < array_count_ * 2) return false; - array_ = span.subrange(0, array_count_ * 2); - span.skip(array_count_ * 2); - if (span.size() != 0) { return false; } + if (span.size() < 2 * array_count_) { + return false; + } + array_ = span.subrange(0, 2 * array_count_); + span.skip(2 * array_count_); + if (span.size() > 0) { + return false; + } return true; } @@ -2315,9 +2428,14 @@ class Packet_Array_Field_ScalarElement_UnknownSizeView { bool Parse(pdl::packet::slice const& parent) { // Parse packet field values. pdl::packet::slice span = parent; + if ((span.size() % 2) != 0) { + return false; + } array_ = span; span.clear(); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -2392,7 +2510,9 @@ class Packet_Array_Field_EnumElement_ConstantSizeView { } array_ = span.subrange(0, 8); span.skip(8); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -2467,10 +2587,17 @@ class Packet_Array_Field_EnumElement_VariableSizeView { } uint8_t chunk0 = span.read_le(); array_size_ = (chunk0 >> 0) & 0xf; - if (span.size() < array_size_) return false; + if (span.size() < array_size_) { + return false; + } + if ((array_size_ % 2) != 0) { + return false; + } array_ = span.subrange(0, array_size_); span.skip(array_size_); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -2549,9 +2676,14 @@ class Packet_Array_Field_EnumElement_VariableCountView { } uint8_t chunk0 = span.read_le(); array_count_ = (chunk0 >> 0) & 0xf; - array_ = span; - span.clear(); - if (span.size() != 0) { return false; } + if (span.size() < 2 * array_count_) { + return false; + } + array_ = span.subrange(0, 2 * array_count_); + span.skip(2 * array_count_); + if (span.size() > 0) { + return false; + } return true; } @@ -2624,9 +2756,14 @@ class Packet_Array_Field_EnumElement_UnknownSizeView { bool Parse(pdl::packet::slice const& parent) { // Parse packet field values. pdl::packet::slice span = parent; + if ((span.size() % 2) != 0) { + return false; + } array_ = span; span.clear(); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -2701,7 +2838,9 @@ class Packet_Array_Field_SizedElement_ConstantSizeView { } array_ = span.subrange(0, 4); span.skip(4); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -2778,10 +2917,17 @@ class Packet_Array_Field_SizedElement_VariableSizeView { } uint8_t chunk0 = span.read_le(); array_size_ = (chunk0 >> 0) & 0xf; - if (span.size() < array_size_) return false; + if (span.size() < array_size_) { + return false; + } + if ((array_size_ % 1) != 0) { + return false; + } array_ = span.subrange(0, array_size_); span.skip(array_size_); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -2862,9 +3008,14 @@ class Packet_Array_Field_SizedElement_VariableCountView { } uint8_t chunk0 = span.read_le(); array_count_ = (chunk0 >> 0) & 0xf; - array_ = span; - span.clear(); - if (span.size() != 0) { return false; } + if (span.size() < 1 * array_count_) { + return false; + } + array_ = span.subrange(0, 1 * array_count_); + span.skip(1 * array_count_); + if (span.size() > 0) { + return false; + } return true; } @@ -2939,9 +3090,14 @@ class Packet_Array_Field_SizedElement_UnknownSizeView { bool Parse(pdl::packet::slice const& parent) { // Parse packet field values. pdl::packet::slice span = parent; + if ((span.size() % 1) != 0) { + return false; + } array_ = span; span.clear(); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -3012,8 +3168,16 @@ class Packet_Array_Field_UnsizedElement_ConstantSizeView { // Parse packet field values. pdl::packet::slice span = parent; array_ = span; - span.clear(); - if (span.size() != 0) { return false; } + for (size_t n = 0; n < 4; n++) { + UnsizedStruct out; + if (!UnsizedStruct::Parse(span, &out)) { + return false; + } + } + array_ = array_.subrange(0, array_.size() - span.size()); + if (span.size() > 0) { + return false; + } return true; } @@ -3090,10 +3254,14 @@ class Packet_Array_Field_UnsizedElement_VariableSizeView { } uint8_t chunk0 = span.read_le(); array_size_ = (chunk0 >> 0) & 0xf; - if (span.size() < array_size_) return false; + if (span.size() < array_size_) { + return false; + } array_ = span.subrange(0, array_size_); span.skip(array_size_); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -3175,8 +3343,16 @@ class Packet_Array_Field_UnsizedElement_VariableCountView { uint8_t chunk0 = span.read_le(); array_count_ = (chunk0 >> 0) & 0xf; array_ = span; - span.clear(); - if (span.size() != 0) { return false; } + for (size_t n = 0; n < array_count_; n++) { + UnsizedStruct out; + if (!UnsizedStruct::Parse(span, &out)) { + return false; + } + } + array_ = array_.subrange(0, array_.size() - span.size()); + if (span.size() > 0) { + return false; + } return true; } @@ -3252,8 +3428,16 @@ class Packet_Array_Field_UnsizedElement_UnknownSizeView { // Parse packet field values. pdl::packet::slice span = parent; array_ = span; - span.clear(); - if (span.size() != 0) { return false; } + while (span.size() > 0) { + UnsizedStruct out; + if (!UnsizedStruct::Parse(span, &out)) { + return false; + } + } + array_ = array_.subrange(0, array_.size() - span.size()); + if (span.size() > 0) { + return false; + } return true; } @@ -3330,10 +3514,15 @@ class Packet_Array_Field_UnsizedElement_SizeModifierView { } uint8_t chunk0 = span.read_le(); array_size_ = (chunk0 >> 0) & 0xf; - if (span.size() < (array_size_ - 2)) return false; - array_ = span.subrange(0, (array_size_ - 2)); - span.skip((array_size_ - 2)); - if (span.size() != 0) { return false; } + array_size_ = array_size_ - +2; + if (span.size() < array_size_) { + return false; + } + array_ = span.subrange(0, array_size_); + span.skip(array_size_); + if (span.size() > 0) { + return false; + } return true; } @@ -3413,15 +3602,21 @@ class Packet_Array_Field_SizedElement_VariableSize_PaddedView { uint8_t chunk0 = span.read_le(); array_size_ = (chunk0 >> 0) & 0xf; size_t array_start_size = span.size(); - if (span.size() < array_size_) return false; - if ((array_size_ % 2) != 0) return false; + if (span.size() < array_size_) { + return false; + } + if ((array_size_ % 2) != 0) { + return false; + } array_ = span.subrange(0, array_size_); span.skip(array_size_); if (array_start_size - span.size() < 16) { if (span.size() < 16 - (array_start_size - span.size())) return false; span.skip(16 - (array_start_size - span.size())); } - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -3507,12 +3702,20 @@ class Packet_Array_Field_UnsizedElement_VariableCount_PaddedView { array_count_ = span.read_le(); size_t array_start_size = span.size(); array_ = span; - span.clear(); + for (size_t n = 0; n < array_count_; n++) { + UnsizedStruct out; + if (!UnsizedStruct::Parse(span, &out)) { + return false; + } + } + array_ = array_.subrange(0, array_.size() - span.size()); if (array_start_size - span.size() < 16) { if (span.size() < 16 - (array_start_size - span.size())) return false; span.skip(16 - (array_start_size - span.size())); } - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -3554,6 +3757,410 @@ class Packet_Array_Field_UnsizedElement_VariableCount_PaddedBuilder : public pdl std::vector array_; }; +class Packet_Array_Field_VariableElementSize_ConstantSizeView { +public: + static Packet_Array_Field_VariableElementSize_ConstantSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_VariableElementSize_ConstantSizeView(parent); + } + + std::array GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::array elements; + for (int n = 0; n < 4; n++) { + UnknownSizeStruct::Parse(span, &elements[n]); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_VariableElementSize_ConstantSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_element_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < array_element_size_ * 4) { + return false; + } + array_ = span.subrange(0, array_element_size_ * 4); + span.skip(array_element_size_ * 4); + if (span.size() > 0) { + return false; + } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_element_size_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_VariableElementSize_ConstantSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_VariableElementSize_ConstantSizeBuilder() override = default; + Packet_Array_Field_VariableElementSize_ConstantSizeBuilder() = default; + explicit Packet_Array_Field_VariableElementSize_ConstantSizeBuilder(std::array array) : array_(std::move(array)) {} + Packet_Array_Field_VariableElementSize_ConstantSizeBuilder(Packet_Array_Field_VariableElementSize_ConstantSizeBuilder const&) = default; + Packet_Array_Field_VariableElementSize_ConstantSizeBuilder(Packet_Array_Field_VariableElementSize_ConstantSizeBuilder&&) = default; + Packet_Array_Field_VariableElementSize_ConstantSizeBuilder& operator=(Packet_Array_Field_VariableElementSize_ConstantSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t array_element_size = 0; // TODO + pdl::packet::Builder::write_le(output, (static_cast(array_element_size))); + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); })); + } + + std::string ToString() const { return ""; } + + uint8_t array_element_size_ {0}; + std::array array_; +}; + +class Packet_Array_Field_VariableElementSize_VariableSizeView { +public: + static Packet_Array_Field_VariableElementSize_VariableSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_VariableElementSize_VariableSizeView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0) { + UnknownSizeStruct element; + if (!UnknownSizeStruct::Parse(span, &element)) break; + elements.emplace_back(std::move(element)); + } + return elements; + } + + std::vector GetTail() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = tail_; + std::vector elements; + while (span.size() > 0 && span.size() >= 1) { + elements.push_back(span.read_le()); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_VariableElementSize_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 2) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_size_ = (chunk0 >> 0) & 0xf; + uint8_t chunk1 = span.read_le(); + array_element_size_ = (chunk1 >> 0) & 0xf; + if (span.size() < array_size_) { + return false; + } + if ((array_size_ % array_element_size_) != 0) { + return false; + } + array_ = span.subrange(0, array_size_); + span.skip(array_size_); + if ((span.size() % 1) != 0) { + return false; + } + tail_ = span; + span.clear(); + if (span.size() > 0) { + return false; + } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_size_ {0}; + uint8_t array_element_size_ {0}; + pdl::packet::slice array_; + pdl::packet::slice tail_; + + +}; + +class Packet_Array_Field_VariableElementSize_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_VariableElementSize_VariableSizeBuilder() override = default; + Packet_Array_Field_VariableElementSize_VariableSizeBuilder() = default; + explicit Packet_Array_Field_VariableElementSize_VariableSizeBuilder(std::vector array, std::vector tail) : array_(std::move(array)), tail_(std::move(tail)) {} + Packet_Array_Field_VariableElementSize_VariableSizeBuilder(Packet_Array_Field_VariableElementSize_VariableSizeBuilder const&) = default; + Packet_Array_Field_VariableElementSize_VariableSizeBuilder(Packet_Array_Field_VariableElementSize_VariableSizeBuilder&&) = default; + Packet_Array_Field_VariableElementSize_VariableSizeBuilder& operator=(Packet_Array_Field_VariableElementSize_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t array_size = std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& element) { return s + element.GetSize(); }); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + size_t array_element_size = 0; // TODO + pdl::packet::Builder::write_le(output, (static_cast(array_element_size))); + for (auto const& element : array_) { + element.Serialize(output); + } + for (auto const& element : tail_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 2 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); }) + (tail_.size() * 1)); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + uint8_t array_element_size_ {0}; + std::vector array_; + std::vector tail_; +}; + +class Packet_Array_Field_VariableElementSize_VariableCountView { +public: + static Packet_Array_Field_VariableElementSize_VariableCountView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_VariableElementSize_VariableCountView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (elements.size() < array_count_) { + UnknownSizeStruct element; + if (!UnknownSizeStruct::Parse(span, &element)) break; + elements.emplace_back(std::move(element)); + } + return elements; + } + + std::vector GetTail() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = tail_; + std::vector elements; + while (span.size() > 0 && span.size() >= 1) { + elements.push_back(span.read_le()); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_VariableElementSize_VariableCountView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 2) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_count_ = (chunk0 >> 0) & 0xf; + uint8_t chunk1 = span.read_le(); + array_element_size_ = (chunk1 >> 0) & 0xf; + if (span.size() < array_element_size_ * array_count_) { + return false; + } + array_ = span.subrange(0, array_element_size_ * array_count_); + span.skip(array_element_size_ * array_count_); + if ((span.size() % 1) != 0) { + return false; + } + tail_ = span; + span.clear(); + if (span.size() > 0) { + return false; + } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_count_ {0}; + uint8_t array_element_size_ {0}; + pdl::packet::slice array_; + pdl::packet::slice tail_; + + +}; + +class Packet_Array_Field_VariableElementSize_VariableCountBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_VariableElementSize_VariableCountBuilder() override = default; + Packet_Array_Field_VariableElementSize_VariableCountBuilder() = default; + explicit Packet_Array_Field_VariableElementSize_VariableCountBuilder(std::vector array, std::vector tail) : array_(std::move(array)), tail_(std::move(tail)) {} + Packet_Array_Field_VariableElementSize_VariableCountBuilder(Packet_Array_Field_VariableElementSize_VariableCountBuilder const&) = default; + Packet_Array_Field_VariableElementSize_VariableCountBuilder(Packet_Array_Field_VariableElementSize_VariableCountBuilder&&) = default; + Packet_Array_Field_VariableElementSize_VariableCountBuilder& operator=(Packet_Array_Field_VariableElementSize_VariableCountBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + size_t array_element_size = 0; // TODO + pdl::packet::Builder::write_le(output, (static_cast(array_element_size))); + for (auto const& element : array_) { + element.Serialize(output); + } + for (auto const& element : tail_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 2 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); }) + (tail_.size() * 1)); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + uint8_t array_element_size_ {0}; + std::vector array_; + std::vector tail_; +}; + +class Packet_Array_Field_VariableElementSize_UnknownSizeView { +public: + static Packet_Array_Field_VariableElementSize_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_VariableElementSize_UnknownSizeView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0) { + UnknownSizeStruct element; + if (!UnknownSizeStruct::Parse(span, &element)) break; + elements.emplace_back(std::move(element)); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_VariableElementSize_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_element_size_ = (chunk0 >> 0) & 0xf; + if ((span.size() % array_element_size_) != 0) { + return false; + } + array_ = span; + span.clear(); + if (span.size() > 0) { + return false; + } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_element_size_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_VariableElementSize_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_VariableElementSize_UnknownSizeBuilder() override = default; + Packet_Array_Field_VariableElementSize_UnknownSizeBuilder() = default; + explicit Packet_Array_Field_VariableElementSize_UnknownSizeBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_VariableElementSize_UnknownSizeBuilder(Packet_Array_Field_VariableElementSize_UnknownSizeBuilder const&) = default; + Packet_Array_Field_VariableElementSize_UnknownSizeBuilder(Packet_Array_Field_VariableElementSize_UnknownSizeBuilder&&) = default; + Packet_Array_Field_VariableElementSize_UnknownSizeBuilder& operator=(Packet_Array_Field_VariableElementSize_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t array_element_size = 0; // TODO + pdl::packet::Builder::write_le(output, (static_cast(array_element_size))); + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); })); + } + + std::string ToString() const { return ""; } + + uint8_t array_element_size_ {0}; + std::vector array_; +}; + class Packet_Optional_Scalar_FieldView { public: static Packet_Optional_Scalar_FieldView Create(pdl::packet::slice const& parent) { @@ -3601,7 +4208,9 @@ class Packet_Optional_Scalar_FieldView { } b_ = span.read_le(); } - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -3681,17 +4290,25 @@ class Packet_Optional_Enum_FieldView { if (span.size() < 2) { return false; } - a_ = static_cast(span.read_le()); - if (!IsEnum16Valid(a_.value())) return false; + auto raw_value = span.read_le(); + if (!IsValidEnum16(raw_value)) { + return false; + } + a_ = Enum16(raw_value); } if (c1 == 1) { if (span.size() < 2) { return false; } - b_ = static_cast(span.read_le()); - if (!IsEnum16Valid(b_.value())) return false; + auto raw_value = span.read_le(); + if (!IsValidEnum16(raw_value)) { + return false; + } + b_ = Enum16(raw_value); + } + if (span.size() > 0) { + return false; } - if (span.size() != 0) { return false; } return true; } @@ -3779,7 +4396,9 @@ class Packet_Optional_Struct_FieldView { return false; } } - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -3855,7 +4474,9 @@ class ScalarChild_AView { return false; } b_ = span.read_le(); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -3928,7 +4549,9 @@ class ScalarChild_BView { return false; } c_ = span.read_le(); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -4001,7 +4624,9 @@ class EnumChild_AView { return false; } b_ = span.read_le(); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -4074,7 +4699,9 @@ class EnumChild_BView { return false; } c_ = span.read_le(); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -4147,7 +4774,9 @@ class AliasedChild_AView { return false; } b_ = span.read_le(); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -4220,7 +4849,9 @@ class AliasedChild_BView { return false; } c_ = span.read_le(); - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -4262,9 +4893,9 @@ class Struct_Scalar_Field : public pdl::packet::Builder { public: ~Struct_Scalar_Field() override = default; Struct_Scalar_Field() = default; - explicit Struct_Scalar_Field(uint8_t a, uint64_t c) : a_(std::move(a)), c_(std::move(c)) {} Struct_Scalar_Field(Struct_Scalar_Field const&) = default; Struct_Scalar_Field(Struct_Scalar_Field&&) = default; + explicit Struct_Scalar_Field(uint8_t a, uint64_t c) : a_(std::move(a)), c_(std::move(c)) {} Struct_Scalar_Field& operator=(Struct_Scalar_Field const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Scalar_Field* output) { @@ -4297,9 +4928,9 @@ class Struct_Enum_Field_ : public pdl::packet::Builder { public: ~Struct_Enum_Field_() override = default; Struct_Enum_Field_() = default; - explicit Struct_Enum_Field_(Enum7 a, uint64_t c) : a_(std::move(a)), c_(std::move(c)) {} Struct_Enum_Field_(Struct_Enum_Field_ const&) = default; Struct_Enum_Field_(Struct_Enum_Field_&&) = default; + explicit Struct_Enum_Field_(Enum7 a, uint64_t c) : a_(std::move(a)), c_(std::move(c)) {} Struct_Enum_Field_& operator=(Struct_Enum_Field_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Enum_Field_* output) { @@ -4308,8 +4939,11 @@ class Struct_Enum_Field_ : public pdl::packet::Builder { return false; } uint64_t chunk0 = span.read_le(); - output->a_ = static_cast( (chunk0 >> 0) & 0x7f ); - if (!IsEnum7Valid(output->a_)) return false; + auto raw_value = (chunk0 >> 0) & 0x7f; + if (!IsValidEnum7(raw_value)) { + return false; + } + output->a_ = Enum7(raw_value); output->c_ = (chunk0 >> 7) & 0x1ffffffffffffff; parent_span = span; return true; @@ -4357,7 +4991,9 @@ class Struct_Enum_FieldView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Enum_Field_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -4394,9 +5030,9 @@ class Struct_Reserved_Field_ : public pdl::packet::Builder { public: ~Struct_Reserved_Field_() override = default; Struct_Reserved_Field_() = default; - explicit Struct_Reserved_Field_(uint8_t a, uint64_t c) : a_(std::move(a)), c_(std::move(c)) {} Struct_Reserved_Field_(Struct_Reserved_Field_ const&) = default; Struct_Reserved_Field_(Struct_Reserved_Field_&&) = default; + explicit Struct_Reserved_Field_(uint8_t a, uint64_t c) : a_(std::move(a)), c_(std::move(c)) {} Struct_Reserved_Field_& operator=(Struct_Reserved_Field_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Reserved_Field_* output) { @@ -4453,7 +5089,9 @@ class Struct_Reserved_FieldView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Reserved_Field_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -4490,9 +5128,9 @@ class Struct_Size_Field_ : public pdl::packet::Builder { public: ~Struct_Size_Field_() override = default; Struct_Size_Field_() = default; - explicit Struct_Size_Field_(uint64_t a, std::vector b) : a_(std::move(a)), b_(std::move(b)) {} Struct_Size_Field_(Struct_Size_Field_ const&) = default; Struct_Size_Field_(Struct_Size_Field_&&) = default; + explicit Struct_Size_Field_(uint64_t a, std::vector b) : a_(std::move(a)), b_(std::move(b)) {} Struct_Size_Field_& operator=(Struct_Size_Field_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Size_Field_* output) { @@ -4503,11 +5141,14 @@ class Struct_Size_Field_ : public pdl::packet::Builder { uint64_t chunk0 = span.read_le(); output->b_size_ = (chunk0 >> 0) & 0x7; output->a_ = (chunk0 >> 3) & 0x1fffffffffffffff; - if (span.size() < output->b_size_) return false; - if ((output->b_size_ % 1) != 0) return false; - size_t limit = span.size() - output->b_size_; - while (span.size() > limit) { - if (span.size() < 1) return false; + if (span.size() < output->b_size_) { + return false; + } + if ((output->b_size_ % 1) != 0) { + return false; + } + auto b_count_ = output->b_size_ / 1; + for (size_t n = 0; n < b_count_; n++) { output->b_.push_back(span.read_le()); } parent_span = span; @@ -4561,7 +5202,9 @@ class Struct_Size_FieldView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Size_Field_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -4598,9 +5241,9 @@ class Struct_Count_Field_ : public pdl::packet::Builder { public: ~Struct_Count_Field_() override = default; Struct_Count_Field_() = default; - explicit Struct_Count_Field_(uint64_t a, std::vector b) : a_(std::move(a)), b_(std::move(b)) {} Struct_Count_Field_(Struct_Count_Field_ const&) = default; Struct_Count_Field_(Struct_Count_Field_&&) = default; + explicit Struct_Count_Field_(uint64_t a, std::vector b) : a_(std::move(a)), b_(std::move(b)) {} Struct_Count_Field_& operator=(Struct_Count_Field_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Count_Field_* output) { @@ -4611,8 +5254,10 @@ class Struct_Count_Field_ : public pdl::packet::Builder { uint64_t chunk0 = span.read_le(); output->b_count_ = (chunk0 >> 0) & 0x7; output->a_ = (chunk0 >> 3) & 0x1fffffffffffffff; + if (span.size() < 1 * output->b_count_) { + return false; + } for (size_t n = 0; n < output->b_count_; n++) { - if (span.size() < 1) return false; output->b_.push_back(span.read_le()); } parent_span = span; @@ -4665,7 +5310,9 @@ class Struct_Count_FieldView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Count_Field_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -4702,9 +5349,9 @@ class Struct_FixedScalar_Field_ : public pdl::packet::Builder { public: ~Struct_FixedScalar_Field_() override = default; Struct_FixedScalar_Field_() = default; - explicit Struct_FixedScalar_Field_(uint64_t b) : b_(std::move(b)) {} Struct_FixedScalar_Field_(Struct_FixedScalar_Field_ const&) = default; Struct_FixedScalar_Field_(Struct_FixedScalar_Field_&&) = default; + explicit Struct_FixedScalar_Field_(uint64_t b) : b_(std::move(b)) {} Struct_FixedScalar_Field_& operator=(Struct_FixedScalar_Field_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_FixedScalar_Field_* output) { @@ -4762,7 +5409,9 @@ class Struct_FixedScalar_FieldView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_FixedScalar_Field_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -4799,9 +5448,9 @@ class Struct_FixedEnum_Field_ : public pdl::packet::Builder { public: ~Struct_FixedEnum_Field_() override = default; Struct_FixedEnum_Field_() = default; - explicit Struct_FixedEnum_Field_(uint64_t b) : b_(std::move(b)) {} Struct_FixedEnum_Field_(Struct_FixedEnum_Field_ const&) = default; Struct_FixedEnum_Field_(Struct_FixedEnum_Field_&&) = default; + explicit Struct_FixedEnum_Field_(uint64_t b) : b_(std::move(b)) {} Struct_FixedEnum_Field_& operator=(Struct_FixedEnum_Field_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_FixedEnum_Field_* output) { @@ -4859,7 +5508,9 @@ class Struct_FixedEnum_FieldView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_FixedEnum_Field_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -4898,6 +5549,7 @@ class Struct_ScalarGroup_Field_ : public pdl::packet::Builder { Struct_ScalarGroup_Field_() = default; Struct_ScalarGroup_Field_(Struct_ScalarGroup_Field_ const&) = default; Struct_ScalarGroup_Field_(Struct_ScalarGroup_Field_&&) = default; + Struct_ScalarGroup_Field_& operator=(Struct_ScalarGroup_Field_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_ScalarGroup_Field_* output) { @@ -4953,7 +5605,9 @@ class Struct_ScalarGroup_FieldView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_ScalarGroup_Field_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -4992,6 +5646,7 @@ class Struct_EnumGroup_Field_ : public pdl::packet::Builder { Struct_EnumGroup_Field_() = default; Struct_EnumGroup_Field_(Struct_EnumGroup_Field_ const&) = default; Struct_EnumGroup_Field_(Struct_EnumGroup_Field_&&) = default; + Struct_EnumGroup_Field_& operator=(Struct_EnumGroup_Field_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_EnumGroup_Field_* output) { @@ -5047,7 +5702,9 @@ class Struct_EnumGroup_FieldView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_EnumGroup_Field_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -5111,7 +5768,9 @@ class Struct_Struct_FieldView { pdl::packet::slice span = parent; if (!SizedStruct::Parse(span, &a_)) return false; if (!UnsizedStruct::Parse(span, &b_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -5151,15 +5810,17 @@ class Struct_Array_Field_ByteElement_ConstantSize_ : public pdl::packet::Builder public: ~Struct_Array_Field_ByteElement_ConstantSize_() override = default; Struct_Array_Field_ByteElement_ConstantSize_() = default; - explicit Struct_Array_Field_ByteElement_ConstantSize_(std::array array) : array_(std::move(array)) {} Struct_Array_Field_ByteElement_ConstantSize_(Struct_Array_Field_ByteElement_ConstantSize_ const&) = default; Struct_Array_Field_ByteElement_ConstantSize_(Struct_Array_Field_ByteElement_ConstantSize_&&) = default; + explicit Struct_Array_Field_ByteElement_ConstantSize_(std::array array) : array_(std::move(array)) {} Struct_Array_Field_ByteElement_ConstantSize_& operator=(Struct_Array_Field_ByteElement_ConstantSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ByteElement_ConstantSize_* output) { pdl::packet::slice span = parent_span; - for (int n = 0; n < 4; n++) { - if (span.size() < 1) return false; + if (span.size() < 4) { + return false; + } + for (size_t n = 0; n < 4; n++) { output->array_[n] = span.read_le(); } parent_span = span; @@ -5209,7 +5870,9 @@ class Struct_Array_Field_ByteElement_ConstantSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_ByteElement_ConstantSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -5246,9 +5909,9 @@ class Struct_Array_Field_ByteElement_VariableSize_ : public pdl::packet::Builder public: ~Struct_Array_Field_ByteElement_VariableSize_() override = default; Struct_Array_Field_ByteElement_VariableSize_() = default; - explicit Struct_Array_Field_ByteElement_VariableSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_ByteElement_VariableSize_(Struct_Array_Field_ByteElement_VariableSize_ const&) = default; Struct_Array_Field_ByteElement_VariableSize_(Struct_Array_Field_ByteElement_VariableSize_&&) = default; + explicit Struct_Array_Field_ByteElement_VariableSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_ByteElement_VariableSize_& operator=(Struct_Array_Field_ByteElement_VariableSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ByteElement_VariableSize_* output) { @@ -5258,11 +5921,14 @@ class Struct_Array_Field_ByteElement_VariableSize_ : public pdl::packet::Builder } uint8_t chunk0 = span.read_le(); output->array_size_ = (chunk0 >> 0) & 0xf; - if (span.size() < output->array_size_) return false; - if ((output->array_size_ % 1) != 0) return false; - size_t limit = span.size() - output->array_size_; - while (span.size() > limit) { - if (span.size() < 1) return false; + if (span.size() < output->array_size_) { + return false; + } + if ((output->array_size_ % 1) != 0) { + return false; + } + auto array_count_ = output->array_size_ / 1; + for (size_t n = 0; n < array_count_; n++) { output->array_.push_back(span.read_le()); } parent_span = span; @@ -5315,7 +5981,9 @@ class Struct_Array_Field_ByteElement_VariableSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_ByteElement_VariableSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -5352,9 +6020,9 @@ class Struct_Array_Field_ByteElement_VariableCount_ : public pdl::packet::Builde public: ~Struct_Array_Field_ByteElement_VariableCount_() override = default; Struct_Array_Field_ByteElement_VariableCount_() = default; - explicit Struct_Array_Field_ByteElement_VariableCount_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_ByteElement_VariableCount_(Struct_Array_Field_ByteElement_VariableCount_ const&) = default; Struct_Array_Field_ByteElement_VariableCount_(Struct_Array_Field_ByteElement_VariableCount_&&) = default; + explicit Struct_Array_Field_ByteElement_VariableCount_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_ByteElement_VariableCount_& operator=(Struct_Array_Field_ByteElement_VariableCount_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ByteElement_VariableCount_* output) { @@ -5364,8 +6032,10 @@ class Struct_Array_Field_ByteElement_VariableCount_ : public pdl::packet::Builde } uint8_t chunk0 = span.read_le(); output->array_count_ = (chunk0 >> 0) & 0xf; + if (span.size() < 1 * output->array_count_) { + return false; + } for (size_t n = 0; n < output->array_count_; n++) { - if (span.size() < 1) return false; output->array_.push_back(span.read_le()); } parent_span = span; @@ -5417,7 +6087,9 @@ class Struct_Array_Field_ByteElement_VariableCountView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_ByteElement_VariableCount_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -5454,15 +6126,18 @@ class Struct_Array_Field_ByteElement_UnknownSize_ : public pdl::packet::Builder public: ~Struct_Array_Field_ByteElement_UnknownSize_() override = default; Struct_Array_Field_ByteElement_UnknownSize_() = default; - explicit Struct_Array_Field_ByteElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_ByteElement_UnknownSize_(Struct_Array_Field_ByteElement_UnknownSize_ const&) = default; Struct_Array_Field_ByteElement_UnknownSize_(Struct_Array_Field_ByteElement_UnknownSize_&&) = default; + explicit Struct_Array_Field_ByteElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_ByteElement_UnknownSize_& operator=(Struct_Array_Field_ByteElement_UnknownSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ByteElement_UnknownSize_* output) { pdl::packet::slice span = parent_span; - while (span.size() > 0) { - if (span.size() < 1) return false; + if ((span.size() % 1) != 0) { + return false; + } + auto array_count_ = span.size() / 1; + for (size_t n = 0; n < array_count_; n++) { output->array_.push_back(span.read_le()); } parent_span = span; @@ -5512,7 +6187,9 @@ class Struct_Array_Field_ByteElement_UnknownSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_ByteElement_UnknownSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -5549,15 +6226,17 @@ class Struct_Array_Field_ScalarElement_ConstantSize_ : public pdl::packet::Build public: ~Struct_Array_Field_ScalarElement_ConstantSize_() override = default; Struct_Array_Field_ScalarElement_ConstantSize_() = default; - explicit Struct_Array_Field_ScalarElement_ConstantSize_(std::array array) : array_(std::move(array)) {} Struct_Array_Field_ScalarElement_ConstantSize_(Struct_Array_Field_ScalarElement_ConstantSize_ const&) = default; Struct_Array_Field_ScalarElement_ConstantSize_(Struct_Array_Field_ScalarElement_ConstantSize_&&) = default; + explicit Struct_Array_Field_ScalarElement_ConstantSize_(std::array array) : array_(std::move(array)) {} Struct_Array_Field_ScalarElement_ConstantSize_& operator=(Struct_Array_Field_ScalarElement_ConstantSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ScalarElement_ConstantSize_* output) { pdl::packet::slice span = parent_span; - for (int n = 0; n < 4; n++) { - if (span.size() < 2) return false; + if (span.size() < 8) { + return false; + } + for (size_t n = 0; n < 4; n++) { output->array_[n] = span.read_le(); } parent_span = span; @@ -5607,7 +6286,9 @@ class Struct_Array_Field_ScalarElement_ConstantSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_ScalarElement_ConstantSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -5644,9 +6325,9 @@ class Struct_Array_Field_ScalarElement_VariableSize_ : public pdl::packet::Build public: ~Struct_Array_Field_ScalarElement_VariableSize_() override = default; Struct_Array_Field_ScalarElement_VariableSize_() = default; - explicit Struct_Array_Field_ScalarElement_VariableSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_ScalarElement_VariableSize_(Struct_Array_Field_ScalarElement_VariableSize_ const&) = default; Struct_Array_Field_ScalarElement_VariableSize_(Struct_Array_Field_ScalarElement_VariableSize_&&) = default; + explicit Struct_Array_Field_ScalarElement_VariableSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_ScalarElement_VariableSize_& operator=(Struct_Array_Field_ScalarElement_VariableSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ScalarElement_VariableSize_* output) { @@ -5656,11 +6337,14 @@ class Struct_Array_Field_ScalarElement_VariableSize_ : public pdl::packet::Build } uint8_t chunk0 = span.read_le(); output->array_size_ = (chunk0 >> 0) & 0xf; - if (span.size() < output->array_size_) return false; - if ((output->array_size_ % 2) != 0) return false; - size_t limit = span.size() - output->array_size_; - while (span.size() > limit) { - if (span.size() < 2) return false; + if (span.size() < output->array_size_) { + return false; + } + if ((output->array_size_ % 2) != 0) { + return false; + } + auto array_count_ = output->array_size_ / 2; + for (size_t n = 0; n < array_count_; n++) { output->array_.push_back(span.read_le()); } parent_span = span; @@ -5713,7 +6397,9 @@ class Struct_Array_Field_ScalarElement_VariableSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_ScalarElement_VariableSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -5750,9 +6436,9 @@ class Struct_Array_Field_ScalarElement_VariableCount_ : public pdl::packet::Buil public: ~Struct_Array_Field_ScalarElement_VariableCount_() override = default; Struct_Array_Field_ScalarElement_VariableCount_() = default; - explicit Struct_Array_Field_ScalarElement_VariableCount_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_ScalarElement_VariableCount_(Struct_Array_Field_ScalarElement_VariableCount_ const&) = default; Struct_Array_Field_ScalarElement_VariableCount_(Struct_Array_Field_ScalarElement_VariableCount_&&) = default; + explicit Struct_Array_Field_ScalarElement_VariableCount_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_ScalarElement_VariableCount_& operator=(Struct_Array_Field_ScalarElement_VariableCount_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ScalarElement_VariableCount_* output) { @@ -5762,8 +6448,10 @@ class Struct_Array_Field_ScalarElement_VariableCount_ : public pdl::packet::Buil } uint8_t chunk0 = span.read_le(); output->array_count_ = (chunk0 >> 0) & 0xf; + if (span.size() < 2 * output->array_count_) { + return false; + } for (size_t n = 0; n < output->array_count_; n++) { - if (span.size() < 2) return false; output->array_.push_back(span.read_le()); } parent_span = span; @@ -5815,7 +6503,9 @@ class Struct_Array_Field_ScalarElement_VariableCountView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_ScalarElement_VariableCount_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -5852,15 +6542,18 @@ class Struct_Array_Field_ScalarElement_UnknownSize_ : public pdl::packet::Builde public: ~Struct_Array_Field_ScalarElement_UnknownSize_() override = default; Struct_Array_Field_ScalarElement_UnknownSize_() = default; - explicit Struct_Array_Field_ScalarElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_ScalarElement_UnknownSize_(Struct_Array_Field_ScalarElement_UnknownSize_ const&) = default; Struct_Array_Field_ScalarElement_UnknownSize_(Struct_Array_Field_ScalarElement_UnknownSize_&&) = default; + explicit Struct_Array_Field_ScalarElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_ScalarElement_UnknownSize_& operator=(Struct_Array_Field_ScalarElement_UnknownSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ScalarElement_UnknownSize_* output) { pdl::packet::slice span = parent_span; - while (span.size() > 0) { - if (span.size() < 2) return false; + if ((span.size() % 2) != 0) { + return false; + } + auto array_count_ = span.size() / 2; + for (size_t n = 0; n < array_count_; n++) { output->array_.push_back(span.read_le()); } parent_span = span; @@ -5910,7 +6603,9 @@ class Struct_Array_Field_ScalarElement_UnknownSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_ScalarElement_UnknownSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -5947,16 +6642,22 @@ class Struct_Array_Field_EnumElement_ConstantSize_ : public pdl::packet::Builder public: ~Struct_Array_Field_EnumElement_ConstantSize_() override = default; Struct_Array_Field_EnumElement_ConstantSize_() = default; - explicit Struct_Array_Field_EnumElement_ConstantSize_(std::array array) : array_(std::move(array)) {} Struct_Array_Field_EnumElement_ConstantSize_(Struct_Array_Field_EnumElement_ConstantSize_ const&) = default; Struct_Array_Field_EnumElement_ConstantSize_(Struct_Array_Field_EnumElement_ConstantSize_&&) = default; + explicit Struct_Array_Field_EnumElement_ConstantSize_(std::array array) : array_(std::move(array)) {} Struct_Array_Field_EnumElement_ConstantSize_& operator=(Struct_Array_Field_EnumElement_ConstantSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_EnumElement_ConstantSize_* output) { pdl::packet::slice span = parent_span; - for (int n = 0; n < 4; n++) { - if (span.size() < 2) return false; - output->array_[n] = Enum16(span.read_le()); + if (span.size() < 8) { + return false; + } + for (size_t n = 0; n < 4; n++) { + auto raw_value = span.read_le(); + if (!IsValidEnum16(raw_value)) { + return false; + } + output->array_[n] = Enum16(raw_value); } parent_span = span; return true; @@ -6005,7 +6706,9 @@ class Struct_Array_Field_EnumElement_ConstantSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_EnumElement_ConstantSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -6042,9 +6745,9 @@ class Struct_Array_Field_EnumElement_VariableSize_ : public pdl::packet::Builder public: ~Struct_Array_Field_EnumElement_VariableSize_() override = default; Struct_Array_Field_EnumElement_VariableSize_() = default; - explicit Struct_Array_Field_EnumElement_VariableSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_EnumElement_VariableSize_(Struct_Array_Field_EnumElement_VariableSize_ const&) = default; Struct_Array_Field_EnumElement_VariableSize_(Struct_Array_Field_EnumElement_VariableSize_&&) = default; + explicit Struct_Array_Field_EnumElement_VariableSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_EnumElement_VariableSize_& operator=(Struct_Array_Field_EnumElement_VariableSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_EnumElement_VariableSize_* output) { @@ -6054,12 +6757,19 @@ class Struct_Array_Field_EnumElement_VariableSize_ : public pdl::packet::Builder } uint8_t chunk0 = span.read_le(); output->array_size_ = (chunk0 >> 0) & 0xf; - if (span.size() < output->array_size_) return false; - if ((output->array_size_ % 2) != 0) return false; - size_t limit = span.size() - output->array_size_; - while (span.size() > limit) { - if (span.size() < 2) return false; - output->array_.push_back(Enum16(span.read_le())); + if (span.size() < output->array_size_) { + return false; + } + if ((output->array_size_ % 2) != 0) { + return false; + } + auto array_count_ = output->array_size_ / 2; + for (size_t n = 0; n < array_count_; n++) { + auto raw_value = span.read_le(); + if (!IsValidEnum16(raw_value)) { + return false; + } + output->array_.push_back(Enum16(raw_value)); } parent_span = span; return true; @@ -6111,7 +6821,9 @@ class Struct_Array_Field_EnumElement_VariableSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_EnumElement_VariableSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -6148,9 +6860,9 @@ class Struct_Array_Field_EnumElement_VariableCount_ : public pdl::packet::Builde public: ~Struct_Array_Field_EnumElement_VariableCount_() override = default; Struct_Array_Field_EnumElement_VariableCount_() = default; - explicit Struct_Array_Field_EnumElement_VariableCount_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_EnumElement_VariableCount_(Struct_Array_Field_EnumElement_VariableCount_ const&) = default; Struct_Array_Field_EnumElement_VariableCount_(Struct_Array_Field_EnumElement_VariableCount_&&) = default; + explicit Struct_Array_Field_EnumElement_VariableCount_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_EnumElement_VariableCount_& operator=(Struct_Array_Field_EnumElement_VariableCount_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_EnumElement_VariableCount_* output) { @@ -6160,9 +6872,15 @@ class Struct_Array_Field_EnumElement_VariableCount_ : public pdl::packet::Builde } uint8_t chunk0 = span.read_le(); output->array_count_ = (chunk0 >> 0) & 0xf; + if (span.size() < 2 * output->array_count_) { + return false; + } for (size_t n = 0; n < output->array_count_; n++) { - if (span.size() < 2) return false; - output->array_.push_back(Enum16(span.read_le())); + auto raw_value = span.read_le(); + if (!IsValidEnum16(raw_value)) { + return false; + } + output->array_.push_back(Enum16(raw_value)); } parent_span = span; return true; @@ -6213,7 +6931,9 @@ class Struct_Array_Field_EnumElement_VariableCountView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_EnumElement_VariableCount_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -6250,16 +6970,23 @@ class Struct_Array_Field_EnumElement_UnknownSize_ : public pdl::packet::Builder public: ~Struct_Array_Field_EnumElement_UnknownSize_() override = default; Struct_Array_Field_EnumElement_UnknownSize_() = default; - explicit Struct_Array_Field_EnumElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_EnumElement_UnknownSize_(Struct_Array_Field_EnumElement_UnknownSize_ const&) = default; Struct_Array_Field_EnumElement_UnknownSize_(Struct_Array_Field_EnumElement_UnknownSize_&&) = default; + explicit Struct_Array_Field_EnumElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_EnumElement_UnknownSize_& operator=(Struct_Array_Field_EnumElement_UnknownSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_EnumElement_UnknownSize_* output) { pdl::packet::slice span = parent_span; - while (span.size() > 0) { - if (span.size() < 2) return false; - output->array_.push_back(Enum16(span.read_le())); + if ((span.size() % 2) != 0) { + return false; + } + auto array_count_ = span.size() / 2; + for (size_t n = 0; n < array_count_; n++) { + auto raw_value = span.read_le(); + if (!IsValidEnum16(raw_value)) { + return false; + } + output->array_.push_back(Enum16(raw_value)); } parent_span = span; return true; @@ -6308,7 +7035,9 @@ class Struct_Array_Field_EnumElement_UnknownSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_EnumElement_UnknownSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -6345,15 +7074,22 @@ class Struct_Array_Field_SizedElement_ConstantSize_ : public pdl::packet::Builde public: ~Struct_Array_Field_SizedElement_ConstantSize_() override = default; Struct_Array_Field_SizedElement_ConstantSize_() = default; - explicit Struct_Array_Field_SizedElement_ConstantSize_(std::array array) : array_(std::move(array)) {} Struct_Array_Field_SizedElement_ConstantSize_(Struct_Array_Field_SizedElement_ConstantSize_ const&) = default; Struct_Array_Field_SizedElement_ConstantSize_(Struct_Array_Field_SizedElement_ConstantSize_&&) = default; + explicit Struct_Array_Field_SizedElement_ConstantSize_(std::array array) : array_(std::move(array)) {} Struct_Array_Field_SizedElement_ConstantSize_& operator=(Struct_Array_Field_SizedElement_ConstantSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_SizedElement_ConstantSize_* output) { pdl::packet::slice span = parent_span; - for (int n = 0; n < 4; n++) { - if (!SizedStruct::Parse(span, &output->array_[n])) return false; + if (span.size() < 4) { + return false; + } + for (size_t n = 0; n < 4; n++) { + SizedStruct out; + if (!SizedStruct::Parse(span, &out)) { + return false; + } + output->array_[n] = out; } parent_span = span; return true; @@ -6402,7 +7138,9 @@ class Struct_Array_Field_SizedElement_ConstantSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_SizedElement_ConstantSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -6439,9 +7177,9 @@ class Struct_Array_Field_SizedElement_VariableSize_ : public pdl::packet::Builde public: ~Struct_Array_Field_SizedElement_VariableSize_() override = default; Struct_Array_Field_SizedElement_VariableSize_() = default; - explicit Struct_Array_Field_SizedElement_VariableSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_SizedElement_VariableSize_(Struct_Array_Field_SizedElement_VariableSize_ const&) = default; Struct_Array_Field_SizedElement_VariableSize_(Struct_Array_Field_SizedElement_VariableSize_&&) = default; + explicit Struct_Array_Field_SizedElement_VariableSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_SizedElement_VariableSize_& operator=(Struct_Array_Field_SizedElement_VariableSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_SizedElement_VariableSize_* output) { @@ -6451,13 +7189,19 @@ class Struct_Array_Field_SizedElement_VariableSize_ : public pdl::packet::Builde } uint8_t chunk0 = span.read_le(); output->array_size_ = (chunk0 >> 0) & 0xf; - if (span.size() < output->array_size_) return false; - if ((output->array_size_ % 1) != 0) return false; - size_t limit = span.size() - output->array_size_; - while (span.size() > limit) { - SizedStruct element; - if (!SizedStruct::Parse(span, &element)) return false; - output->array_.emplace_back(std::move(element)); + if (span.size() < output->array_size_) { + return false; + } + if ((output->array_size_ % 1) != 0) { + return false; + } + auto array_count_ = output->array_size_ / 1; + for (size_t n = 0; n < array_count_; n++) { + SizedStruct out; + if (!SizedStruct::Parse(span, &out)) { + return false; + } + output->array_.push_back(out); } parent_span = span; return true; @@ -6509,7 +7253,9 @@ class Struct_Array_Field_SizedElement_VariableSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_SizedElement_VariableSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -6546,9 +7292,9 @@ class Struct_Array_Field_SizedElement_VariableCount_ : public pdl::packet::Build public: ~Struct_Array_Field_SizedElement_VariableCount_() override = default; Struct_Array_Field_SizedElement_VariableCount_() = default; - explicit Struct_Array_Field_SizedElement_VariableCount_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_SizedElement_VariableCount_(Struct_Array_Field_SizedElement_VariableCount_ const&) = default; Struct_Array_Field_SizedElement_VariableCount_(Struct_Array_Field_SizedElement_VariableCount_&&) = default; + explicit Struct_Array_Field_SizedElement_VariableCount_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_SizedElement_VariableCount_& operator=(Struct_Array_Field_SizedElement_VariableCount_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_SizedElement_VariableCount_* output) { @@ -6558,10 +7304,15 @@ class Struct_Array_Field_SizedElement_VariableCount_ : public pdl::packet::Build } uint8_t chunk0 = span.read_le(); output->array_count_ = (chunk0 >> 0) & 0xf; + if (span.size() < 1 * output->array_count_) { + return false; + } for (size_t n = 0; n < output->array_count_; n++) { - SizedStruct element; - if (!SizedStruct::Parse(span, &element)) return false; - output->array_.emplace_back(std::move(element)); + SizedStruct out; + if (!SizedStruct::Parse(span, &out)) { + return false; + } + output->array_.push_back(out); } parent_span = span; return true; @@ -6612,7 +7363,9 @@ class Struct_Array_Field_SizedElement_VariableCountView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_SizedElement_VariableCount_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -6649,17 +7402,23 @@ class Struct_Array_Field_SizedElement_UnknownSize_ : public pdl::packet::Builder public: ~Struct_Array_Field_SizedElement_UnknownSize_() override = default; Struct_Array_Field_SizedElement_UnknownSize_() = default; - explicit Struct_Array_Field_SizedElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_SizedElement_UnknownSize_(Struct_Array_Field_SizedElement_UnknownSize_ const&) = default; Struct_Array_Field_SizedElement_UnknownSize_(Struct_Array_Field_SizedElement_UnknownSize_&&) = default; + explicit Struct_Array_Field_SizedElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_SizedElement_UnknownSize_& operator=(Struct_Array_Field_SizedElement_UnknownSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_SizedElement_UnknownSize_* output) { pdl::packet::slice span = parent_span; - while (span.size() > 0) { - SizedStruct element; - if (!SizedStruct::Parse(span, &element)) return false; - output->array_.emplace_back(std::move(element)); + if ((span.size() % 1) != 0) { + return false; + } + auto array_count_ = span.size() / 1; + for (size_t n = 0; n < array_count_; n++) { + SizedStruct out; + if (!SizedStruct::Parse(span, &out)) { + return false; + } + output->array_.push_back(out); } parent_span = span; return true; @@ -6708,7 +7467,9 @@ class Struct_Array_Field_SizedElement_UnknownSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_SizedElement_UnknownSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -6745,15 +7506,19 @@ class Struct_Array_Field_UnsizedElement_ConstantSize_ : public pdl::packet::Buil public: ~Struct_Array_Field_UnsizedElement_ConstantSize_() override = default; Struct_Array_Field_UnsizedElement_ConstantSize_() = default; - explicit Struct_Array_Field_UnsizedElement_ConstantSize_(std::array array) : array_(std::move(array)) {} Struct_Array_Field_UnsizedElement_ConstantSize_(Struct_Array_Field_UnsizedElement_ConstantSize_ const&) = default; Struct_Array_Field_UnsizedElement_ConstantSize_(Struct_Array_Field_UnsizedElement_ConstantSize_&&) = default; + explicit Struct_Array_Field_UnsizedElement_ConstantSize_(std::array array) : array_(std::move(array)) {} Struct_Array_Field_UnsizedElement_ConstantSize_& operator=(Struct_Array_Field_UnsizedElement_ConstantSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_UnsizedElement_ConstantSize_* output) { pdl::packet::slice span = parent_span; - for (int n = 0; n < 4; n++) { - if (!UnsizedStruct::Parse(span, &output->array_[n])) return false; + for (size_t n = 0; n < 4; n++) { + UnsizedStruct out; + if (!UnsizedStruct::Parse(span, &out)) { + return false; + } + output->array_[n] = std::move(out); } parent_span = span; return true; @@ -6802,7 +7567,9 @@ class Struct_Array_Field_UnsizedElement_ConstantSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_UnsizedElement_ConstantSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -6839,9 +7606,9 @@ class Struct_Array_Field_UnsizedElement_VariableSize_ : public pdl::packet::Buil public: ~Struct_Array_Field_UnsizedElement_VariableSize_() override = default; Struct_Array_Field_UnsizedElement_VariableSize_() = default; - explicit Struct_Array_Field_UnsizedElement_VariableSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_UnsizedElement_VariableSize_(Struct_Array_Field_UnsizedElement_VariableSize_ const&) = default; Struct_Array_Field_UnsizedElement_VariableSize_(Struct_Array_Field_UnsizedElement_VariableSize_&&) = default; + explicit Struct_Array_Field_UnsizedElement_VariableSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_UnsizedElement_VariableSize_& operator=(Struct_Array_Field_UnsizedElement_VariableSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_UnsizedElement_VariableSize_* output) { @@ -6851,13 +7618,18 @@ class Struct_Array_Field_UnsizedElement_VariableSize_ : public pdl::packet::Buil } uint8_t chunk0 = span.read_le(); output->array_size_ = (chunk0 >> 0) & 0xf; - if (span.size() < output->array_size_) return false; - size_t limit = span.size() - output->array_size_; - while (span.size() > limit) { - UnsizedStruct element; - if (!UnsizedStruct::Parse(span, &element)) return false; - output->array_.emplace_back(std::move(element)); + if (span.size() < output->array_size_) { + return false; } + auto array_span = span.subrange(0, output->array_size_); + while (array_span.size() > 0) { + UnsizedStruct out; + if (!UnsizedStruct::Parse(array_span, &out)) { + return false; + } + output->array_.push_back(std::move(out)); + } + span.skip(output->array_size_); parent_span = span; return true; } @@ -6908,7 +7680,9 @@ class Struct_Array_Field_UnsizedElement_VariableSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_UnsizedElement_VariableSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -6945,9 +7719,9 @@ class Struct_Array_Field_UnsizedElement_VariableCount_ : public pdl::packet::Bui public: ~Struct_Array_Field_UnsizedElement_VariableCount_() override = default; Struct_Array_Field_UnsizedElement_VariableCount_() = default; - explicit Struct_Array_Field_UnsizedElement_VariableCount_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_UnsizedElement_VariableCount_(Struct_Array_Field_UnsizedElement_VariableCount_ const&) = default; Struct_Array_Field_UnsizedElement_VariableCount_(Struct_Array_Field_UnsizedElement_VariableCount_&&) = default; + explicit Struct_Array_Field_UnsizedElement_VariableCount_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_UnsizedElement_VariableCount_& operator=(Struct_Array_Field_UnsizedElement_VariableCount_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_UnsizedElement_VariableCount_* output) { @@ -6958,9 +7732,11 @@ class Struct_Array_Field_UnsizedElement_VariableCount_ : public pdl::packet::Bui uint8_t chunk0 = span.read_le(); output->array_count_ = (chunk0 >> 0) & 0xf; for (size_t n = 0; n < output->array_count_; n++) { - UnsizedStruct element; - if (!UnsizedStruct::Parse(span, &element)) return false; - output->array_.emplace_back(std::move(element)); + UnsizedStruct out; + if (!UnsizedStruct::Parse(span, &out)) { + return false; + } + output->array_.push_back(std::move(out)); } parent_span = span; return true; @@ -7011,7 +7787,9 @@ class Struct_Array_Field_UnsizedElement_VariableCountView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_UnsizedElement_VariableCount_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -7048,17 +7826,19 @@ class Struct_Array_Field_UnsizedElement_UnknownSize_ : public pdl::packet::Build public: ~Struct_Array_Field_UnsizedElement_UnknownSize_() override = default; Struct_Array_Field_UnsizedElement_UnknownSize_() = default; - explicit Struct_Array_Field_UnsizedElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_UnsizedElement_UnknownSize_(Struct_Array_Field_UnsizedElement_UnknownSize_ const&) = default; Struct_Array_Field_UnsizedElement_UnknownSize_(Struct_Array_Field_UnsizedElement_UnknownSize_&&) = default; + explicit Struct_Array_Field_UnsizedElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_UnsizedElement_UnknownSize_& operator=(Struct_Array_Field_UnsizedElement_UnknownSize_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_UnsizedElement_UnknownSize_* output) { pdl::packet::slice span = parent_span; while (span.size() > 0) { - UnsizedStruct element; - if (!UnsizedStruct::Parse(span, &element)) return false; - output->array_.emplace_back(std::move(element)); + UnsizedStruct out; + if (!UnsizedStruct::Parse(span, &out)) { + return false; + } + output->array_.push_back(std::move(out)); } parent_span = span; return true; @@ -7107,7 +7887,9 @@ class Struct_Array_Field_UnsizedElement_UnknownSizeView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_UnsizedElement_UnknownSize_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -7144,9 +7926,9 @@ class Struct_Array_Field_UnsizedElement_SizeModifier_ : public pdl::packet::Buil public: ~Struct_Array_Field_UnsizedElement_SizeModifier_() override = default; Struct_Array_Field_UnsizedElement_SizeModifier_() = default; - explicit Struct_Array_Field_UnsizedElement_SizeModifier_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_UnsizedElement_SizeModifier_(Struct_Array_Field_UnsizedElement_SizeModifier_ const&) = default; Struct_Array_Field_UnsizedElement_SizeModifier_(Struct_Array_Field_UnsizedElement_SizeModifier_&&) = default; + explicit Struct_Array_Field_UnsizedElement_SizeModifier_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_UnsizedElement_SizeModifier_& operator=(Struct_Array_Field_UnsizedElement_SizeModifier_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_UnsizedElement_SizeModifier_* output) { @@ -7156,13 +7938,19 @@ class Struct_Array_Field_UnsizedElement_SizeModifier_ : public pdl::packet::Buil } uint8_t chunk0 = span.read_le(); output->array_size_ = (chunk0 >> 0) & 0xf; - if (span.size() < (output->array_size_ - 2)) return false; - size_t limit = span.size() - (output->array_size_ - 2); - while (span.size() > limit) { - UnsizedStruct element; - if (!UnsizedStruct::Parse(span, &element)) return false; - output->array_.emplace_back(std::move(element)); + output->array_size_ = output->array_size_ - +2; + if (span.size() < output->array_size_) { + return false; + } + auto array_span = span.subrange(0, output->array_size_); + while (array_span.size() > 0) { + UnsizedStruct out; + if (!UnsizedStruct::Parse(array_span, &out)) { + return false; + } + output->array_.push_back(std::move(out)); } + span.skip(output->array_size_); parent_span = span; return true; } @@ -7213,7 +8001,9 @@ class Struct_Array_Field_UnsizedElement_SizeModifierView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_UnsizedElement_SizeModifier_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -7250,9 +8040,9 @@ class Struct_Array_Field_SizedElement_VariableSize_Padded_ : public pdl::packet: public: ~Struct_Array_Field_SizedElement_VariableSize_Padded_() override = default; Struct_Array_Field_SizedElement_VariableSize_Padded_() = default; - explicit Struct_Array_Field_SizedElement_VariableSize_Padded_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_SizedElement_VariableSize_Padded_(Struct_Array_Field_SizedElement_VariableSize_Padded_ const&) = default; Struct_Array_Field_SizedElement_VariableSize_Padded_(Struct_Array_Field_SizedElement_VariableSize_Padded_&&) = default; + explicit Struct_Array_Field_SizedElement_VariableSize_Padded_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_SizedElement_VariableSize_Padded_& operator=(Struct_Array_Field_SizedElement_VariableSize_Padded_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_SizedElement_VariableSize_Padded_* output) { @@ -7263,11 +8053,14 @@ class Struct_Array_Field_SizedElement_VariableSize_Padded_ : public pdl::packet: uint8_t chunk0 = span.read_le(); output->array_size_ = (chunk0 >> 0) & 0xf; size_t array_start_size = span.size(); - if (span.size() < output->array_size_) return false; - if ((output->array_size_ % 2) != 0) return false; - size_t limit = span.size() - output->array_size_; - while (span.size() > limit) { - if (span.size() < 2) return false; + if (span.size() < output->array_size_) { + return false; + } + if ((output->array_size_ % 2) != 0) { + return false; + } + auto array_count_ = output->array_size_ / 2; + for (size_t n = 0; n < array_count_; n++) { output->array_.push_back(span.read_le()); } if (array_start_size - span.size() < 16) { @@ -7328,7 +8121,9 @@ class Struct_Array_Field_SizedElement_VariableSize_PaddedView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_SizedElement_VariableSize_Padded_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -7365,9 +8160,9 @@ class Struct_Array_Field_UnsizedElement_VariableCount_Padded_ : public pdl::pack public: ~Struct_Array_Field_UnsizedElement_VariableCount_Padded_() override = default; Struct_Array_Field_UnsizedElement_VariableCount_Padded_() = default; - explicit Struct_Array_Field_UnsizedElement_VariableCount_Padded_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_UnsizedElement_VariableCount_Padded_(Struct_Array_Field_UnsizedElement_VariableCount_Padded_ const&) = default; Struct_Array_Field_UnsizedElement_VariableCount_Padded_(Struct_Array_Field_UnsizedElement_VariableCount_Padded_&&) = default; + explicit Struct_Array_Field_UnsizedElement_VariableCount_Padded_(std::vector array) : array_(std::move(array)) {} Struct_Array_Field_UnsizedElement_VariableCount_Padded_& operator=(Struct_Array_Field_UnsizedElement_VariableCount_Padded_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_UnsizedElement_VariableCount_Padded_* output) { @@ -7378,9 +8173,11 @@ class Struct_Array_Field_UnsizedElement_VariableCount_Padded_ : public pdl::pack output->array_count_ = span.read_le(); size_t array_start_size = span.size(); for (size_t n = 0; n < output->array_count_; n++) { - UnsizedStruct element; - if (!UnsizedStruct::Parse(span, &element)) return false; - output->array_.emplace_back(std::move(element)); + UnsizedStruct out; + if (!UnsizedStruct::Parse(span, &out)) { + return false; + } + output->array_.push_back(std::move(out)); } if (array_start_size - span.size() < 16) { if (span.size() < 16 - (array_start_size - span.size())) return false; @@ -7439,7 +8236,9 @@ class Struct_Array_Field_UnsizedElement_VariableCount_PaddedView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Array_Field_UnsizedElement_VariableCount_Padded_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -7476,9 +8275,9 @@ class Struct_Optional_Scalar_Field_ : public pdl::packet::Builder { public: ~Struct_Optional_Scalar_Field_() override = default; Struct_Optional_Scalar_Field_() = default; - explicit Struct_Optional_Scalar_Field_(std::optional a, std::optional b) : a_(std::move(a)), b_(std::move(b)) {} Struct_Optional_Scalar_Field_(Struct_Optional_Scalar_Field_ const&) = default; Struct_Optional_Scalar_Field_(Struct_Optional_Scalar_Field_&&) = default; + explicit Struct_Optional_Scalar_Field_(std::optional a, std::optional b) : a_(std::move(a)), b_(std::move(b)) {} Struct_Optional_Scalar_Field_& operator=(Struct_Optional_Scalar_Field_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Optional_Scalar_Field_* output) { @@ -7553,7 +8352,9 @@ class Struct_Optional_Scalar_FieldView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Optional_Scalar_Field_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -7590,9 +8391,9 @@ class Struct_Optional_Enum_Field_ : public pdl::packet::Builder { public: ~Struct_Optional_Enum_Field_() override = default; Struct_Optional_Enum_Field_() = default; - explicit Struct_Optional_Enum_Field_(std::optional a, std::optional b) : a_(std::move(a)), b_(std::move(b)) {} Struct_Optional_Enum_Field_(Struct_Optional_Enum_Field_ const&) = default; Struct_Optional_Enum_Field_(Struct_Optional_Enum_Field_&&) = default; + explicit Struct_Optional_Enum_Field_(std::optional a, std::optional b) : a_(std::move(a)), b_(std::move(b)) {} Struct_Optional_Enum_Field_& operator=(Struct_Optional_Enum_Field_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Optional_Enum_Field_* output) { @@ -7607,15 +8408,21 @@ class Struct_Optional_Enum_Field_ : public pdl::packet::Builder { if (span.size() < 2) { return false; } - output->a_ = static_cast(span.read_le()); - if (!IsEnum16Valid(output->a_.value())) return false; + auto raw_value = span.read_le(); + if (!IsValidEnum16(raw_value)) { + return false; + } + output->a_ = Enum16(raw_value); } if (c1 == 1) { if (span.size() < 2) { return false; } - output->b_ = static_cast(span.read_le()); - if (!IsEnum16Valid(output->b_.value())) return false; + auto raw_value = span.read_le(); + if (!IsValidEnum16(raw_value)) { + return false; + } + output->b_ = Enum16(raw_value); } parent_span = span; return true; @@ -7669,7 +8476,9 @@ class Struct_Optional_Enum_FieldView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Optional_Enum_Field_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -7706,9 +8515,9 @@ class Struct_Optional_Struct_Field_ : public pdl::packet::Builder { public: ~Struct_Optional_Struct_Field_() override = default; Struct_Optional_Struct_Field_() = default; - explicit Struct_Optional_Struct_Field_(std::optional a, std::optional b) : a_(std::move(a)), b_(std::move(b)) {} Struct_Optional_Struct_Field_(Struct_Optional_Struct_Field_ const&) = default; Struct_Optional_Struct_Field_(Struct_Optional_Struct_Field_&&) = default; + explicit Struct_Optional_Struct_Field_(std::optional a, std::optional b) : a_(std::move(a)), b_(std::move(b)) {} Struct_Optional_Struct_Field_& operator=(Struct_Optional_Struct_Field_ const&) = default; static bool Parse(pdl::packet::slice& parent_span, Struct_Optional_Struct_Field_* output) { @@ -7783,7 +8592,9 @@ class Struct_Optional_Struct_FieldView { // Parse packet field values. pdl::packet::slice span = parent; if (!Struct_Optional_Struct_Field_::Parse(span, &s_)) return false; - if (span.size() != 0) { return false; } + if (span.size() > 0) { + return false; + } return true; } @@ -7831,8 +8642,14 @@ inline std::string Enum_Incomplete_Truncated_Closed_Text(Enum_Incomplete_Truncat } } -inline bool IsEnum_Incomplete_Truncated_Closed_Valid(Enum_Incomplete_Truncated_Closed_ tag) { - return tag == Enum_Incomplete_Truncated_Closed_::A || tag == Enum_Incomplete_Truncated_Closed_::B; +inline bool IsValidEnum_Incomplete_Truncated_Closed_(uint8_t value) { + switch (value) { + case 0x0: + case 0x1: + return true; + default: + return false; + } } class Enum_Incomplete_Truncated_ClosedView { @@ -7866,9 +8683,14 @@ class Enum_Incomplete_Truncated_ClosedView { return false; } uint8_t chunk0 = span.read_le(); - e_ = static_cast( (chunk0 >> 0) & 0x7 ); - if (!IsEnum_Incomplete_Truncated_Closed_Valid(e_)) return false; - if (span.size() != 0) { return false; } + auto raw_value = (chunk0 >> 0) & 0x7; + if (!IsValidEnum_Incomplete_Truncated_Closed_(raw_value)) { + return false; + } + e_ = Enum_Incomplete_Truncated_Closed_(raw_value); + if (span.size() > 0) { + return false; + } return true; } @@ -7916,8 +8738,6 @@ inline std::string Enum_Incomplete_Truncated_Open_Text(Enum_Incomplete_Truncated } } -inline bool IsEnum_Incomplete_Truncated_Open_Valid(Enum_Incomplete_Truncated_Open_ /* tag */) { return true; } - class Enum_Incomplete_Truncated_OpenView { public: static Enum_Incomplete_Truncated_OpenView Create(pdl::packet::slice const& parent) { @@ -7949,9 +8769,10 @@ class Enum_Incomplete_Truncated_OpenView { return false; } uint8_t chunk0 = span.read_le(); - e_ = static_cast( (chunk0 >> 0) & 0x7 ); - if (!IsEnum_Incomplete_Truncated_Open_Valid(e_)) return false; - if (span.size() != 0) { return false; } + e_ = Enum_Incomplete_Truncated_Open_((chunk0 >> 0) & 0x7); + if (span.size() > 0) { + return false; + } return true; } @@ -7986,23 +8807,20 @@ class Enum_Incomplete_Truncated_OpenBuilder : public pdl::packet::Builder { enum class Enum_Incomplete_Truncated_Closed_WithRange_ : uint8_t { A = 0x0, - X = 0x1, - Y = 0x2, }; inline std::string Enum_Incomplete_Truncated_Closed_WithRange_Text(Enum_Incomplete_Truncated_Closed_WithRange_ tag) { switch (tag) { case Enum_Incomplete_Truncated_Closed_WithRange_::A: return "A"; - case Enum_Incomplete_Truncated_Closed_WithRange_::X: return "X"; - case Enum_Incomplete_Truncated_Closed_WithRange_::Y: return "Y"; default: return std::string("Unknown Enum_Incomplete_Truncated_Closed_WithRange_: " + std::to_string(static_cast(tag))); } } -inline bool IsEnum_Incomplete_Truncated_Closed_WithRange_Valid(Enum_Incomplete_Truncated_Closed_WithRange_ tag) { - return tag == Enum_Incomplete_Truncated_Closed_WithRange_::A || (static_cast(tag) >= 0x1 && static_cast(tag) <= 0x6); +inline bool IsValidEnum_Incomplete_Truncated_Closed_WithRange_(uint8_t value) { + return value == 0x0 + || (0x1 <= value && value <= 0x6); } class Enum_Incomplete_Truncated_Closed_WithRangeView { @@ -8036,9 +8854,14 @@ class Enum_Incomplete_Truncated_Closed_WithRangeView { return false; } uint8_t chunk0 = span.read_le(); - e_ = static_cast( (chunk0 >> 0) & 0x7 ); - if (!IsEnum_Incomplete_Truncated_Closed_WithRange_Valid(e_)) return false; - if (span.size() != 0) { return false; } + auto raw_value = (chunk0 >> 0) & 0x7; + if (!IsValidEnum_Incomplete_Truncated_Closed_WithRange_(raw_value)) { + return false; + } + e_ = Enum_Incomplete_Truncated_Closed_WithRange_(raw_value); + if (span.size() > 0) { + return false; + } return true; } @@ -8073,23 +8896,17 @@ class Enum_Incomplete_Truncated_Closed_WithRangeBuilder : public pdl::packet::Bu enum class Enum_Incomplete_Truncated_Open_WithRange_ : uint8_t { A = 0x0, - X = 0x1, - Y = 0x2, }; inline std::string Enum_Incomplete_Truncated_Open_WithRange_Text(Enum_Incomplete_Truncated_Open_WithRange_ tag) { switch (tag) { case Enum_Incomplete_Truncated_Open_WithRange_::A: return "A"; - case Enum_Incomplete_Truncated_Open_WithRange_::X: return "X"; - case Enum_Incomplete_Truncated_Open_WithRange_::Y: return "Y"; default: return std::string("Unknown Enum_Incomplete_Truncated_Open_WithRange_: " + std::to_string(static_cast(tag))); } } -inline bool IsEnum_Incomplete_Truncated_Open_WithRange_Valid(Enum_Incomplete_Truncated_Open_WithRange_ /* tag */) { return true; } - class Enum_Incomplete_Truncated_Open_WithRangeView { public: static Enum_Incomplete_Truncated_Open_WithRangeView Create(pdl::packet::slice const& parent) { @@ -8121,9 +8938,10 @@ class Enum_Incomplete_Truncated_Open_WithRangeView { return false; } uint8_t chunk0 = span.read_le(); - e_ = static_cast( (chunk0 >> 0) & 0x7 ); - if (!IsEnum_Incomplete_Truncated_Open_WithRange_Valid(e_)) return false; - if (span.size() != 0) { return false; } + e_ = Enum_Incomplete_Truncated_Open_WithRange_((chunk0 >> 0) & 0x7); + if (span.size() > 0) { + return false; + } return true; } @@ -8183,8 +9001,20 @@ inline std::string Enum_Complete_Truncated_Text(Enum_Complete_Truncated_ tag) { } } -inline bool IsEnum_Complete_Truncated_Valid(Enum_Complete_Truncated_ tag) { - return tag == Enum_Complete_Truncated_::A || tag == Enum_Complete_Truncated_::B || tag == Enum_Complete_Truncated_::C || tag == Enum_Complete_Truncated_::D || tag == Enum_Complete_Truncated_::E || tag == Enum_Complete_Truncated_::F || tag == Enum_Complete_Truncated_::G || tag == Enum_Complete_Truncated_::H; +inline bool IsValidEnum_Complete_Truncated_(uint8_t value) { + switch (value) { + case 0x0: + case 0x1: + case 0x2: + case 0x3: + case 0x4: + case 0x5: + case 0x6: + case 0x7: + return true; + default: + return false; + } } class Enum_Complete_TruncatedView { @@ -8218,9 +9048,14 @@ class Enum_Complete_TruncatedView { return false; } uint8_t chunk0 = span.read_le(); - e_ = static_cast( (chunk0 >> 0) & 0x7 ); - if (!IsEnum_Complete_Truncated_Valid(e_)) return false; - if (span.size() != 0) { return false; } + auto raw_value = (chunk0 >> 0) & 0x7; + if (!IsValidEnum_Complete_Truncated_(raw_value)) { + return false; + } + e_ = Enum_Complete_Truncated_(raw_value); + if (span.size() > 0) { + return false; + } return true; } @@ -8255,23 +9090,20 @@ class Enum_Complete_TruncatedBuilder : public pdl::packet::Builder { enum class Enum_Complete_Truncated_WithRange_ : uint8_t { A = 0x0, - X = 0x1, - Y = 0x2, }; inline std::string Enum_Complete_Truncated_WithRange_Text(Enum_Complete_Truncated_WithRange_ tag) { switch (tag) { case Enum_Complete_Truncated_WithRange_::A: return "A"; - case Enum_Complete_Truncated_WithRange_::X: return "X"; - case Enum_Complete_Truncated_WithRange_::Y: return "Y"; default: return std::string("Unknown Enum_Complete_Truncated_WithRange_: " + std::to_string(static_cast(tag))); } } -inline bool IsEnum_Complete_Truncated_WithRange_Valid(Enum_Complete_Truncated_WithRange_ tag) { - return tag == Enum_Complete_Truncated_WithRange_::A || (static_cast(tag) >= 0x1 && static_cast(tag) <= 0x7); +inline bool IsValidEnum_Complete_Truncated_WithRange_(uint8_t value) { + return value == 0x0 + || (0x1 <= value && value <= 0x7); } class Enum_Complete_Truncated_WithRangeView { @@ -8305,9 +9137,14 @@ class Enum_Complete_Truncated_WithRangeView { return false; } uint8_t chunk0 = span.read_le(); - e_ = static_cast( (chunk0 >> 0) & 0x7 ); - if (!IsEnum_Complete_Truncated_WithRange_Valid(e_)) return false; - if (span.size() != 0) { return false; } + auto raw_value = (chunk0 >> 0) & 0x7; + if (!IsValidEnum_Complete_Truncated_WithRange_(raw_value)) { + return false; + } + e_ = Enum_Complete_Truncated_WithRange_(raw_value); + if (span.size() > 0) { + return false; + } return true; } @@ -8355,8 +9192,10 @@ inline std::string Enum_Complete_WithRange_Text(Enum_Complete_WithRange_ tag) { } } -inline bool IsEnum_Complete_WithRange_Valid(Enum_Complete_WithRange_ tag) { - return tag == Enum_Complete_WithRange_::A || tag == Enum_Complete_WithRange_::B || (static_cast(tag) >= 0x2 && static_cast(tag) <= 0xff); +inline bool IsValidEnum_Complete_WithRange_(uint8_t value) { + return value == 0x0 + || value == 0x1 + || (0x2 <= value && value <= 0xff); } class Enum_Complete_WithRangeView { @@ -8389,9 +9228,14 @@ class Enum_Complete_WithRangeView { if (span.size() < 1) { return false; } - e_ = static_cast( span.read_le() ); - if (!IsEnum_Complete_WithRange_Valid(e_)) return false; - if (span.size() != 0) { return false; } + auto raw_value = span.read_le(); + if (!IsValidEnum_Complete_WithRange_(raw_value)) { + return false; + } + e_ = Enum_Complete_WithRange_(raw_value); + if (span.size() > 0) { + return false; + } return true; }