Assignment 2 for CSCI 255 / ECE 109

Due date

This assignment must be submitted as a single file for Assignment 2 of the CSCI 255/ECE 109 section on UNCA moodle by 5:00 PM on Friday, 6 March.

On-line discussion of a similar problem

If you would like to review a presentation of a similar problem, take a look at Problem Session 2. You can also download an archived lecture that discusses this problem.

The problem

This assignment is a "real" world problem and, as such, isn't simple. The problem is to design a finite state machine that determines if an input sequence is a legal integer constant in the C++ programming language. C++ allows integer constants to be expressed in three forms.

1. Decimal constants: These begin with the a non-zero digit (1 to 9) and continue with a sequence of digits (0 to 9). They are interpreted as base 10 numbers.
2. Octal constants: These begin with the zero digit (0) and continue with a sequence of octal digits (0 to 7). They are interpreted as base 8 numbers.
3. Hexadecimal constants: These begin with the two letter sequence '0x' or '0X' and continue with a sequence of octal digits (0 to 9, A to F, a to f). They are interpreted as base 16 numbers.

Furthermore, integer constants can be followed by suffixes composed of the letters 'u' or 'U' to indicate the integer is unsigned or 'l' or 'L' to indicate the number is long. Since a number can be both unsigned and long, 'ul', 'lu', 'Ul', 'Lu', 'uL', 'lU', 'UL', and 'LU' also legal two-letter suffixes.

This means that `2009`, `03731`, and `0x7D9` are all legitimate ways of writing the number 2009 in C++ (and C). With suffixes, `2009l`, `2009ul`, and `2009LU` are also legal.

The following are not legal constants.

 ` ` Must contain at least one character. `5 6` Can't contain blanks at beginning, middle, or end. `080` No 8's or 9's in octal numbers `-255` Not a constant, but an operator applied to a constant. `2009LL` Legal in C99 standard (as a long long), but not in C++ `#!^&*@#\$*` Watch your language!

Implementation detail #1

Your finite state machine processes the characters as they are input. Consequently, a seven-character input sequence like `0x7D9LL` will be judged valid at the end of the clock cycle for the five partial sequences `0`, `0x7`, `0x7D` `0x7D9`, `0x7D9L` but not at the end of the cycle for `0x`, `0x7D9LL`, or the initial state (empty string).

Implementation detail #2

Technically, the input to your circuit should be a seven-bit ASCII encoding. However, seven bits would be too much; so we assume that your circuit will be fronted by a special encoder that reduces the number of inputs from seven to three bits. The meaning of these three bits is shown in the following table.

Binary inputsASCII character input
000 Character '0'
001 Characters '1' to '7'
010 Characters '8' or '9'
011 Characters 'A' to 'F' or 'a' to 'f'
100 Characters 'u' or 'U'
101 Characters 'l' or 'L'
110 Characters 'x' or 'X'
111 Any character not covered by the above cases

An example

If you want an example of how this works, you can download a Perl script which reads input strings and prints out the three-bit input encoding and the expected one-bit binary output for them.

Here'a an example of running this program on our sample input `0x7D9LL`:

```bash-3.2\$ CIntCheck.pl
Enter an empty line when you've had enough

0x7D9LL

string=>   0 x 7 D 9 L L
in2bit=>   0 1 0 0 0 1 1
in1bit=>   0 1 0 1 1 0 0
in0bit=>   0 0 1 1 0 1 1
outbit=>  0 1 0 1 1 1 1 0

```

If you are running Windows on your computer, you may need to download a Perl interpreter to run the sample program. Do not attempt to use this script as a model for your solution because (1) Perl is a write-only language and its programs are inscrutable, and (2) the script uses regular expressions rather than finite state machines to solve the problem.

What to turn in

This is actually the first part of a two-part assignment. For this part you should turn in a table similar to the "English" finite state machine specification presented for the "Nabs" machine in the February 5 lecture. If you wish, you can start with an Excel spreadsheet that contains this information. You could also turn in a scanned copy of a drawn finite state machine.

You may turn in either a text file, spreadsheet, or PDF file into moodle for this assignment.