Commit: 43921e54fe35496ec29eb0bf1e74d1d5a906d3b9 - turbolisp (git)

A small standalone Lisp used as a scripting language in the Z2 game engine

Commit MetaInfo

• Révision: 43921e54fe35496ec29eb0bf1e74d1d5a906d3b9 (tree)
• l'heure: 2019-11-10 05:12:48
• Auteur: AlaskanEmily <emily@alas...>
• Commiter: AlaskanEmily

Message de Log

Add bitwise operators as builtins

Change Summary

• modified: turbolisp.runtime.builtin.arithmetic.m
• modified: turbolisp.runtime.builtin.m

Modification

--- a/turbolisp.runtime.builtin.arithmetic.m
+++ b/turbolisp.runtime.builtin.arithmetic.m
@@ -19,28 +19,46 @@
 
 %-----------------------------------------------------------------------------%
 
+:- mode arith_pred == (pred(in, in, uo) is det).
+:- inst arith_pred == (pred(in, in, uo) is det).
+
+%-----------------------------------------------------------------------------%
+
 :- type math_pred == (pred(number, number, string)).
-:- mode math_pred == (pred(in, in, uo) is det).
-:- inst math_pred == (pred(in, in, uo) is det).
+
+%-----------------------------------------------------------------------------%
+
+:- type bit_pred == (pred(int, int, int)).
 
 %-----------------------------------------------------------------------------%
 % TODO: Variadic + and *?
-:- pred builtin_plus `with_type` math_pred `with_inst` math_pred.
-:- pred builtin_minus `with_type` math_pred `with_inst` math_pred.
-:- pred builtin_times `with_type` math_pred `with_inst` math_pred.
-:- pred builtin_divide `with_type` math_pred `with_inst` math_pred.
+:- pred builtin_plus `with_type` math_pred `with_inst` arith_pred.
+:- pred builtin_minus `with_type` math_pred `with_inst` arith_pred.
+:- pred builtin_times `with_type` math_pred `with_inst` arith_pred.
+:- pred builtin_divide `with_type` math_pred `with_inst` arith_pred.
+
+%-----------------------------------------------------------------------------%
+
+:- pred builtin_and `with_type` bit_pred `with_inst` arith_pred.
+:- pred builtin_or `with_type` bit_pred `with_inst` arith_pred.
+:- pred builtin_xor`with_type` bit_pred `with_inst` arith_pred.
+
+%-----------------------------------------------------------------------------%
+
+:- pred builtin_math_bind(math_pred, arithmetic, list(element), result).
+:- mode builtin_math_bind(arith_pred, in, in, res_uo) is det.
 
 %-----------------------------------------------------------------------------%
 
-:- pred builtin_arithmetic_bind(math_pred, arithmetic, list(element), result).
-:- mode builtin_arithmetic_bind(math_pred, in, in, res_uo) is det.
+:- pred builtin_bit_bind(bit_pred, logic, list(element), result).
+:- mode builtin_bit_bind(arith_pred, in, in, res_uo) is det.
 
 %=============================================================================%
 % Most of the implementation of the arithmetic submodule is private.
 :- implementation.
 %=============================================================================%
 
-:- use_module int.
+:- import_module int.
 :- import_module float.
 
 %-----------------------------------------------------------------------------%
@@ -123,10 +141,16 @@ builtin_times(ANum, BNum, arithmetic(int.times, float_times, ANum, BNum)).
 builtin_divide(ANum, BNum, arithmetic('int__div', float_divide, ANum, BNum)).
 
 %-----------------------------------------------------------------------------%
+
+builtin_and(A, B, A /\ B).
+builtin_or(A, B, A \/ B).
+builtin_xor(A, B, int.xor(A, B)).
+
+%-----------------------------------------------------------------------------%
 % Implementation of arithmetic operators.
 :- pred arithmetic(math_pred,
     arithmetic, list.list(element), result).
