How to do bit shifting in M3?

[nsgnkhibdk2cls0f]

Is it the same as SHL and SHR on Pascal? I didn't find the answer on the language manual. BTW, what about about bitwise operators (AND, OR, XOR, NOT)? Is there is list of them like what of C/C++?

[1997tn]

Using the Word interface, it's right on the interface index: http://modula3.github.io/cm3/help/interfaces.html#texts

The language doesn't provide bitwise operators like C/C++ or Pascal.

[mikanystrom-intel]

1997tn's answer is right but to add a few "bits" of information:

1. the Word interface is (required to be) implemented directly in the compiler, so while the syntax is a bit cumbersome, the code that's generated should be the same as in C

2. in some (many?) cases what you're trying to do can or maybe should be done using operations on SET OF ... .

Search for the word "Set" in the below:

https://www.cs.purdue.edu/homes/hosking/m3/reference/arithmetic.html

https://www.cs.purdue.edu/homes/hosking/m3/reference/relations.html

If you do use Word.T, you can use BITSIZE to make your code portable.

[nsgnkhibdk2cls0f]

in some (many?) cases what you're trying to do can or maybe should be done using operations on SET OF ... .

How? Example?

[mikanystrom-intel]

in some (many?) cases what you're trying to do can or maybe should be done using operations on SET OF ... .

How? Example?

Well it depends on what you are using bit operations for.

If you are using them to represent say 1234 different conditions (0..1233), then you could use Word.T:

VAR haveEm := ARRAY [0..1233 DIV BITSIZE(Word.T) + 1] OF Word.T;

PROCEDURE MarkOne(idx : [0..1233]) =
BEGIN
  WITH word = idx DIV 64,
       bit  = idx MOD 64 DO
      haveEm[word] := Word.Or(haveEm[word], Word.Shift(1, bit))
  END
END MarkOne;

PROCEDURE ClearOne(idx : [0..1233]) =
BEGIN
  WITH word = idx DIV 64,
       bit  = idx MOD 64 DO
      haveEm[word] := Word.And(haveEm[word], Word.Not(Word.Shift(1, bit)))
  END
END ClearOne;

Or you could just use the SET feature ..

VAR haveEm := SET OF [0..1233] {};

PROCEDURE MarkOne(idx : [0..1233]) =
   BEGIN haveEm := haveEm + SET OF [0..1233] { idx } END MarkOne;

PROCEDURE ClearOne(idx : [0..1233]) =
   BEGIN haveEm := haveEm - SET OF [0..1233] { idx } END ClearOne;

The machine representation is likely to be similar, if not identical.

[RodneyBates]

On 1/19/23 12:54, 1997tn wrote: Using the Word interface, it's right on the interface index: http://modula3.github.io/cm3/help/interfaces.html#texts The language doesn't provide bitwise operators like C/C++ or Pascal.

Interface Word provides unsigned arithmetic, bitwise boolean operations and shifts on INTEGER.  In the library code ( found in m3-libs/m3core/src/word), you will find it's a good but simple example of an instantiation of a generic interface named GenWord.ig, which is also instantiated as Long.i3, for same operations on LONGINT.

…

— Reply to this email directly, view it on GitHub <#1144 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ABSVZNBK3CLNHDSTFBLWRVDWTGEURANCNFSM6AAAAAAUAALGUA>. You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>