boolcalc

Description

boolcalc is a simple RPN (reverse polish notation) boolean calculator. It allows the four main boolean operators: AND, OR, XOR, and NOT, as well as very simple support for D-latches and JK flip-flops. After reading the expression, it prints out a truth table for it.

This program is placed in the public domain. It uses pretty standard techniques, so I did not feel the necessity to put any licence on it. Feel free to modify the program in any way you see fit. Copy it, redistribute it, and use it in any way you want -- I don't care, as long as it's all honest and legal. (Of course, it's always nice to acknowledge your sources ;-) )

Disclaimer

The usual stuff: I'm not responsible for anything that happens to your computer as a result of running boolcalc. I'm only distributing the source files, so by compiling it, you agree to be fully responsible for any results of the program.

Requrements

Your compiler should at least have support for the STL stack, and should be able to handle exceptions. If you compiler supports ISO-standard C++ (I have yet to find one that does), it should be fine.

Usage

boolcalc takes no command line arguments. It reads from stdin and writes to stdout, so you can easily type expressions into text files, redirect the input to the file, and then redirect the output to another file.

The input has the following format:

The first character is a number, indicating the number of input gates (max 8). Note that boolcalc doesn't check that it is actually a number within the required range. Entering some other character may produce strange results.

The rest of the input is the RPN expression. Multiple expressions are separated by newline characters. Valid characters and their meanings are shown in the following table:

Input	Meaning
1, 0	Boolean constants.
A, B, C, ..., H	The input gates. Valid gates start from A. eg. if you have two inputs, they will be A and B
&, *	AND (pop two things off the stack, and connect them with an AND gate)
\|, +	OR
^	XOR
!	NOT
d	D-latch (pop two things off the stack: the first (ie. last one pushed onto the stack) is the D-input, the second (ie. first one pushed onto the stack) is the previous state.
j	JK flip-flop (pop three things off the stack: K, J, and the previous state.)
'\n', <eof>	Marks the end of the expression

Any other characters are just ignored (for the time being).

For example, the following input: "3 A B + C * '\n' A C! + B! ^ '\n'" would result in the functions f1=(A+B)*C and f2=(A+(!C))^(!B).

The expressions must be in RPN notation. That is, the operands come first, and then the operator. eg. ABC+* -> A*(B+C) To check that you got it right, boolcalc will print out the expression in `normal' format. Note that, as far as boolcalc is concerned, + has higher precedence than ^ so if it prints out A^B+C, it means A^(B+C).

After it prints out the expression, it prints out a truth table. On the left side are the inputs, and on the right side are the results of the espressions. This should be fairly self-explanatory.

`Bugs'

No, there aren't really any bugs, at least that I'm aware of. Just some shortcuts that I made that might cause some problems if you're not aware of them. I assume that you're all intelligent people, and so you can properly formulate an RPN expression with the proper number of gates, so there shouldn't be any problems. But just in case you mess something up and you want to know what's wrong...

boolcalc does not do checking that you only use the gates that you told it you would. If you ask for 3 gates, and then use gate G, it won't complain.
boolcalc is case sensitive. It also doesn't complain about invalid input.
boolcalc doesn't take into account any timing, so if, for example, you have a JK flip-flop feeding into another JK flip-flop, chances are, the result won't be correct.

To come...

ability to define customized, named gates
add an r-biased and s-biased RS flip-flop
add better error messages for a parse error
make this document a man page (?), or a dvi file.

Revision History

v.0.10 - Nov 7, 1998

used the STL stack class instead of my own (which had a lot of limitations)
got rid of the memory leak (?)
swapped the (displayed) input order to the more natural way
changed a few internal things (eg. used pointers instead of references for many things, no more globals)
added support for multiple functions in a run
added some range checking (thanks to the STL stack)

v.0.02 - Oct 15, 1997

added constant gates
added flip-flops (D-latch, JK-flip-flop)

v.0.01 - Oct 3, 1997

first release

The Author

You can e-mail me at hubert@cs.ualberta.ca, or if that address is invalid (ie. I'm graduated), you can try my alternate address. Send me comments or criticism.

My home page (the one that you'll be able to find boolcalc) is here.
[ Back ]
Last updated November 9, 1997. <><