PrefixLiteral

src/ast.rs

@@ -26,7 +26,7 @@ use nom::{
     combinator::map,
     IResult,
 };
-use nom::{AsChar, Finish};
+use nom::{AsChar, Finish, Parser};
 use serde::{Serialize, Serializer};
 use smallvec::SmallVec;
 
@@ -1893,7 +1893,7 @@ impl IpAddressLiteral {
                     terminated(digit1, char('.')),
                     terminated(digit1, char('.')),
                     take_while1(|ch: char| ch.is_dec_digit()),
-                    not(char(':')),
+                    not(char(':'))
                 ))),
                 recognize(tuple((
                     terminated(hex_digit0, char(':')),
@@ -1904,7 +1904,7 @@ impl IpAddressLiteral {
                     opt(terminated(hex_digit0, char(':'))),
                     opt(terminated(hex_digit0, char(':'))),
                     hex_digit0,
-                    not(char('.')),
+                    not(char('.'))
                 ))),
             )),
         )(input)?;
@@ -1921,6 +1921,25 @@ impl From<&'_ IpAddressLiteral> for ShortString {
 
 //------------ PrefixLiteral -------------------------------------------------
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PrefixLiteral(pub String);
+
+impl PrefixLiteral {
+    pub fn parse(input: &str) -> IResult<&str, Self, VerboseError<&str>> {
+        let (input, prefix_str) = context(
+            "prefix literal",
+            recognize(
+                tuple((
+                    IpAddressLiteral::parse,
+                    PrefixLengthLiteral::parse
+                )
+            ))
+        )(input)?;
+
+        Ok((input, Self(prefix_str.to_string())))
+    }
+}
+
 //------------ PrefixLengthLiteral -------------------------------------------
 
 /// A prefix length literal is a sequence of digits preceded by a '/'.
@@ -2267,12 +2286,13 @@ impl LargeCommunityLiteral {
             tuple((
                 opt(alt((tag("AS"), tag("0x")))),
                 take_while1(|ch: char| ch.is_hex_digit()),
-                tag(":"),
+                char(':'),
                 opt(tag("0x")),
                 take_while1(|ch: char| ch.is_hex_digit()),
-                tag(":"),
+                char(':'),
                 opt(tag("0x")),
                 take_while1(|ch: char| ch.is_hex_digit()),
+                not(char(':'))
             )),
         )(input)?;
 
@@ -2531,6 +2551,7 @@ impl std::fmt::Display for AcceptReject {
 #[derive(Clone, Debug)]
 pub enum ValueExpr {
     StringLiteral(StringLiteral),
+    PrefixLiteral(PrefixLiteral),
     PrefixLengthLiteral(PrefixLengthLiteral),
     AsnLiteral(AsnLiteral),
     IpAddressLiteral(IpAddressLiteral),
@@ -2567,6 +2588,7 @@ impl ValueExpr {
                 StandardCommunityLiteral::parse,
                 ValueExpr::StandardCommunityLiteral,
             ),
+            map(PrefixLiteral::parse, ValueExpr::PrefixLiteral),
             map(IpAddressLiteral::parse, ValueExpr::IpAddressLiteral),
             map(AsnLiteral::parse, ValueExpr::AsnLiteral),
             map(HexLiteral::parse, ValueExpr::HexLiteral),

src/eval.rs

@@ -20,6 +20,7 @@ use crate::types::builtin::BuiltinTypeValue;
 use crate::types::builtin::HexLiteral;
 use crate::types::builtin::IntegerLiteral;
 use crate::types::builtin::IpAddress;
+use crate::types::builtin::Prefix;
 use crate::types::builtin::PrefixLength;
 use crate::types::builtin::StringLiteral;
 use crate::types::enum_types::GlobalEnumTypeDef;
@@ -1708,6 +1709,15 @@ impl ast::ValueExpr {
                     Token::Constant(None),
                 ))
             }
+            ast::ValueExpr::PrefixLiteral(pfx_lit) => {
+                Ok(symbols::Symbol::new_with_value(
+                    "prefix_lit".into(),
+                    symbols::SymbolKind::Constant,
+                    Prefix::try_from(pfx_lit)?.into(),
+                    vec![],
+                    Token::Constant(None)
+                ))
+            }
             ast::ValueExpr::IpAddressLiteral(ip_address_lit) => {
                 Ok(symbols::Symbol::new_with_value(
                     "ip_address_lit".into(),

src/types/builtin/primitives.rs

@@ -9,7 +9,7 @@ use routecore::bgp::communities::{
 use serde::ser::SerializeSeq;
 use serde::{Serialize, Serializer};
 
-use crate::ast::IpAddressLiteral;
+use crate::ast::{IpAddressLiteral, PrefixLiteral};
 use crate::attr_change_set::VectorValue;
 use crate::compiler::compile::CompileError;
 use crate::first_into_vm_err;
@@ -1389,6 +1389,15 @@ impl From<Prefix> for TypeValue {
     }
 }
 
+impl TryFrom<&'_ PrefixLiteral> for Prefix {
+    type Error = CompileError;
+
+    fn try_from(value: &PrefixLiteral) -> Result<Self, Self::Error> {
+        Ok(Prefix(<routecore::addr::Prefix as std::str::FromStr>::from_str(value.0.as_str())
+            .map_err(|e| CompileError::from(format!("Cannot parse '{:?}' as an IP Address: {}", value, e)))?))
+    }
+}
+
 impl From<routecore::addr::Prefix> for Prefix {
     fn from(val: routecore::addr::Prefix) -> Self {
         Prefix(val)

src/types/collections.rs

@@ -216,6 +216,9 @@ impl TryFrom<ValueExpr> for ElementTypeValue {
             ValueExpr::IntegerLiteral(i_lit) => {
                 Ok(ElementTypeValue::Primitive(i_lit.into()))
             }
+            ValueExpr::PrefixLiteral(pfx_lit) => {
+                Ok(ElementTypeValue::Primitive((&pfx_lit).try_into()?))
+            }
             ValueExpr::IpAddressLiteral(ip_lit) => {
                 Ok(ElementTypeValue::Primitive((&ip_lit).try_into()?))
             }

src/types/typevalue.rs

@@ -1226,6 +1226,16 @@ impl TryFrom<&'_ crate::ast::IpAddressLiteral> for TypeValue {
     }
 }
 
+impl TryFrom<&'_ crate::ast::PrefixLiteral> for TypeValue {
+    type Error = CompileError;
+
+    fn try_from(value: &crate::ast::PrefixLiteral) -> Result<Self, Self::Error> {
+        Ok(TypeValue::Builtin(BuiltinTypeValue::Prefix(
+            value.try_into()?
+        )))
+    }
+}
+
 impl From<crate::ast::PrefixLengthLiteral> for TypeValue {
     fn from(value: crate::ast::PrefixLengthLiteral) -> Self {
         TypeValue::Builtin(BuiltinTypeValue::PrefixLength(PrefixLength(