-:- mode arithmetic(math_pred,
+:- mode arithmetic(arith_pred,
     in, in, res_uo) is det.
 
 :- pragma inline(arithmetic/4).
@@ -167,4 +191,62 @@ arithmetic(Pred, Op, Args, Result) :-
 
 %-----------------------------------------------------------------------------%
 
-builtin_arithmetic_bind(Pred, Op, Args, Out) :- arithmetic(Pred, Op, Args, Out).
+builtin_math_bind(Pred, Op, Args, Out) :- arithmetic(Pred, Op, Args, Out).
+
+%-----------------------------------------------------------------------------%
+
+builtin_bit_bind(Pred, Op, Args, Result) :-
+    two_atoms(Args, ArgsResult),
+    (
+        ArgsResult = maybe.error(Error),
+        builtin_op_tag(logic(Op), Tag),
+        Result = maybe.error(func_error(Tag, 2, Error))
+    ;
+        ArgsResult = maybe.ok({AStr, BStr}),
+        ( if
+            number_type(AStr, ANum)
+        then
+            ( if
+                number_type(BStr, BNum)
+            then
+                (
+                    ANum = int(A),
+                    (
+                        BNum = int(B),
+                        Pred(A, B, Out),
+                        Result = maybe.ok(atom(string.from_int(Out)))
+                    ;
+                        ANum = int(_), BNum = float(_),
+                        builtin_op_tag(logic(Op), Tag),
+                        Result = maybe.error(func_error(
+                            Tag,
+                            2,
+                            string.append(string.append(
+                                "arg 2 not an integer (", BStr), ")")))
+                    )
+                ;
+                    ANum = float(_),
+                    builtin_op_tag(logic(Op), Tag),
+                    Result = maybe.error(func_error(
+                        Tag,
+                        2,
+                        string.append(string.append(
+                            "arg 1 not an integer (", BStr), ")")))
+                )
+            else
+                builtin_op_tag(logic(Op), Tag),
+                Result = maybe.error(func_error(
+                    Tag,
+                    2,
+                    string.append(string.append(
+                        "arg 2 not a number (", BStr), ")")))
+            )
+        else
+            builtin_op_tag(logic(Op), Tag),
+            Result = maybe.error(func_error(
+                Tag,
+                2,
+                string.append(string.append(
+                    "arg 1 not a number (", AStr), ")")))
+        )
+    ).

--- a/turbolisp.runtime.builtin.m
+++ b/turbolisp.runtime.builtin.m
@@ -167,6 +167,14 @@
 :- pred builtin_divide_bind `with_type` execute_pred `with_inst` execute_pred.
     
 %-----------------------------------------------------------------------------%
+% Bitwise components.
+%-----------------------------------------------------------------------------%
+
+:- pred builtin_and_bind `with_type` execute_pred `with_inst` execute_pred.
+:- pred builtin_or_bind `with_type` execute_pred `with_inst` execute_pred.
+:- pred builtin_xor_bind `with_type` execute_pred `with_inst` execute_pred.
+
+%-----------------------------------------------------------------------------%
 % Define components.
 %-----------------------------------------------------------------------------%
 
@@ -370,10 +378,16 @@ builtin_ge_bind(E, R, !RT) :- builtin_comparison_bind(builtin_ge, E, R, !RT).
 
 %-----------------------------------------------------------------------------%
 
-builtin_plus_bind(E, R, !RT) :- builtin_arithmetic_bind(builtin_plus, plus, E, R).
-builtin_minus_bind(E, R, !RT) :- builtin_arithmetic_bind(builtin_minus, minus, E, R).
-builtin_times_bind(E, R, !RT) :- builtin_arithmetic_bind(builtin_times, times, E, R).
-builtin_divide_bind(E, R, !RT) :- builtin_arithmetic_bind(builtin_divide, divide, E, R).
+builtin_plus_bind(E, R, !RT) :- builtin_math_bind(builtin_plus, plus, E, R).
+builtin_minus_bind(E, R, !RT) :- builtin_math_bind(builtin_minus, minus, E, R).
+builtin_times_bind(E, R, !RT) :- builtin_math_bind(builtin_times, times, E, R).
+builtin_divide_bind(E, R, !RT) :- builtin_math_bind(builtin_divide, divide, E, R).
+
+%-----------------------------------------------------------------------------%
+
+builtin_and_bind(E, R, !RT) :- builtin_bit_bind(builtin_and, int_and, E, R).
+builtin_or_bind(E, R, !RT) :- builtin_bit_bind(builtin_or, int_or, E, R).
+builtin_xor_bind(E, R, !RT) :- builtin_bit_bind(builtin_xor, int_xor, E, R).
 
 %-----------------------------------------------------------------------------%
 % Used to implement let and def