Read flag?

BlitzMax Forums/BlitzMax Beginners Area/Read flag?

BLaBZ

(Posted 2010) [#1]

How are flags read?

I'd imagine you could do it bitwise somehow but is that ideal?

Czar Flavius

(Posted 2010) [#2]

& the value which stores the flag, with the number of the flag I believe.

If the flag is 4, that's 00001000

If the value is 00101100

00101100 &
00001000 =
00001000

which is non-zero, hence the flag is set.

TaskMaster

(Posted 2010) [#3]

4 is 00000100.

TomToad

(Posted 2010) [#4]

The most common way is to use Const to define a name for each bit position, then use that for setting and reading flags. Something like this:

Const PAINTFLAG:Int = %00000001
Const DRAWFLAG:Int = %00000010
Const ERASEFLAG:Int = %00000100
Const RESIZEFLAG:Int = %00001000

Function ReadFlag:Int(I:Int, Flag:Int)
    If (I & Flag) Then Return True
    Return False
End Function

Function SetFlag(I:Int Var, Flag:Int)
    I |: Flag
End Function

Function ClearFlag(I:Int Var, Flag:Int)
    I &: $FFFFFFFF - Flag
End Function

Local MyFlags:Int
SetFlag(MyFlag,DRAWFLAG)
If ReadFlag(MyFlag,PAINTFLAG) Then Paint()

dawlane

(Posted 2010) [#5]

As TomToad says it's best to use constants to define what each bit does. I tend to use Hexadecimal numbers as it's more readable and less typing.

SuperStrict

' Set up some constant binary switches. You can give these a more meaningful names e.g image visibility etc.
Const bit0:Byte = $01    '00000001
Const bit1:Byte = $02    '00000010
Const bit2:Byte = $04    '00000100
Const bit3:Byte = $08    '00001000
Const bit4:Byte = $10    '00010000
Const bit5:Byte = $20    '00100000
Const bit6:Byte = $40    '01000000
Const bit7:Byte = $80    '10000000

' Create a variable to maintain switch state each bit within this variable
' can mean any thing that you like e.g. image visibility etc.
Global flags:Byte = $00

' Set bit 1
flags:|bit1

Print "SET BIT 1: flags:|bit1 = HEX:" + Right(Hex:String(flags), 2) + " BIN:" + Right(Bin:String(flags), 8)
Print

' Add bits 4 and 7 to bit 1
flags:|(bit4 | bit7)

Print "SET BIT 4 and 7 to flags: flags:|(bit4 | bit7) = HEX:" + Right(Hex:String(flags), 2) + " BIN:" + Right(Bin:String(flags), 8)
Print

' Test to see if bit4 is set
If (flags & bit4) Then Print "TESTING BIT4 is set:(flags & bit4) = YES" Else Print "TESTING BIT4 is set:(flags & bit4) = NO"
Print

' Clear bit 4 but preserve bits 1,7 and any others
' There are four ways to do this
' 1) Invert bit4 by using the bitwise complement "~" and then bitwise AND to flags: flags:&(~bit4)
' 2) Invert bit4 by using Exclusive OR with the highest value flags can hold ($FF) and then bitwise AND flags: flags:&($FF ~ bit4)
'        this is basically the bitwise complement. 
' 3) Subtract bit4 from the highest value that flags variable can hold in this case $FF: flags:& $FF - bit4
' 4) Pre calculate the inverted bit4 and then bitwise AND flags in the case of bit4 $EF: flags:& $EF
 
Print "CLEARING BIT 4 AND PRESERVE THE REST"
Print "Invert the flags variable:~~bit4 = HEX:" + Right(Hex:String(~bit4), 2) + " BIN:" + Right(Bin:String(~bit4), 8)
Print "and then bitwise AND to flags: HEX:" + Right(Hex:String(flags), 2) + " BIN:" + Right(Bin:String(flags), 8)

flags:&(~bit4)

Print "Command: flags:&(~~bit4) = HEX:" + Right(Hex:String(flags), 2) + " BIN:" + Right(Bin:String(flags), 8)
Print

' Test bit4 again
If (flags & bit4) Then Print "TESTING BIT4 is set:(flags & bit4) = YES" Else Print "TESTING BIT4 is set:(flags & bit4) = NO"

End

EDIT: Note that in the example I've used a byte just to make it a little more easier to follow. For speed its better to use the cpu's word size (four bytes for a 32bit CPU) this is because of how a CPU accesses memory.

Czar Flavius

(Posted 2010) [#6]

My apologies!

Here is a quick way to set up the flags...

Const flag1 = 1 Shl 0 '1
Const flag2 = 1 Shl 1 '2
Const flag3 = 1 Shl 2 '4
Const flag4 = 1 Shl 3 '8
Const flag5 = 1 Shl 4 '16
Const flag6 = 1 Shl 5 '32
Const flag7 = 1 Shl 6 '64

Never use Bytes unless you have a specific need to. Ints are faster than bytes.

GfK	(Posted 2010) [#7]

Here is a quick way to set up the flags...
Const flag1 = 1 Shl 0 '1
Const flag2 = 1 Shl 1 '2
Const flag3 = 1 Shl 2 '4
Const flag4 = 1 Shl 3 '8
Const flag5 = 1 Shl 4 '16
Const flag6 = 1 Shl 5 '32
Const flag7 = 1 Shl 6 '64

Eh??

Why not Const flag7 = 64 etc?? What's with all the unnecessary bitshifting?

Czar Flavius

(Posted 2010) [#8]

You can copy and paste and just change one number, and it goes up by 1 so it's easy to remember? It's just a suggestion not a recommendation. As they're consts the bitshifting is done at compile time, so there is no performance loss.

GfK	(Posted 2010) [#9]

You can copy and paste and just change one number, and it goes up by 1 so it's easy to remember?

Pffffft!! :D

Czar Flavius

(Posted 2010) [#10]

For the ultimately lazy:

Global myflag1:Int = autoflag("myflag")
Global myflag2:Int = autoflag("myflag")
Global myflag3:Int = autoflag("myflag")
Global myflag4:Int = autoflag("myflag")
Global myflag5:Int = autoflag("myflag")
Global myflag6:Int = autoflag("myflag")

Function autoflag:Int(id:String)
    Global flagmap:TMap = New TMap
    If flagmap.Contains(id)
        Local flag:Int = Int(String(flagmap.ValueForKey(id)))
        flagmap.Insert(id, String(flag+1))
        Return 1 Shl flag
    Else
        flagmap.Insert(id, String(0))
        Return autoflag(id)
    End If
End Function

Note: do not use this.