feat: implement integer literal

crates/psl/src/ast/expressions.rs

@@ -2,12 +2,18 @@ use super::{ExpressionOrBlock, Token, Type};
 
 #[derive(Clone, Debug, Hash, PartialEq)]
 pub enum Expression {
+    Literal(LiteralExpression),
     Read(ReadExpression),
     Name(NameExpression),
     If(IfExpression),
     BinaryOperator(BinaryOperatorExpression),
 }
 
+#[derive(Clone, Debug, Hash, PartialEq)]
+pub struct LiteralExpression {
+    pub value: Token,
+}
+
 #[derive(Clone, Debug, Hash, PartialEq)]
 pub enum ReadExpression {
     Type(Type),

crates/psl/src/ast/token.rs

@@ -7,6 +7,10 @@ pub enum TokenKind {
 
     IdentifierIdentifier,
 
+    LiteralDecimal,
+    LiteralHexadecimal,
+    LiteralBinary,
+
     KeywordRead,
     KeywordWrite,
     KeywordIf,

crates/psl/src/codegen/impls/expressions/literal.rs

@@ -0,0 +1,70 @@
+use crate::{
+    ast::{LiteralExpression, TokenKind},
+    codegen::{
+        construct::Type,
+        context::CodegenContext,
+        pass::{NameResolutionContext, NameResolutionPass},
+        visitor::CodegenNode,
+    },
+};
+
+impl CodegenNode for LiteralExpression {
+    fn produce_code(self, _ctx: &mut CodegenContext) -> String {
+        let digit_only = self.value.content.replace('_', "");
+        match self.value.kind {
+            TokenKind::LiteralDecimal => digit_only,
+            TokenKind::LiteralHexadecimal => format!("0x{digit_only}"),
+            TokenKind::LiteralBinary => {
+                let mut binary = String::from("0x");
+                let mut buffer = 0;
+                let mut nibble_len = digit_only.chars().count() % 4;
+                for bit in digit_only.chars() {
+                    buffer <<= 1;
+                    if bit == '1' {
+                        buffer |= 1;
+                    }
+                    nibble_len -= 1;
+                    if nibble_len == 0 {
+                        binary.push(to_hex_digit(buffer));
+                    }
+                }
+                binary
+            }
+            _ => unreachable!(
+                "Invalid TokenKind for LiteralExpression: {:?}",
+                self.value.kind
+            ),
+        }
+    }
+}
+impl NameResolutionPass for LiteralExpression {
+    fn resolve(&self, _ctx: &mut NameResolutionContext) {}
+}
+
+impl LiteralExpression {
+    pub fn infer_type(&self, _ctx: &CodegenContext) -> Result<Type, String> {
+        Ok(Type::Integer)
+    }
+}
+
+fn to_hex_digit(number: i32) -> char {
+    match number {
+        0 => '0',
+        1 => '1',
+        2 => '2',
+        3 => '3',
+        4 => '4',
+        5 => '5',
+        6 => '6',
+        7 => '7',
+        8 => '8',
+        9 => '9',
+        10 => 'A',
+        11 => 'B',
+        12 => 'C',
+        13 => 'D',
+        14 => 'E',
+        15 => 'F',
+        _ => unreachable!("No matching hex digit for {number}"),
+    }
+}

crates/psl/src/codegen/impls/expressions/mod.rs

@@ -1,5 +1,6 @@
 mod binary_operator;
 mod r#if;
+mod literal;
 mod name;
 mod read;
 
@@ -16,6 +17,7 @@ use crate::{
 impl CodegenNode for Expression {
     fn produce_code(self, ctx: &mut CodegenContext) -> String {
         match self {
+            Expression::Literal(node) => ctx.visit(node),
             Expression::Read(node) => ctx.visit(node),
             Expression::Name(node) => ctx.visit(node),
             Expression::If(node) => ctx.visit(node),
@@ -27,6 +29,7 @@ impl CodegenNode for Expression {
 impl NameResolutionPass for Expression {
     fn resolve(&self, ctx: &mut NameResolutionContext) {
         match self {
+            Expression::Literal(node) => ctx.visit(node),
             Expression::Read(node) => ctx.visit(node),
             Expression::Name(node) => ctx.visit(node),
             Expression::If(node) => ctx.visit(node),
@@ -38,6 +41,7 @@ impl NameResolutionPass for Expression {
 impl Expression {
     pub fn infer_type(&self, ctx: &CodegenContext) -> Result<Type, String> {
         match self {
+            Expression::Literal(expr) => expr.infer_type(ctx),
             Expression::Read(expr) => expr.infer_type(ctx),
             Expression::Name(expr) => expr.infer_type(ctx),
             Expression::If(expr) => expr.infer_type(ctx),

crates/psl/src/syntax/expressions/literal.rs

@@ -0,0 +1,13 @@
+use winnow::{combinator::alt, Located, PResult, Parser};
+
+use crate::ast::{LiteralExpression, TokenKind};
+
+pub fn parse_literal(s: &mut Located<&str>) -> PResult<LiteralExpression> {
+    alt((
+        TokenKind::LiteralDecimal,
+        TokenKind::LiteralHexadecimal,
+        TokenKind::LiteralBinary,
+    ))
+    .map(|token| LiteralExpression { value: token })
+    .parse_next(s)
+}

crates/psl/src/syntax/expressions/mod.rs

@@ -6,6 +6,7 @@ pub use name::parse_name;
 use operator::parse_operator;
 
 mod r#if;
+mod literal;
 mod name;
 mod operator;
 mod read;

crates/psl/src/syntax/expressions/simple.rs

@@ -2,10 +2,11 @@ use winnow::{combinator::alt, Located, PResult, Parser};
 
 use crate::ast::Expression;
 
-use super::{name::parse_name, r#if::parse_if, read::parse_read};
+use super::{literal::parse_literal, name::parse_name, r#if::parse_if, read::parse_read};
 
 pub fn parse_simple_expression(s: &mut Located<&str>) -> PResult<Expression> {
     alt((
+        parse_literal.map(Expression::Literal),
         parse_read.map(Expression::Read),
         parse_name.map(Expression::Name),
         parse_if.map(Expression::If),

crates/psl/src/syntax/tokens/literal.rs

@@ -0,0 +1,44 @@
+use winnow::{
+    combinator::{alt, preceded},
+    token::take_while,
+    Located, PResult, Parser,
+};
+
+use crate::ast::{Token, TokenKind};
+
+use super::token;
+
+pub fn parse_literal(s: &mut Located<&str>) -> PResult<Token> {
+    parse_integer_literal.parse_next(s)
+}
+
+pub fn parse_integer_literal(s: &mut Located<&str>) -> PResult<Token> {
+    alt((parse_hexadecimal, parse_binary, parse_decimal)).parse_next(s)
+}
+
+pub fn parse_decimal(s: &mut Located<&str>) -> PResult<Token> {
+    take_while(1.., ('0'..='9', '_'))
+        .verify(|s: &str| s.chars().any(|c| c != '_'))
+        .with_span()
+        .map(token(TokenKind::LiteralDecimal))
+        .parse_next(s)
+}
+
+pub fn parse_hexadecimal(s: &mut Located<&str>) -> PResult<Token> {
+    preceded(
+        "0x",
+        take_while(1.., ('0'..='9', 'a'..='f', 'A'..='F', '_')),
+    )
+    .verify(|s: &str| s.chars().any(|c| c != '_'))
+    .with_span()
+    .map(token(TokenKind::LiteralHexadecimal))
+    .parse_next(s)
+}
+
+pub fn parse_binary(s: &mut Located<&str>) -> PResult<Token> {
+    preceded("0b", take_while(1.., ('0'..='1', '_')))
+        .verify(|s: &str| s.chars().any(|c| c != '_'))
+        .with_span()
+        .map(token(TokenKind::LiteralBinary))
+        .parse_next(s)
+}

crates/psl/src/syntax/tokens/mod.rs

@@ -12,12 +12,14 @@ use crate::ast::{Token, TokenKind};
 use self::{
     identifier::parse_identifier_identifier,
     keyword::parse_keyword,
+    literal::parse_literal,
     punctuations::parse_punctuations,
     whitespaces::{parse_whitespace_horizontal, parse_whitespace_vertical},
 };
 
 mod identifier;
 mod keyword;
+mod literal;
 mod punctuations;
 mod whitespaces;
 
@@ -28,6 +30,7 @@ pub fn parse_token(s: &mut Located<&str>) -> PResult<Token> {
         parse_whitespace_horizontal,
         parse_whitespace_vertical,
         parse_identifier_identifier,
+        parse_literal,
         any.with_span().map(token(TokenKind::Error)),
         success("<eof>").with_span().map(token(TokenKind::Eof)),
     ))

snippets/27xx/2753.psl

@@ -0,0 +1,16 @@
+i32 year = read i32
+i32 is_leap = if year % 4 == 0 {
+    if year % 400 == 0 {
+        1
+    } else {
+        if year % 100 == 0 {
+            0
+        } else {
+            1
+        }
+    }
+} else {
+    0
+}
+
+write is_leap