======SYSPROG PROJECT: Writing Unix Tools 2.0 (wut2)======
====Objective: ====
Input under each section examples of your program running using different options
=====binary.c=====
=====parity.c=====
=====endian.c=====
=====checksum.c=====
=====twoscomp.c (bschulte)=====
Last week, I had a broken, messy version of twoscomp.c. So I decided to rewrite it for wut2. Everything works except for only one string can be input at a time.
./twoscomp -s "10010110"
01101010
./twoscomp -v -s "10010110"
Verbose mode on: probably less ugly
Base: 2
Wordsize: 8
10010110 -> 01101001 + 1 = 01101010
./twoscomp -w 4 -s "1001"
0111
./twoscomp -w 4 -v -s "1001"
Verbose mode on: probably less ugly
Base: 2
Wordsize: 4
1001 -> 0110 + 1 = 0111
./twoscomp -s "100100"
Improper String Length. Wordsize is: 8
String is: 6 characters long
./twoscomp -b 10 -s "10"
10 -> 246
./twoscomp -v -b 10 -s "10"
Verbose mode on: probably less ugly
Base: 10
Wordsize: 8
10 -> 00001010 -> 11110101 + 1 = 11110110 -> 246
./twoscomp -v -w 4 -b 10 -s "10"
Verbose mode on: probably less ugly
Base: 10
Wordsize: 4
10 -> 1010 -> 0101 + 1 = 0110 -> 6
./twoscomp -b 10 -s "124"
124 -> 132
./twoscomp -w 32 -b 10 -s "124"
4294967172
./twoscomp -v -w 32 -b 10 -s "124"
Verbose mode on: probably less ugly
Base: 10
Wordsize: 32
124 -> 00000000000000000000000001111100 ->
11111111111111111111111110000011 + 1 =
11111111111111111111111110000100 ->
4294967172
./twoscomp -v -w 8 -b 10 -s "255"
Verbose mode on: probably less ugly
Base: 10
Wordsize: 8
255 -> 11111111 -> 00000000 + 1 = 00000001 -> 1
./twoscomp -w 8 -b 10 -s "256"
Segmentation fault
./twoscomp -v -w 32 -b 10 -s "6553"
Verbose mode on: probably less ugly
Base: 10
Wordsize: 32
6553 -> 00000000000000000001100110011001 ->
11111111111111111110011001100110 + 1 =
11111111111111111110011001100111 ->
4294960743
./twoscomp -b 8 -s "123"
123 -> 83 -> 193 -> 301
./twoscomp -v -b 8 -s "123"
Verbose mode on: probably less ugly
Base: 8
Wordsize: 8
123 -> 83 -> 01010011 -> 10101100 + 1 = 10101101 -> 173 -> 255
/twoscomp -b 16 -s "af"
1015 -> 175 -> 81 -> 51 //a = 10 f = 15, hence 1015 -> 175
/twoscomp -v -b 16 -s "af"
Verbose mode on: probably less ugly
Base: 16
Wordsize: 8
1015 -> 175 -> 10101111 -> 01010000 + 1 = 01010001 -> 81 -> 51
./twoscomp --help
~~~~~twoscomp.c help page~~~~~
Usage: ./twoscomp -s [STRING] [OPTION]
-q, --quiet
suppress all output
-V, --version
print version info
-v, --verbose
includes printout of all values specified by options
-D, --debug
prints all debug statements. Probably pretty ugly
-s [STRING], --string[=STRING]
The string to be processed.
-d [DELIM], --delim[=DELIM]
Changes delimeter to [DELIM]. Defaults to space
-w [SIZE], --wordsize[=SIZE]
Sets the wordsize to [SIZE}. Defaults to 8
Must be power of 2, between 4 and 128
-b [BASE], --BASE[=BASE]
Changes the input/output base. Defaults to base 2
./twoscomp -V
twoscomp Ver. 0.2
//I also included my own -D debugging option
./twoscomp -D -s "10010110"
Debug mode on~~: this is gonna be ugly
Verbose mode on: probably less ugly
==================~~~~===============
Size of Binary[]: 9
Base: 2
Wordsize: 8
Copied Input: 10010110
Size of Binary[]: 9
Start of toBinary()
Base is 2
After toBinary(), binary[] is: 10010110
Start of twoscomp()
10010110 -> 01101001 + 1 =
After twoscomp(), binary[] is: 01101010
end of twoscomp()
Start of toDec()
End of toDec
After toDec, convDec is: 0
After toDec(), binary[] is(should be unchanged): 01101010
End of toBinary/printnum() call
Start of printnum()
01101010
End of printnum
=====addition.c - Kris=====
addition.c is an addition program that uses bitwise logic to add two numbers together. The absolute size limit for numbers is 255, though it may be smaller if a smaller word size (either 7 bits or a nibble) is chosen. Sums can go over this, but won't be reported in the results. If you want the carry, there's an option for that.
The bare minimum operation is: ./addition -s "10001000 00101000" or echo "10001000 00101000" | ./addition or ./addition file
where file contains "10001000 00101000" (minus quotes)... note that if other options are specified, file must follow all of the options or the program will complain.
By default, the program expects 8-bits of binary input for each number to be added. If you have less or more than this (i.e. type "1001 0100" instead of the other string up above), it will complain.
There are some additional options, depending on what type of numbers you want to add. You can change base to 8, 10, or 16 by specifying -b 8 or -b 10 or -b 16 on the command line (-b 2 is also possible but unnecessary, as base 2 is the default). For example,
./addition -s "020 100" -b 10
will print "120"
You can limit the size of the input/output by using the -4, -7, or -8 (default) options, which will cause the program to expect that number of bits as input. Bits are from the computer's perspective. Choosing the -4 option will limit binary input to the range 0000-1111, octal input 000-017, decimal 00-15, or hexadecimal 0x00-0x0F. Going over these limits will cause an error.
A space is the default delimiter, but a different character can be chosen as the delimiter using the -d option, as so:
./addition -s "1000A0100" -d 'A' -4
or no delimiter if the -n option is chosen:
./addition -s "10000100" -n -4
If the -C option is used, the program's return value will be the final carry. This can be useful if the sum overflows the 0-255 size limit.
Using the -I option, you can specify an initial carry, like so:
./addition -b 10 -s "010 210" -I "005"
which prints "225"
The -h/-? option will display a more detailed usage guide. The -q option makes all output quiet, while the -v option will print information about the base, word size, and initial carry.
The -V option prints version information, in this case "wut.2"
Some usage examples and their output (commands are on the first line, output on the following line(s):
./addition -s "10011000 01100001"
11111001
./addition -n -s "10011001" -4 -C -v
Base is: 2
Input unit is: 4 bits
Final carry is: 16
0010
./addition -b 8 -s "0012 0137"
0151
./addition -7 -s "0101111 0010000"
0111111
echo "0x0e 0x02" | ./addition -b 16
0x10
(here's a fun one: using 'x' as the delimiter for hexadecimal numbers won't cause errors!)
echo "0x0ex0x02" | ./addition -b 16 -d 'x'
0x10
(notice how we get 0 because we hit the overflow)
./addition -b 8 -7 -s "0177 0001"
000
./addition -b 8 -7 -s "0177 0001" -I "0003"
003
(add something over the size limit)
./addition -b 10 -s "300 456"
Input exceeds size limit.
type "'./addition' -h" for help
./addition -b 16 -n -s "0x1f0x01" -I "0x0a"
0x2a
echo "027 018" | ./addition -b 10 -I "001"
46
(file contains: "0010 0043"
./addition -b 8 file
053
=====bitmask.c - Andrei Bratkovski=====
\\
**Examples** \\
**base 2 (default)** \\
./bitmask -M "10110111" -s "10011010 11010001" \\
10010010 \\
10010001 \\
**base 8** \\
./bitmask -M "66" -s "77 77" -b 8 \\
66 \\
66 \\
**base 10**\\
./bitmask -M "31 -s "30" -b 10 \\
30 \\
**base 16** \\
./bitmask -M "FE" -s "FF" -b 16 \\
0xFE \\
**delimiter example** \\
./bitmask -M "66" -s "77s77" -b 8 -d "s" \\
66 \\
66 \\
**word size example**
./bitmask -M "65535" -s "65534" -w128 -b10 \\
65534 \\
**Help** \\
./bitmask -h \\ \\
Bitmask options: \\
-M 'BITMASK' specify bitmask value for processing (required) \\
-b 'BASE' input/output base (of 2, 8, 10, or 16; base 2 is default) \\
-w # set wordsize (power of 2 between 4 and 128, 8 is default) \\
\\
Options displayed here for help: \\
-h display usage information and exit \\
-V display version information and exit \\
-s 'STRING' specify STRING as value to process \\
-4 set nibble as processing unit/word size \\
-7 set byte/word as 7-bits \\
-8 set byte/word as 8-bits (default) \\
-n no delimiter between processing units \\
-d 'CHAR' use CHAR as delimiter between processing units (space is default) \\
-q quiet, do not display anything to STDOUT \\
-v verbose, display more information to STDOUT \\
\\
**Version** \\
./bitmask -V \\
./bitmask Awesome version 1.0 \\
=====rotate.c - Aaron Houghtaling=====
rotate.c is a program that when given a set of bits will shift them left or right and carry over the removed bit and tacked onto the left or right side respectively.
Some Examples:
lab46:~/src/sysprog/wut2/src$ ./rotate 1101
1110
lab46:~/src/sysprog/wut2/src$ ./rotate -s "1101"
1110
lab46:~/src/sysprog/wut2/src$ ./rotate -R 3 -s "1101"
1011
lab46:~/src/sysprog/wut2/src$ ./rotate -L 3 -s "1101"
1110
lab46:~/src/sysprog/wut2/src$ ./rotate -V
Version: rotate 2.0
lab46:~/src/sysprog/wut2/src$ ./rotate -R 9 -s "1101"
1110
lab46:~/src/sysprog/wut2/src$ ./rotate -d , -s "1101,101"
1110
110
lab46:~/src/sysprog/wut2/src$ ./rotate -d , -S -s "1101,101"
1110 110
lab46:~/src/sysprog/wut2/src$ ./rotate -4 -s "11100"
Error: input does not match byte size!
lab46:~/src/sysprog/wut2/src$ ./rotate -h
Usage: rotate [OPTION]...
Rotates bits from a given input based on args given
Rotates default behavior without arguments is to shift right by one bit
Optional Arguments:
-h display this help information and exit
-V display rotate.c version information and exit
-S display output on a SINGLE line.
Default is to print on a new line with each value
-s [STRING] specify "STRING" as value
Default accepts SPACE seperated values
ex: -s "1011 1110"
-4 set nibble as processing unit size
-7 set byte size to 7-bits
-8 set byte size to 8-bits
-n no delimiter between units. Can only contain ONE value
ex: 1011 1110 will process as only 1011
-d [CHAR] use "CHAR" as delimiter between units
-q quiet all STDOUT output
-v display MORE information to STDOUT
-w [#] set "#" as byte size (4-128)
-L [#] rotate LEFT by "#" of bytes
-R [#] rotate RIGHT by "#" of bytes
For further information contact: ahought2@corning-cc.edu
=====invert.c=====
A bit-wise inversion is an operation where the end outputs the opposite bit of the beginning input. What this means is that the input bit of 1 will result in a 0 after this operation.
Example of outputs and error messages:
./invert -s "10011010 11010001" --> 01100101 00101110
echo "1100101100011101" | ./invert --> 0011010011100010
echo "1000100" | ./invert -B --> 0111011
echo "12" | ./invert -B --> invalid number!
./invert -V --> 0.0.2
./invert --help
Usage: ./invert [OPTION]... [FILE]...
performs a bit inversion against a set of input values!
Arguments:
-h, --help display usage information
-V, --Version display version information
-s, -string specify STRING as value to process
-v, -verbose displays more information to STDOUT
-d, -delimiter use the argument as a delimiter
-q, -quiet do not display anything to STDOUT
-B, -Binary input data is to be considered as binary
-O, -Octal input data is to be considered as octal
-D, -Decimal input data is to be considered as decimal
-H, -Hexadecimal input data is to be considered as hexadecimal