Concurrency in C+
+

1

Assignment 1

These questions requires the use of C+ which means compiling the program with the u++ command, including
+,
uC++.h as the first include file in each translation unit, and replacing routine main with member uMain::main .
1. Write a semi-coroutine with the following public interface (you may only add a public destructor and private members): _Coroutine FloatConstant { public: enum status { MORE, GOOD, BAD }; // possible status private: status stat;
// current status of match char ch;
// character passed by cocaller void main();
// coroutine main public: status next( char c ) { ch = c;
// communication in resume(); // activate return stat;
// communication out
}
};

which verifies a string of characters corresponds to a C+ floating-point constant described by:
+
floating-constant : signÓÔØ fractional-constant exponent-part ÓÔØ floating-suffixÓÔØ signÓÔØ digit-sequence exponent-part floating-suffixÓÔØ fractional-constant : digit-sequenceÓÔØ “.” digit-sequence digit-sequence “.”
“e” “E” signÓÔØ digit-sequence exponent-part : sign : “+” “-” digit-sequence : digit digit-sequence digit floating-suffix : “f” “l” “F” “L” digit : “0” “1” “2” “3” “4” “5” “6” “7” “8” “9”
(Where XÓÔØ means X ¯ and ¯ means empty.) In addition, there is a maximum of 16 digits for the mantissa
(non-exponent digits) and 3 digits for the characteristic (exponent digits). For example, the following are valid
C/C+ floating-point constants:
+
123.456
-.099
+555.
2.7E+1
-3.555E-12

After creation, the coroutine is resumed with a series of characters from a string (one character at a time). The coroutine returns a status for each character:

¯ MORE means continue sending characters, may yet be a valid string of the language,
¯ GOOD means the characters form a valid floating-point constant but more characters can be sent (e.g., 1.,
.1)
¯ BAD means the last character resulted in a string that is not a floating-point constant.
Except as otherwise noted, the content of this presentation is licensed under the Creative Commons Attribution 2.5 License.

Concurrency in C+
+

2

After the coroutine returns a value of GOOD and the string is complete, the next character passed to the coroutine returns a value of BAD. After the coroutine returns a value of BAD, it must terminate; sending more characters to the coroutine after this point is undefined.
Write a program floatconstant that checks if a string is in a floating-point constant. The shell interface to the floatconstant program is as follows: floatconstant [ infile ]

(Square brackets indicate optional command line parameters, and do not appear on the actual command line.)
If no input file name is specified, input comes from standard input. Output is sent to standard output. For any specified command-line file, check it exists and can be opened. You may assume I/O reading and writing do not result in I/O errors.
The program should:

¯ read a line from the file,
¯ create a FloatConstant coroutine,
¯ pass characters from the input line to the coroutine one at time while the coroutine returns MORE or
GOOD,
¯ stop passing characters when there are no more or the coroutine returns BAD,
¯ terminate the coroutine,
¯ print out result information, and
¯ repeat these steps for each line in the file.
Assume a valid floating-point constant starts at the beginning of the input line, i.e., there is no leading whitespace.
If the end of line is reached while the coroutine is returning MORE, the text is not a floating-point constant.
If the end of line is reached while the coroutine is returning GOOD, the text is a floating-point constant. If the coroutine returns BAD, the text is not a floating-point constant. For every non-empty input line, print the line, how much of the line is parsed, and the string yes if it is a valid floating-point constant and the string no otherwise; print an appropriate warning for an empty input line (i.e., a line containing only ’\n’). The following is some example output:
"+1234567890123456." : "+1234567890123456." yes
"+12.E-2" : "+12.E-2" yes
"-12.5" : "-12.5" yes
"12." : "12." yes
"-.5" : "-.5" yes
".1E+123" : ".1E+123" yes
"-12.5F" : "-12.5F" yes
"" : Warning! Blank line.
"a" : "a" no
"+." : "+." no
" 12.0" : " " no -- extraneous characters "12.0"
"12.0 " : "12.0 " no -- extraneous characters " "
"1.2.0a" : "1.2." no -- extraneous characters "0a"
"0123456789.0123456E-0124" : "0123456789.0123456" no -- extraneous characters "E-0124"

See the C library function isdigit(c), which returns true if character c is a digit.
2. Write a semi-coroutine that filters a stream of text. The filter semantics are specified by command-line options.
This program is logically divided into 3 parts, a reader, a filter (optional), and a writer. The reader and writer are implemented as single coroutines. The filter is implemented as a sequence of coroutines. The coroutines are joined together in a pipeline such that the reader is at the input end of the pipeline, the filter comprises the middle of the pipeline, and the writer is at the output end of the pipeline. Control passes from the reader to the filter to the writer, eventually returning back to the reader. All these coroutines are semi-coroutines.
(In the following, you may not add, change or remove members from a public interface; you may add a destructor and/or private and protected members.)

Concurrency in C+
+

3

