Format improvements (WIP)

src/ast/meta.rs

@@ -576,7 +576,7 @@ impl ToMeta for f32 {
     fn to_meta(&self) -> Meta { Meta::Scalar(sp!((*self).into())) }
 }
 impl ToMeta for bool {
-    fn to_meta(&self) -> Meta { Meta::Scalar(sp!(ast::Expr::LitInt { value: *self as i32, radix: ast::IntRadix::Bool })) }
+    fn to_meta(&self) -> Meta { Meta::Scalar(sp!(ast::Expr::LitInt { value: *self as i32, format: ast::IntFormat { unsigned: true, radix: ast::IntRadix::Bool } })) }
 }
 impl ToMeta for String {
     fn to_meta(&self) -> Meta { Meta::Scalar(sp!(self.to_owned().into())) }

src/ast/mod.rs

@@ -455,7 +455,7 @@ pub enum Expr {
         value: raw::LangInt,
         /// A hint to the formatter on how it should write the integer.
         /// (may not necessarily represent the original radix of a parsed token)
-        radix: IntRadix,
+        format: IntFormat,
     },
     LitFloat { value: raw::LangFloat },
     LitString(LitString),
@@ -469,14 +469,18 @@ pub enum Expr {
     },
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct IntFormat {
+    pub unsigned: bool,
+    pub radix: IntRadix,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum IntRadix {
     /// Display as decimal.
     Dec,
     /// Display as hexadecimal, with an `0x` prefix.
     Hex,
-    /// Display as potentially negative hexadecimal, with an `0x` prefix.
-    SignedHex,
     /// Display as binary, with an `0b` prefix.
     Bin,
     /// Use `true` and `false` if the value is `1` or `0`.  Otherwise, fall back to decimal.
@@ -695,6 +699,9 @@ string_enum! {
         #[strum(serialize = "~")] BitNot,
         #[strum(serialize = "sin")] Sin,
         #[strum(serialize = "cos")] Cos,
+        #[strum(serialize = "tan")] Tan,
+        #[strum(serialize = "acos")] Acos,
+        #[strum(serialize = "atan")] Atan,
         #[strum(serialize = "sqrt")] Sqrt,
         #[strum(serialize = "$")] EncodeI,
         #[strum(serialize = "%")] EncodeF,
@@ -711,6 +718,9 @@ impl UnOpKind {
             UnOpKind::BitNot => OpClass::Bitwise,
             UnOpKind::Sin => OpClass::FloatMath,
             UnOpKind::Cos => OpClass::FloatMath,
+            UnOpKind::Tan => OpClass::FloatMath,
+            UnOpKind::Acos => OpClass::FloatMath,
+            UnOpKind::Atan => OpClass::FloatMath,
             UnOpKind::Sqrt => OpClass::FloatMath,
             UnOpKind::CastI => OpClass::Cast,
             UnOpKind::CastF => OpClass::Cast,
@@ -842,7 +852,7 @@ string_enum! {
 }
 
 impl From<raw::LangInt> for Expr {
-    fn from(value: raw::LangInt) -> Expr { Expr::LitInt { value, radix: IntRadix::Dec } }
+    fn from(value: raw::LangInt) -> Expr { Expr::LitInt { value, format: IntFormat { unsigned: false, radix: IntRadix::Dec } } }
 }
 impl From<raw::LangFloat> for Expr {
     fn from(value: raw::LangFloat) -> Expr { Expr::LitFloat { value } }
@@ -1257,7 +1267,7 @@ macro_rules! generate_visitor_stuff {
                 Expr::XcrementOp { op: _, order: _, var } => {
                     v.visit_var(var);
                 },
-                Expr::LitInt { value: _, radix: _ } => {},
+                Expr::LitInt { value: _, format: _ } => {},
                 Expr::LitFloat { value: _ } => {},
                 Expr::LitString(_s) => {},
                 Expr::LabelProperty { .. } => {},

src/cli_def.rs

@@ -576,7 +576,10 @@ pub mod msg_compile {
                 truth.load_mapfiles_from_pragmas(game, &ast)?;
             },
             MsgMode::Mission => {},
-            MsgMode::Ending => return Err(truth.emit(error!("--ending is not yet implemented"))),
+            MsgMode::Ending => {
+                load_mapfiles(truth, game, &[LanguageKey::End], mapfile_options)?;
+                truth.load_mapfiles_from_pragmas(game, &ast)?;
+            },
         }
 
         let mut truth = truth.validate_defs()?;
@@ -590,7 +593,10 @@ pub mod msg_compile {
                 let msg = truth.compile_mission(game, &ast)?;
                 truth.write_mission(game, out_path, &msg)?;
             },
-            MsgMode::Ending => unreachable!(),
+            MsgMode::Ending => {
+                let msg = truth.compile_msg(game, LanguageKey::End, &ast)?;
+                truth.write_msg(game, LanguageKey::End, out_path, &msg)?;
+            },
         }
         if let Some(debug_info_path) = debug_info_path {
             truth.prepare_and_write_debug_info(debug_info_path)?;
@@ -636,7 +642,14 @@ pub mod msg_decompile {
                 let msg = truth.read_mission(game, in_path)?;
                 truth.decompile_mission(game, &msg)
             },
-            MsgMode::Ending => return Err(truth.emit(error!("--ending is not yet implemented"))),
+            MsgMode::Ending => {
+                let mapfile_options = add_env_mapfile_for_decomp(mapfile_options, ".endm");
+                load_mapfiles(truth, game, &[LanguageKey::End], &mapfile_options)?;
+
+                let mut truth = truth.validate_defs()?;
+                let msg = truth.read_msg(game, LanguageKey::End, in_path)?;
+                truth.decompile_msg(game, LanguageKey::End, &msg, decompile_options)
+            },
         }
     }
 }

src/context/defs.rs

@@ -775,44 +775,9 @@ impl Defs {
 /// Lookup table for decompiling constant values to enum consts.
 #[derive(Debug, Clone)]
 pub struct ConstNames {
-    pub enums: IdMap<Ident, ScalarValueMap<Sp<Ident>>>,
+    pub enums: IdMap<Ident, IdMap<i32, Sp<Ident>>>,
 }
 
-/// A map with ScalarValue keys, which uses bitwise-identity for floats.
-#[derive(Debug, Clone)]
-pub struct ScalarValueMap<T> {
-    ints: IdMap<i32, T>,
-    strings: IdMap<String, T>,
-    floats: IdMap<u32, T>,
-}
-
-impl<T> ScalarValueMap<T> {
-    pub fn new() -> Self {
-        ScalarValueMap {
-            ints: Default::default(),
-            strings: Default::default(),
-            floats: Default::default(),
-        }
-    }
-
-    pub fn insert(&mut self, key: ScalarValue, value: T) -> Option<T> {
-        match key {
-            ScalarValue::Int(x) => self.ints.insert(x, value),
-            ScalarValue::Float(x) => self.floats.insert(x.to_bits(), value),
-            ScalarValue::String(x) => self.strings.insert(x, value),
-        }
-    }
-
-    pub fn get(&self, key: &ScalarValue) -> Option<&T> {
-        match key {
-            ScalarValue::Int(x) => self.ints.get(x),
-            ScalarValue::Float(x) => self.floats.get(&x.to_bits()),
-            ScalarValue::String(x) => self.strings.get(x),
-        }
-    }
-}
-
-
 impl CompilerContext<'_> {
     /// Get `value -> name` mappings for all enums and automatic consts, for decompilation or
     /// pretty-printing purposes.
@@ -827,11 +792,11 @@ impl CompilerContext<'_> {
 }
 
 impl EnumData {
-    fn generate_lookup(&self, consts: &context::Consts) -> ScalarValueMap<Sp<Ident>> {
-        let mut out = ScalarValueMap::new();
+    fn generate_lookup(&self, consts: &context::Consts) -> IdMap<i32, Sp<Ident>> {
+        let mut out = IdMap::new();
         for (ident, &const_id) in &self.consts {
             let value = consts.get_cached_value(const_id).expect("evaluate_const_vars has not run! (bug!)");
-            out.insert(value.clone(), ident.clone());
+            out.insert(value.expect_int(), ident.clone());
         }
         out
     }
@@ -1150,34 +1115,18 @@ impl Signature {
         signature_from_func_ast(ty_keyword, params)
     }
 
-    pub(crate) fn validate(&self, ctx: &CompilerContext) -> Result<(), ErrorReported> {
-        self._check_non_optional_after_optional(ctx)
-    }
-
-    fn _check_non_optional_after_optional(&self, ctx: &CompilerContext) -> Result<(), ErrorReported> {
-        let mut first_optional = None;
-        for param in self.params.iter() {
-            if param.default.is_some() {
-                first_optional = Some(param);
-            } else if let Some(optional) = first_optional {
-                return Err(ctx.emitter.emit(error!(
-                    message("invalid function signature"),
-                    secondary(optional.useful_span, "optional parameter"),
-                    primary(param.useful_span, "non-optional parameter after optional"),
-                )));
-            }
-        }
+    pub(crate) fn validate(&self, _ctx: &CompilerContext) -> Result<(), ErrorReported> {
         Ok(())
     }
 
     /// Minimum number of arguments accepted.
     pub fn min_args(&self) -> usize {
-        self.params.iter().take_while(|param| param.default.is_none()).count()
+        self.params.iter().fold(0, |count, param| count + param.default.is_none() as usize)
     }
 
     /// Maximum number of arguments accepted.
     pub fn max_args(&self) -> usize {
-        self.params.len()
+        self.min_args()
     }
 
     /// Matches arguments at a call site to their corresponding parameters.