Added basic support for C logical, comparison, and bitwise operators

Author: IsaacShelton

Diff for: src/ast/conforming.rs

@@ -1,6 +1,6 @@
 use super::CIntegerAssumptions;
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Language {
     Adept,
     C,
@@ -19,4 +19,11 @@ impl ConformBehavior {
             ConformBehavior::C => Default::default(),
         }
     }
+
+    pub fn auto_c_integer_to_bool_conversion(&self) -> bool {
+        match self {
+            ConformBehavior::Adept(_) => false,
+            ConformBehavior::C => true,
+        }
+    }
 }

Diff for: src/ast/expr/binary/short_circuiting.rs

@@ -1,11 +1,12 @@
-use crate::ast::Expr;
+use crate::ast::{Expr, Language};
 use std::fmt::Display;
 
 #[derive(Clone, Debug)]
 pub struct ShortCircuitingBinaryOperation {
     pub operator: ShortCircuitingBinaryOperator,
     pub left: Expr,
     pub right: Expr,
+    pub language: Language,
 }
 
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]

Diff for: src/c/translation/expr/mod.rs

@@ -38,20 +38,20 @@ pub fn translate_expr(
             let left = translate_expr(ast_file, typedefs, &operation.left, diagnostics)?;
             let right = translate_expr(ast_file, typedefs, &operation.right, diagnostics)?;
 
-            let op: ast::BinaryOperator = match operation.operator {
-                BinaryOperator::LogicalOr => todo!(),
-                BinaryOperator::LogicalAnd => todo!(),
-                BinaryOperator::InclusiveOr => todo!(),
-                BinaryOperator::ExclusiveOr => todo!(),
-                BinaryOperator::BitwiseAnd => todo!(),
-                BinaryOperator::Equals => todo!(),
-                BinaryOperator::NotEquals => todo!(),
-                BinaryOperator::LessThan => todo!(),
-                BinaryOperator::GreaterThan => todo!(),
-                BinaryOperator::LessThanEq => todo!(),
-                BinaryOperator::GreaterThanEq => todo!(),
-                BinaryOperator::LeftShift => todo!(),
-                BinaryOperator::RightShift => todo!(),
+            let operator: ast::BinaryOperator = match operation.operator {
+                BinaryOperator::LogicalOr => ast::ShortCircuitingBinaryOperator::Or.into(),
+                BinaryOperator::LogicalAnd => ast::ShortCircuitingBinaryOperator::And.into(),
+                BinaryOperator::InclusiveOr => ast::BasicBinaryOperator::BitwiseOr.into(),
+                BinaryOperator::ExclusiveOr => ast::BasicBinaryOperator::BitwiseXor.into(),
+                BinaryOperator::BitwiseAnd => ast::BasicBinaryOperator::BitwiseAnd.into(),
+                BinaryOperator::Equals => ast::BasicBinaryOperator::Equals.into(),
+                BinaryOperator::NotEquals => ast::BasicBinaryOperator::NotEquals.into(),
+                BinaryOperator::LessThan => ast::BasicBinaryOperator::LessThan.into(),
+                BinaryOperator::GreaterThan => ast::BasicBinaryOperator::GreaterThan.into(),
+                BinaryOperator::LessThanEq => ast::BasicBinaryOperator::LessThanEq.into(),
+                BinaryOperator::GreaterThanEq => ast::BasicBinaryOperator::GreaterThanEq.into(),
+                BinaryOperator::LeftShift => ast::BasicBinaryOperator::LeftShift.into(),
+                BinaryOperator::RightShift => ast::BasicBinaryOperator::RightShift.into(),
                 BinaryOperator::Add => ast::BasicBinaryOperator::Add.into(),
                 BinaryOperator::Subtract => ast::BasicBinaryOperator::Subtract.into(),
                 BinaryOperator::Multiply => ast::BasicBinaryOperator::Multiply.into(),
@@ -70,7 +70,7 @@ pub fn translate_expr(
                 BinaryOperator::BitOrAssign => todo!(),
             };
 
-            match op {
+            match operator {
                 ast::BinaryOperator::Basic(operator) => {
                     ast::ExprKind::BasicBinaryOperation(Box::new(ast::BasicBinaryOperation {
                         operator,
@@ -84,6 +84,7 @@ pub fn translate_expr(
                             operator,
                             left,
                             right,
+                            language: ast::Language::C,
                         },
                     ))
                 }

Diff for: src/parser/parse_expr/primary/operator.rs

@@ -1,7 +1,7 @@
 use super::{is_right_associative, is_terminating_token, Parser};
 use crate::{
     ast::{
-        BasicBinaryOperation, BasicBinaryOperator, BinaryOperator, Expr, ExprKind,
+        BasicBinaryOperation, BasicBinaryOperator, BinaryOperator, Expr, ExprKind, Language,
         ShortCircuitingBinaryOperation, ShortCircuitingBinaryOperator,
     },
     inflow::Inflow,
@@ -79,6 +79,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                     operator: short_circuiting_operator,
                     left: lhs,
                     right: rhs,
+                    language: Language::Adept,
                 }))
             }
         }

Diff for: src/resolve/conform/from_c_integer.rs

@@ -4,7 +4,7 @@ use crate::{
         Cast, CastFrom, Expr, ExprKind, IntegerSign, Type, TypeKind, TypedExpr, UnaryMathOperation,
         UnaryMathOperator,
     },
-    ast::{CInteger, IntegerBits, OptionIntegerSignExt},
+    ast::{CInteger, ConformBehavior, IntegerBits, OptionIntegerSignExt},
     logic::implies,
     source_files::Source,
 };
@@ -13,13 +13,14 @@ pub fn from_c_integer<O: Objective>(
     expr: &Expr,
     from_type: &Type,
     mode: ConformMode,
+    behavior: ConformBehavior,
     from_c_integer: CInteger,
     from_sign: Option<IntegerSign>,
     to_type: &Type,
     source: Source,
 ) -> ObjectiveResult<O> {
     match &to_type.kind {
-        TypeKind::Boolean => from_c_integer_to_bool::<O>(expr, from_type, mode, source),
+        TypeKind::Boolean => from_c_integer_to_bool::<O>(expr, from_type, mode, behavior, source),
         TypeKind::Integer(to_bits, to_sign) => from_c_integer_to_integer::<O>(
             expr,
             mode,
@@ -46,9 +47,10 @@ fn from_c_integer_to_bool<O: Objective>(
     expr: &Expr,
     from_type: &Type,
     mode: ConformMode,
+    behavior: ConformBehavior,
     source: Source,
 ) -> ObjectiveResult<O> {
-    if !mode.allow_lossy_integer() {
+    if !behavior.auto_c_integer_to_bool_conversion() && !mode.allow_lossy_integer() {
         return O::fail();
     }
 

Diff for: src/resolve/conform/mod.rs

@@ -111,6 +111,7 @@ pub fn conform_expr<O: Objective>(
             &expr.expr,
             from_type,
             mode,
+            behavior,
             *from_size,
             *from_sign,
             to_type,

Diff for: src/resolve/expr/short_circuiting_binary_operation.rs

@@ -31,7 +31,7 @@ pub fn resolve_short_circuiting_binary_operation_expr(
         &left,
         &local_bool_type,
         ConformMode::Normal,
-        ctx.adept_conform_behavior(),
+        ctx.conform_behavior(binary_operation.language),
         source,
     )
     .map_err(|_| {
@@ -59,7 +59,7 @@ pub fn resolve_short_circuiting_binary_operation_expr(
         &right,
         &local_bool_type,
         ConformMode::Normal,
-        ctx.adept_conform_behavior(),
+        ctx.conform_behavior(binary_operation.language),
         source,
     )
     .map_err(|_| {