Each filter must inherit from the abstract class Filter:
_Coroutine Filter { protected: static const unsigned char end_filter = ’\377’; unsigned char ch; public: void put( unsigned char c ) { ch = c; resume(); }
};

which ensures each filter has a put routine that can be called to transfer a character along the pipeline.
The reader reads characters from the specified input file and passes these characters to the first coroutine in the filter: _Coroutine Reader : public Filter { public: Reader( istream &i, Filter &f );
};

(No coroutine calls the put routine of the reader; all other coroutines have their put routine called.) The reader constructor is given a stream object from which it reads characters, and a filter object that it passes one character at a time from the input. The filter object must therefore be created before the reader object.
The writer is passed characters from the last coroutine in the filter pipeline and writes these characters to the specified output file:
_Coroutine Writer : public Filter { public: Writer( ostream &o );
};

All other filters have the following interface:
_Coroutine filter-name : public Filter { public: filter-name( Filter &f, . . . );
};

where “. . .” is any additional information needed by the filter.
The pipeline is built by uMain from writer to reader, in reverse order to the data flow. Each newly created coroutine is passed to the constructor of its predecessor coroutine in the pipeline. Control then passes to the reader, beginning the flow of data and control from the reader through the filters to the writer. Specifically, when the reader is created at the head of the pipeline, it starts reading characters and passing them to the first filter coroutine in the pipeline (i.e., the first filter on the command line if there is one) by calling the filter’s inherited put members. Each coroutine of the filter is passed characters from the previous coroutine in the pipeline, possibly performing some transformations, and possibly passing characters to the next coroutine in the pipeline. All characters are passed through the pipeline, including control characters (e.g., \n, \t). When the reader reaches end-of-file, it passes the sentinel character ’\377’ through the pipeline and then terminates.
Similarly, each coroutine along the filter must pass the sentinel character through the pipeline and then terminate.
The writer does not print the sentinel character. The reader coroutine can read characters one at a time or in groups, it makes no difference. The writer coroutine can write characters one at a time or in groups, it makes no difference. Filter options are passed to the program via command line arguments. For each filter option, create a coroutine that becomes part of the pipeline. If no filter options are specified, then the output should simply be an echo of the input from the reader to the writer. Assume all filter options are correctly specified and from the list given below, i.e., no error checking is required on the filter options. Hint: scan the command line left-to-right to locate

Concurrency in C+
+

4

and remember the position of each option, and then scan the option-position information right-to-left (reverse order) to create the filters with their specified arguments.
The filter options that must be supported are:
-w The white space option removes all blanks from the beginning and end of lines, and collapses multiple blank

spaces within a line into a single blank space. This option does not affect other white-space characters, such as tab, ’\t’, and newline, ’\n’.
-s If the first non-whitespace character (space, tab, newline are whitespace) after a period, question mark, or exclamation point is a lower case letter, the sentence option changes the letter to upper case. In other words, this option attempts to capitalize the first letter of every sentence. You must deal with the special case of capitalizing the first letter in the pipeline. This case is special because there is no preceding punctuation character. -e key The encrypt option uses key to encrypt the stream. Each byte in the stream is exclusive-or’ed (xor) with successive characters in the key, and the resulting byte is passed along. When the end of key is reached, cycle back to the beginning of key and continue, e.g.:

input file

a

b

c

xor xor xor

3 char. key

S

G

output file

2

%

move key over and encrypt next 3 chars.

J

)

This encryption scheme is reversible, so that encrypting an encrypted file produces the original data. Assume -e and key are separated by spaces, and spaces cannot occur in key. There should be no limit on the length of key.
-h The hex dump option replaces each character in the stream with a string displaying the character’s hex value.
For example, the character ’a’ would be replaced with the string 61, and the character ’0’ (zero) would be replaced with the string 30. The hex values must be generated with the necessary spacing and newlines to look like the following:
7257
2065
4d50
6d50

7469
6874
4920
7473

2065
7461
760a
6964

2061
6220
696f
5c6e

6f63 6f72
6765 6e69
2064 7267
282a

7475 6e69
3a73 2e0a
6d61 616d

Spacing among groups of hex digits is one space, then three spaces, etc. Note, it is possible to convert a character to its hexadecimal value using a simple, short expression.
In addition, design, implement and document one other filter operation that might be useful.
The order in which filter options appear on the command line is significant, i.e., the left-to-right order of the filter options on the command line is the first-to-last order of the filter coroutines. As well, a filter option may appear more than once in a command. Each filter option should be constructed without regard to what any other filters do, i.e., there is no communication among filters using global variables; all information is passed using member put.
The executable program is to be named filter and has the following shell interface: filter [ -filter-options ... ] [ infile [outfile] ]

(Square brackets indicate optional command line parameters, and do not appear on the actual command line.) If no input file name is specified, input from standard input and output to standard output. If no output file name is specified, output to standard output. For any specified command-line file, check it exists and can be opened.
You may assume I/O reading and writing do not result in I/O errors.
NOTE: the routine names read and write are used by the UNIX operating system and cannot be used as routine names in your program.