use crate::error::{Error, Result};
pub fn parse_field_descriptor(desc: &str) -> Result<String> {
let (ty, consumed) = parse_type(desc)?;
if consumed != desc.len() {
return Err(Error::InvalidClassFile(format!(
"trailing characters in field descriptor '{desc}'"
)));
}
Ok(ty)
}
pub fn parse_method_descriptor(desc: &str) -> Result<(Vec<String>, String)> {
let mut chars = desc.chars().peekable();
if chars.next() != Some('(') {
return Err(Error::InvalidClassFile(format!(
"method descriptor must start with '(': '{desc}'"
)));
}
let mut params = Vec::new();
loop {
match chars.peek() {
Some(')') => {
chars.next();
break;
}
None => {
return Err(Error::InvalidClassFile(format!(
"unterminated parameter list in '{desc}'"
)))
}
Some(_) => {
let rest: String = chars.clone().collect();
let (ty, consumed) = parse_type(&rest)?;
params.push(ty);
for _ in 0..consumed {
chars.next();
}
}
}
}
let ret_rest: String = chars.collect();
let (ret, consumed) = parse_type(&ret_rest)?;
if consumed != ret_rest.len() {
return Err(Error::InvalidClassFile(format!(
"trailing characters in method descriptor '{desc}'"
)));
}
Ok((params, ret))
}
fn parse_type(s: &str) -> Result<(String, usize)> {
let bytes = s.as_bytes();
if bytes.is_empty() {
return Err(Error::InvalidClassFile("empty descriptor".into()));
}
let mut dims = 0;
let mut i = 0;
while bytes[i] == b'[' {
dims += 1;
i += 1;
if i >= bytes.len() {
return Err(Error::InvalidClassFile(format!("dangling '[' in '{s}'")));
}
}
let base = match bytes[i] {
b'B' => "byte".to_string(),
b'C' => "char".to_string(),
b'D' => "double".to_string(),
b'F' => "float".to_string(),
b'I' => "int".to_string(),
b'J' => "long".to_string(),
b'S' => "short".to_string(),
b'Z' => "boolean".to_string(),
b'V' => "void".to_string(),
b'L' => {
let end = s[i..]
.find(';')
.ok_or_else(|| Error::InvalidClassFile(format!("unterminated 'L' type in '{s}'")))?;
crate::java::classfile::to_dotted(&s[i + 1..i + end])
}
other => {
return Err(Error::InvalidClassFile(format!(
"unknown descriptor char '{}' in '{s}'",
other as char
)))
}
};
i += if bytes[i] == b'L' {
s[i..].find(';').unwrap() + 1
} else {
1
};
Ok((format!("{}{}", base, "[]".repeat(dims)), i))
}
fn parse_type_param_names(s: &str) -> Result<(Vec<String>, &str)> {
let Some(mut rest) = s.strip_prefix('<') else {
return Ok((Vec::new(), s));
};
let mut names = Vec::new();
loop {
if let Some(r) = rest.strip_prefix('>') {
return Ok((names, r));
}
if let Some(r) = rest.strip_prefix(':') {
rest = skip_bound(r);
continue;
}
match rest.find(':') {
Some(colon) => {
names.push(rest[..colon].to_string());
rest = skip_bound(&rest[colon + 1..]);
}
None => {
return Err(Error::InvalidClassFile(format!(
"unterminated type-parameter list in '{s}'"
)))
}
}
}
}
fn skip_bound(rest: &str) -> &str {
let bytes = rest.as_bytes();
let mut depth = 0;
let mut i = 0;
while i < bytes.len() {
match bytes[i] {
b'<' => depth += 1,
b'>' => {
if depth == 0 {
return &rest[i..];
}
depth -= 1;
}
b';' if depth == 0 => return &rest[i + 1..],
_ => {}
}
i += 1;
}
&rest[i..]
}
fn parse_type_signature_at(s: &str) -> Result<(String, usize)> {
match s.as_bytes().first() {
None => Err(Error::InvalidClassFile("empty type signature".into())),
Some(b'[') => {
let (comp, n) = parse_type_signature_at(&s[1..])?;
Ok((format!("{comp}[]"), n + 1))
}
Some(b'T') => {
let end = s
.find(';')
.ok_or_else(|| Error::InvalidClassFile(format!("unterminated type variable in '{s}'")))?;
Ok((s[1..end].to_string(), end + 1))
}
Some(b'L') => parse_class_type_sig(s),
_ => parse_type(s), }
}
fn parse_class_type_sig(s: &str) -> Result<(String, usize)> {
let bytes = s.as_bytes();
if bytes.first() != Some(&b'L') {
return Err(Error::InvalidClassFile(format!(
"class type signature must start with 'L': '{s}'"
)));
}
let mut i = 1;
let mut out = String::new();
loop {
let start = i;
while i < bytes.len() && !matches!(bytes[i], b'<' | b'>' | b';' | b'.' | b'/') {
i += 1;
}
if i >= bytes.len() {
return Err(Error::InvalidClassFile(format!(
"unterminated class type signature '{s}'"
)));
}
out.push_str(&s[start..i]);
match bytes[i] {
b'/' | b'.' => {
out.push('.');
i += 1;
}
b'<' => {
let (args, n) = parse_type_arguments(&s[i..])?;
out.push_str(&args);
i += n;
}
_ => return Ok((out, i + 1)), }
}
}
fn parse_type_arguments(s: &str) -> Result<(String, usize)> {
let mut i = 1; let mut args = Vec::new();
loop {
match s.as_bytes().get(i) {
Some(b'>') => {
i += 1;
break;
}
None | Some(&b';') => {
return Err(Error::InvalidClassFile(format!(
"unterminated type arguments in '{s}'"
)))
}
_ => {}
}
let (arg, n) = parse_type_argument(&s[i..])?;
args.push(arg);
i += n;
}
Ok((format!("<{}>", args.join(", ")), i))
}
fn parse_type_argument(s: &str) -> Result<(String, usize)> {
match s.as_bytes().first() {
Some(b'*') => Ok(("*".into(), 1)),
Some(b'+') => {
let (t, n) = parse_type_signature_at(&s[1..])?;
Ok((format!("? extends {t}"), n + 1))
}
Some(b'-') => {
let (t, n) = parse_type_signature_at(&s[1..])?;
Ok((format!("? super {t}"), n + 1))
}
_ => parse_type_signature_at(s),
}
}
pub fn parse_type_signature(sig: &str) -> Result<String> {
let (ty, consumed) = parse_type_signature_at(sig)?;
if consumed != sig.len() {
return Err(Error::InvalidClassFile(format!(
"trailing characters in field signature '{sig}'"
)));
}
Ok(ty)
}
pub fn parse_method_signature(sig: &str) -> Result<(Vec<String>, Vec<String>, String)> {
let (type_params, rest) = parse_type_param_names(sig)?;
let rest = rest.strip_prefix('(').ok_or_else(|| {
Error::InvalidClassFile(format!("method signature must have '(': '{sig}'"))
})?;
let mut params = Vec::new();
let mut rest = rest;
loop {
if let Some(r) = rest.strip_prefix(')') {
rest = r;
break;
}
if rest.is_empty() {
return Err(Error::InvalidClassFile(format!(
"unterminated parameter list in '{sig}'"
)));
}
let (ty, consumed) = parse_type_signature_at(rest)?;
params.push(ty);
rest = &rest[consumed..];
}
let (ret, _) = parse_type_signature_at(rest)?;
Ok((type_params, params, ret))
}
pub fn parse_class_type_params(signature: &str) -> Vec<String> {
parse_type_param_names(signature)
.map(|(names, _)| names)
.unwrap_or_default()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn field_descriptors() {
assert_eq!(parse_field_descriptor("I").unwrap(), "int");
assert_eq!(parse_field_descriptor("Z").unwrap(), "boolean");
assert_eq!(parse_field_descriptor("J").unwrap(), "long");
assert_eq!(parse_field_descriptor("Ljava/lang/String;").unwrap(), "java.lang.String");
assert_eq!(parse_field_descriptor("[[I").unwrap(), "int[][]");
assert_eq!(
parse_field_descriptor("[Ljava/lang/Object;").unwrap(),
"java.lang.Object[]"
);
}
#[test]
fn method_descriptors() {
let (params, ret) = parse_method_descriptor("(ID)V").unwrap();
assert_eq!(params, vec!["int", "double"]);
assert_eq!(ret, "void");
let (params, ret) = parse_method_descriptor("([Ljava/lang/String;I)[I").unwrap();
assert_eq!(params, vec!["java.lang.String[]", "int"]);
assert_eq!(ret, "int[]");
}
#[test]
fn bad_descriptors() {
assert!(parse_field_descriptor("X").is_err());
assert!(parse_field_descriptor("[").is_err());
assert!(parse_method_descriptor("I)V").is_err());
assert!(parse_method_descriptor("(I").is_err());
}
#[test]
fn class_type_params() {
assert_eq!(parse_class_type_params("<T:Ljava/lang/Object;>Ljava/lang/Object;"), vec!["T"]);
assert_eq!(
parse_class_type_params("<K:Ljava/lang/Object;V:Ljava/lang/Object;>Ljava/lang/Object;"),
vec!["K", "V"]
);
assert_eq!(parse_class_type_params("Ljava/lang/Object;"), Vec::<String>::new());
}
}