I need help with my computer science assignment. its in C++ language. This project is different from the previous two, where you were given skeleton classes with member functions to complete. Its goal is for you to become familiar with the use of the binary search tree by using the Standard Library (SL) implementation of this container: the STL map. It requires you to use existing SL classes to solve a problem, not to fill in the members of those classes as previous projects have done. The project files provide one class, DocumentIndex, with member functions that you must complete. Application The project requires the design and implementation of an application program that creates a page index for a text document. The index must have one line for each word in the document, with a list of page numbers following the word in that line. Here is a sample: Class 12, 34, 56 Warning Be very careful about the format of the lines in your output file. Your index file will be checked by a program that expects the format of the file's lines to conform to the example shown--a single word, a space, a set of numbers separated by a comma and a space. A nonconforming format will cause a test to fail. Document pages are separated by two successive empty lines, created by pressing Return twice after the Return that ends a paragraph. Here is an illustration: Last line of a page First line of next page Words are separated by spaces, tabs, and punctuation, which may be: period (.) comma (,) colon (:) semicolon (;) question mark (?) exclamation point (!) The punctuation should not appear in the index. Words can end with a possessive--an apostrophe followed by an s. The index must contain the word without the 's. Word that contain digits or symbols other those mentioned above must not appear in the index. Words can begin with opening double or single quotation marks, or parentheses; they can end with the corresponding closing character. These marks may enclose a string of words, not just a single word. You do not have to check for matching pairs; you only have strip them off like other punctuation. The marks should not appear in the index. Enclosed words, after the marks are stripped, are subject to the other constraints. For example, the word "Room-131" is not a legal word because of the hyphen and the digits. If a word appears more than once on a page, the page number must appear only once in the index. Words in the exclusion file must not appear in the index. Words that appear more than ten times in the document must not appear in the index. The words in the index must appear in sorted order and the page numbers for each word must appear in sorted order. Classes and Functions The document index program must have a DocumentFile class and a DocumentIndex class with the indicated functions: DocumentFile * Close: Close the document file after it's been used. This function's code will be provided to you. * GetWord: Return the next legal word from the document file, stripping out the allowable punctuation and skipping over the illegal words (those with disallowed characters). * GetPageNumber: Return the current page number. * LoadExclusions: Load the word exclusion list from a file, given the file's name. * Open: Open the document file, given its name. This function's code will be provided to you. * Read: Read the next line of the document file; update the page number if appropriate. DocumentIndex * Create: Create the index from the document file. * Write: Write the index to a file. This list is a summary; the documentindex.h file contains a complete declaration of the classes and the documentindex.cpp file contains definitions of the functions--some skeletons for you to complete and some provided for you to use without having to change them. Implementation You are to use the Standard Library (SL) map class to hold index information. You may find it necessary to use other SL containers within the map's data elements. Remember that the nodes of a tree, which is the structure that the SL map implements, are key/data pairs. The map's insert function takes a key and an associated data element, which can be anything, including a class or structure. The structure can have anything as a member, including other SL containers. Resources Program Files These files will be posted on GitHub for you to download, use or modify, and submit: * documentindex.h: contains declarations of the DocumentFile and DocumentIndex classes. You may add other declarations as needed for your implementation. Do not add definitions (code) to this file; definitions of functions belong in documentindex.cpp. * documentindex.cpp: contains skeletons for the required member functions, either completely empty or partially filled in. You may add other functions, member and nonmember, as needed for your implementation. * getline.cpp: contains the definition of a function that handles text lines with various combinations of line endings--carriage return/line feed. It accommodates the differences between platforms; different editors and word processors use different line endings. * getline.h: contains the declaration of the GetLine function. * main.cpp: contains a set of test functions that will call DocumentIndex's functions. Do not modify this file. Do not submit this file as part of your project; a controlled version will be used to test your submission. Test Files These files are used by main.cpp during testing. They will be posted on GitHub for you to download: * document.txt: contains a large multipage document to be used as input for the CreateIndex function. * excessiveappearances.txt: contains a number of words, some repeated more than the ten allowed times, to be used as input for testing. * exclusions.txt: contains a list of words, one per file line, to be used as input for the LoadExclusions function. * expectedindex.txt: contains a sample index file, created when the document.txt file is used as input. Main.cpp compares it against the actualindex.txt file created during testing. * getword.txt: contains a small document that is simply a collection of legal words, including some with legal punctuation and some with illegal characters such as numbers and symbols; it is used to test the GetWord function. * pagenumber.txt: contains a small document that is primarily a set of pages; it is used to test the "next page" detection function. All of these test files are samples. Do not submit them; your final submission will be tested using different files. References These files, which describe SL classes of interest, will be posted for your use: * map.pdf: a brief description of the relevant map functions--insert, find, erase--including how to insert a key/data pair. * set.pdf: a brief description of the SL set's relevant functions--insert and size. You may find this container interesting or useful. A more extension description of the SL classes and their functions can be found at www.cplusplus.com. This is the code //critic #! /usr/bin/env python3 # -*-Python-*- import os, subprocess, sys HAVE_GITHUB = False try: import github HAVE_GITHUB = True except ImportError: pass COMPILER = 'clang++' MEGABYTE = 1024 * 1024 MAX_SOURCE_FILE_SIZE = 1 * MEGABYTE def print_divider(): print('-' * 79) def is_source_file(path): if not os.path.isfile(path): return False st = os.stat(path) size = st.st_size if size > MAX_SOURCE_FILE_SIZE: return False return True # return True on success or False on failure def command(arg_list): print(' '.join(arg_list)) return_code = subprocess.call(arg_list) return (return_code == 0) # return a list of lines printed to stdout on success, or None on error def command_lines(arg_list): print(' '.join(arg_list)) p = subprocess.Popen(arg_list, stdout=subprocess.PIPE, universal_newlines=True, close_fds=True) stdout_str, stderr_str = p.communicate() if p.returncode != 0: return None else: return stdout_str.splitlines() class Contributor: def __init__(self, name, emails): self.name = name self.emails = emails def find_contributors(): lines = command_lines(['git', 'shortlog', '-s', '-e']) result = [] for line in lines: name_and_email = line[7:] name_part, email_part = name_and_email.split('<') name = name_part.strip() email = email_part.lstrip('<').rstrip('>') result.append(Contributor(name, [email])) return result # return True on success or False on failure def compile(source_path_list, library_name_list, output_path): return command([COMPILER] + ['-g', '-std=c++11'] + source_path_list + ['-l' + lib for lib in library_name_list] + ['-o'] + output_path) def build(): return (compile(['Main.cpp', 'DocumentIndex.cpp', 'GetLine.cpp'], [], ['Project3exe'])) def test(): return (build() and command(['./Project3exe'])) def team(): contribs = find_contributors() print('The following git users have contributed to this repository:') print_divider() for contrib in contribs: print('"' + contrib.name + '"', end="") for email in contrib.emails: print(' <' + email + '>', end="") print('') print_divider() print('') def print_usage(): print('Usage: ' + ' ' + ' critic ' + ' ' + 'Commands: ' + ' ' + ' build compile and link ' ' help print this usage information ' ' team print team members ' ' test compile, then run unit tests ') def usage_error(): print_usage() sys.exit(1) def main(): if len(sys.argv) != 2: usage_error() command = sys.argv[1] if command == 'build': success = build() elif command == 'help': print_usage() success = True elif command == 'team': team() success = True elif command == 'test': success = test() else: usage_error() success = False if not success: sys.exit(1) if __name__ == '__main__': main() //DocumentIndex.h #ifndef DocumentIndex_h #define DocumentIndex_h //**************************************************************************************** // // INCLUDE FILES // //**************************************************************************************** #include #include #include #include using namespace std; //**************************************************************************************** // // CONSTANT DEFINITIONS // //**************************************************************************************** //**************************************************************************************** // // CLASSES, TYPEDEFS AND STRUCTURES // //**************************************************************************************** typedef string::size_type StringSize; class DocumentFile { public: DocumentFile() : pageNumber_(1) { } void Close(); int GetPageNumber(); // Returns the current pge number. string GetWord(); // Returns the next legal word not on the exception list; // returns an empty string if there are no more words in // the line. bool LoadExclusions(const string& name); // Loads a list of words to be excluded from the index // from a file of the given name. bool Open(const string& name); // Opens a document file of the given name. bool Read(); // Reads the next line of the document file, skipping over // the double empty lines that mark page separations. // Returns false if there are no more lines in the file. private: StringSize beginPosition_; fstream file_; int pageNumber_; string text_; }; class DocumentIndex { public: void Create(DocumentFile& documentFile); // Creates an index for the given document file. void Show(ostream& stream); void Write(ostream& indexFile); // Writes the index to the given file. // The argument is a stream so that this function // can be called to wrtite its output to cout for // test purposes. private: }; #endif //DocumentIndex.cpp //**************************************************************************************** // // INCLUDE FILES // //**************************************************************************************** #include #include #include // #include #include "DocumentIndex.h" #include "GetLine.h" using namespace std; //**************************************************************************************** // // CONSTANT DEFINITIONS // //**************************************************************************************** //**************************************************************************************** // // CLASSES, TYPEDEFS AND STRUCTURES // //**************************************************************************************** typedef string::size_type StringSize; //**************************************************************************************** // // PUBLIC DATA // //**************************************************************************************** //**************************************************************************************** // // PRIVATE DATA // //**************************************************************************************** //**************************************************************************************** // // FUNCTION PROTOTYPES // //**************************************************************************************** //**************************************************************************************** // // DocumentFile::Close // //**************************************************************************************** void DocumentFile::Close() { //************************************************************************************ // LOCAL DATA //************************************************************************************ // EXECUTABLE STATEMENTS file_.close(); file_.clear(); return; } //**************************************************************************************** // // DocumentFile::GetPageNumber // //**************************************************************************************** int DocumentFile::GetPageNumber() { //************************************************************************************ // LOCAL DATA //************************************************************************************ // EXECUTABLE STATEMENTS return(pageNumber_); } //**************************************************************************************** // // DocumentFile::GetWord // //**************************************************************************************** string DocumentFile::GetWord() { //************************************************************************************ // LOCAL DATA string word; //************************************************************************************ // EXECUTABLE STATEMENTS return(word); } //**************************************************************************************** // // DocumentFile::LoadExclusions // //**************************************************************************************** bool DocumentFile::LoadExclusions(const string& name) { //************************************************************************************ // LOCAL DATA bool success; //************************************************************************************ // EXECUTABLE STATEMENTS return(success); } //**************************************************************************************** // // DocumentFile::Open // //**************************************************************************************** bool DocumentFile::Open(const string& name) { //************************************************************************************ // LOCAL DATA //************************************************************************************ // EXECUTABLE STATEMENTS file_.open(name, ios::in); if (!file_.fail()) { // You may add any useful initialization here. return(true); } else { return(false); } } //**************************************************************************************** // // DocumentFile::Read // //**************************************************************************************** bool DocumentFile::Read() { //************************************************************************************ // LOCAL DATA bool success; int indx =0; //************************************************************************************ // EXECUTABLE STATEMENTS return(success); } //**************************************************************************************** // // DocumentIndex::Create // //**************************************************************************************** void DocumentIndex::Create(DocumentFile& documentFile) { //************************************************************************************ // LOCAL DATA //************************************************************************************ // EXECUTABLE STATEMENTS return; } //**************************************************************************************** // // DocumentIndex::Write // //**************************************************************************************** void DocumentIndex::Write(ostream& indexStream) { //************************************************************************************ // LOCAL DATA //************************************************************************************ // EXECUTABLE STATEMENTS return; } //GetLline.cpp //**************************************************************************************** // // INCLUDE FILES // //**************************************************************************************** #include #include #include "GetLine.h" using namespace std; //**************************************************************************************** // // CONSTANT DEFINITIONS // //**************************************************************************************** //**************************************************************************************** // // CLASSES, TYPEDEFS AND STRUCTURES // //**************************************************************************************** //**************************************************************************************** // // MACROS // //**************************************************************************************** //**************************************************************************************** // // PUBLIC DATA // //**************************************************************************************** //**************************************************************************************** // // PRIVATE DATA // //**************************************************************************************** //**************************************************************************************** // // FUNCTION PROTOTYPES // //**************************************************************************************** //**************************************************************************************** // // GetLine // // This function reads a series of characters from a stream and puts it into a string, // stopping when it sees a line break: // 1. A carriage return (CR) // 2. A line feed (LF) // 3. A CR/LF pair // 4. A LF/CR pair // The #3 and #4 pairs are a single line break. // The line break (any of the four) is consumed but not added to the output string. // // The return status is true if at least one character, oncluidng a line break, is read; // the status is false if an end-of-file is immediately encountered. // //**************************************************************************************** bool GetLine(istream& stream, string& text) { //************************************************************************************ // LOCAL DATA int c; int p; bool success; //************************************************************************************ // EXECUTABLE STATEMENTS text.erase(); success = false; while (true) { c = stream.get(); if (stream.good()) { success = true; if (c == ' ') { p = stream.peek(); if (p == ' ') { stream.ignore(); } break; } else if (c == ' ') { p = stream.peek(); if (p == ' ') { stream.ignore(); } break; } else { text += c; } } else { break; } } // If we reached the end of file, but at least one character was seen, // including any delimiter, clear the stream's state so the caller won't // ignore the last line of a file. if (success) { stream.clear(); } return(success); } //**************************************************************************************** // // GetLine // // This function reads a series of characters from a stream and puts it into a string, // stopping when it sees any character from a specified delimiter set. The delimiter // is consumed but not added to the output string. // //**************************************************************************************** bool GetLine(istream& stream, string& text, const string& delimiter) { //************************************************************************************ // LOCAL DATA const uint32_t initialMask = 0x80000000; const uint32_t columnMask = 0x1F; const uint32_t rowMask = 0x07; const uint32_t rowShift = 5; char c; uint32_t flag[8]; uint32_t i; uint32_t mask; uint32_t row; uint32_t shift; bool success; //************************************************************************************ // EXECUTABLE STATEMENTS text.erase(); // Set up flags array. for (row = 0; row < (sizeof(flag) / sizeof(flag[0])); ++row) { flag[row] = 0; } for (i = 0; i < delimiter.size(); ++i) { c = delimiter[i]; row = (c >> rowShift) & rowMask; shift = c & columnMask; mask = initialMask >> shift; flag[row] |= mask; } // Get characters until a delimiter is seen or the end of the file // is reached. success = false; while (true) { stream.get(c); if (stream.good()) { // Remember that at least one character has been seen. success = true; // Check for a delimiter. row = (c >> rowShift) & rowMask; shift = c & columnMask; mask = initialMask >> shift; if ((flag[row] & mask) == 0) { // Character isn't a delimiter, save it. text += c; } else { // Character is a delimiter, leave loop. break; } } else { break; } } // If we reached the end of file, but at least one character was seen, // including any delimiter, clear the stream's state so the caller won't // ignore the last line of a file. if (success) { stream.clear(); } return(success); } //GetLine.h #ifndef GetLine_h #define GetLine_h //**************************************************************************************** // INCLUDE FILES #include #include using namespace std; //**************************************************************************************** // CONSTANT DEFINITIONS //**************************************************************************************** // CLASSES, TYPEDEFS AND STRUCTURES //**************************************************************************************** // FUNCTION PROTOTYPES bool GetLine(istream& stream, string& text); bool GetLine(istream& stream, string& text, const string& delimiter); #endif //main.cpp //**************************************************************************************** // // INCLUDE FILES // //**************************************************************************************** #include #include #include #include #include #include "DocumentIndex.h" #include "GetLine.h" using namespace std; //**************************************************************************************** // // CONSTANT DEFINITIONS // //**************************************************************************************** //**************************************************************************************** // // CLASSES, TYPEDEFS AND STRUCTURES // //**************************************************************************************** typedef string::size_type StringSize; //**************************************************************************************** // // PUBLIC DATA // //**************************************************************************************** //**************************************************************************************** // // PRIVATE DATA // //**************************************************************************************** //**************************************************************************************** // // FUNCTION PROTOTYPES // //**************************************************************************************** bool CreateIndexTest(); bool ExcessiveAppearancesTest(); bool ExclusionTest(); bool GetWordTest(); bool PageNumberTest(); //**************************************************************************************** // // MAIN PROGRAM // //**************************************************************************************** int main (int argc, char * const argv[]) { //************************************************************************************ // LOCAL DATA bool pass; int passCount; int score; bool success; string word; //************************************************************************************ // EXECUTABLE STATEMENTS score = 0; passCount = 0; cout << endl << "PageNumberTest (10 points)" << endl; pass = PageNumberTest(); if (pass) { cout << " Pass" << endl; ++passCount; score += 10; } else { cout << " Fail" << endl; } cout << endl << "ExclusionTest (10 points)" << endl; pass = ExclusionTest(); if (pass) { cout << " Pass" << endl; ++passCount; score += 10; } else { cout << " Fail" << endl; } cout << endl << "ExcessiveAppearancesTest (10 points)" << endl; pass = ExcessiveAppearancesTest(); if (pass) { cout << " Pass" << endl; ++passCount; score += 10; } else { cout << " Fail" << endl; } cout << endl << "GetWordTest (20 points)" << endl; pass = GetWordTest(); if (pass) { cout << " Pass" << endl; ++passCount; score += 20; } else { cout << " Fail" << endl; } cout << endl << "CreateIndexTest (30 points)" << endl; pass = CreateIndexTest(); if (pass) { cout << " Pass" << endl; ++passCount; score += 30; } else { cout << " Fail" << endl; } if (passCount == 5) { cout << endl << "All tests passed." << endl << "Score: 80/80." << endl; } else { cout << endl << passCount << " of 5 tests passed." << endl << "Score: " << score << "/80." << endl; } return(0); } //**************************************************************************************** // // CreateIndexTest // //**************************************************************************************** bool CreateIndexTest() { //************************************************************************************ // LOCAL DATA fstream actualIndexFile; string actualLine; DocumentFile documentFile; DocumentIndex documentIndex; uint64_t endActual = 1; uint64_t endExpected = 2; uint64_t endStatus; fstream expectedIndexFile; string expectedLine; bool pass; bool success; string word; //************************************************************************************ // EXECUTABLE STATEMENTS success = documentFile.Open("Document.txt"); if (!success) { cout << "Can't open document file." << endl; return(false); } actualIndexFile.open("ActualIndex.txt", ios::in | ios::out | ios::trunc); if (actualIndexFile.fail()) { cout << "Can't create index file." << endl; return(false); } expectedIndexFile.open("ExpectedIndex.txt", ios::in); if (actualIndexFile.fail()) { cout << "Can't create index file." << endl; return(false); } documentIndex.Create(documentFile); documentIndex.Write(actualIndexFile); // indexFile << endl << endl; // documentIndex.Show(indexFile); actualIndexFile.seekg(0, ios::beg); endStatus = 0; while (true) { GetLine(actualIndexFile, actualLine); if (actualIndexFile.fail()) { endStatus |= endActual; } GetLine(expectedIndexFile, expectedLine); if (expectedIndexFile.fail()) { endStatus |= endExpected; } if (endStatus == (endActual | endExpected)) { pass = true; break; } if (endStatus == 0) { if (actualLine != expectedLine) { pass = false; break; } } else { pass = false; break; } } return(pass); } //**************************************************************************************** // // ExcessiveAppearancesTest // //**************************************************************************************** bool ExcessiveAppearancesTest() { //************************************************************************************ // LOCAL DATA string actualText; DocumentFile documentFile; DocumentIndex documentIndex; string expectedText = "first 1 second 1 "; stringstream indexStream; bool success; string word; //************************************************************************************ // EXECUTABLE STATEMENTS success = documentFile.Open("ExcessiveAppearances.txt"); if (!success) { cout << "Can't open document file." << endl; return(false); } documentIndex.Create(documentFile); documentIndex.Write(indexStream); actualText = indexStream.str(); if (actualText == expectedText) { return(true); } else { return(false); } } //**************************************************************************************** // // ExclusionTest // //**************************************************************************************** bool ExclusionTest() { //************************************************************************************ // LOCAL DATA vector actualWord; DocumentFile documentFile; vector expectedWord = { "some", "words", "to", "include", "and", "some", "to", "or", "to", "or", "to" }; bool pass; bool success; string word; //************************************************************************************ // EXECUTABLE STATEMENTS success = documentFile.Open("ExclusionTest.txt"); if (!success) { cout << "Can't open document file." << endl; return(false); } success = documentFile.LoadExclusions("ExclusionWords.txt"); if (!success) { cout << "Can't load exclusions." << endl; return(false); } while (true) { success = documentFile.Read(); if (!success) { break; } while (true) { word = documentFile.GetWord(); if (!word.empty()) { actualWord.push_back(word); } else { break; } } } if (actualWord.size() == expectedWord.size()) { pass = true; for (uint64_t i = 0; i < actualWord.size(); ++i) { if (actualWord[i] != expectedWord[i]) { pass = false; break; } } } else { pass = false; } return(pass); } //**************************************************************************************** // // GetWordTest // //**************************************************************************************** bool GetWordTest() { //************************************************************************************ // LOCAL DATA vector actualWord; DocumentFile documentFile; vector expectedWord = { "a", "legal", "word", "and", "another", "period", "comma", "colon", "semicolon", "open", "parenthesis", "closed", "parenthesis", "opening", "double", "quote", "closing", "double", "quote", "opening", "single", "quote", "closing", "single", "quote", "OK", "Good" }; bool pass; bool success; string word; //************************************************************************************ // EXECUTABLE STATEMENTS success = documentFile.Open("GetWord.txt"); if (!success) { cout << "Can't open document file." << endl; return(false); } while (true) { success = documentFile.Read(); if (!success) { break; } while (true) { word = documentFile.GetWord(); if (!word.empty()) { actualWord.push_back(word); } else { break; } } } if (actualWord.size() == expectedWord.size()) { pass = true; for (uint64_t i = 0; i < actualWord.size(); ++i) { if (actualWord[i] != expectedWord[i]) { pass = false; break; } } } else { pass = false; } return(pass); } //**************************************************************************************** // // PageNumberTest // //**************************************************************************************** bool PageNumberTest() { //************************************************************************************ // LOCAL DATA int actualPageNumber; DocumentFile documentFile; vector expectedPageNumber = { 1, 1, 1, 2, 2, 3, 3, 3, 3 }; bool pass; bool success; //************************************************************************************ // EXECUTABLE STATEMENTS success = documentFile.Open("PageNumber.txt"); if (!success) { cout << "Can't open document file." << endl; return(false); } pass = true; for (uint64_t i = 0; i < expectedPageNumber.size(); ++i) { success = documentFile.Read(); if (!success) { break; } actualPageNumber = documentFile.GetPageNumber(); if (actualPageNumber != expectedPageNumber[i]) { pass = false; break; } } return(pass); } #if 0 //**************************************************************************************** // // Test // //**************************************************************************************** bool Test() { //************************************************************************************ // LOCAL DATA bool pass; //************************************************************************************ // EXECUTABLE STATEMENTS return(pass); } #endif //ExcessiveAppearances.txt first second second excess excess excess excess excess excess excess excess excess excess excess //ExclusionTest.txt some words to include and some to exclude or to ignore or to forget //ExclusionWords.txt exclude ignore forget //ExpectedIndex.txt A 1, 3 All 2 Application 1 Be 1 Class 1 Classes 2 Close 2 Create 2 CreateIndex 2 Do 2 Document 1 DocumentFile 2 DocumentIndex 1, 2 Enclosed 2 Files 2 First 2 For 2 Functions 2 GetLine 2 GetPageNumber 2 GetWord 2 GitHub 2 Here 1 If 2 Implementation 2 Index 1 It 1, 2 Its 1 Last 1 Library 1, 2 Load 2 LoadExclusions 2 Open 2 Program 2 Project 1 Read 2 References 3 Remember 2 Resources 2 Return 1, 2 SL 1, 2, 3 STL 1 Standard 1, 2 Test 2 The 1, 2 These 2, 3 They 2 This 1, 2 Warning 1 Word 2 Words 2 Write 2 You 2, 3 Your 1 about 1 above 2 accommodates 2 add 2 after 1, 2 against 2 allowable 2 allowed 2 an 1, 2 anything 2 apostrophe 2 appear 2 appears 2 application 1 appropriate 2 are 1, 2 as 1, 2 associated 2 at 3 because 2 become 1 been 2 begin 2 belong 2 between 2 binary 1 brief 3 by 1, 2 call 2 can 2, 3 careful 1 cause 1 change 2 character 2 characters 2 check 2 checked 1 class 1, 2 classes 1, 2, 3 closing 2 code 2 collection 2 colon 2 combinations 2 comma 1, 2 compares 2 complete 1, 2 completely 2 conform 1 constraints 2 contain 2 container 1, 3 containers 2 controlled 2 corresponding 2 created 1, 2 creates 1 current 2 data 2 declaration 2 declarations 2 definition 2 definitions 2 describe 3 description 3 design 1 detection 2 differences 2 different 1, 2 digits 2 disallowed 2 do 2 done 1 double 2 download 2 during 2 each 1, 2 editors 2 either 2 element 2 elements 2 empty 1, 2 enclose 2 end 2 endings 2 ends 1 example 1, 2 exclamation 2 exclusion 2 existing 1 expects 1 extension 3 fail 1 familiar 1 feed 2 files 1, 2, 3 fill 1 filled 2 final 2 find 2, 3 followed 2 following 1 format 1 found 3 from 1, 2 function 2 functions 1, 2, 3 given 1, 2 goal 1 handles 2 have 1, 2 having 2 hold 2 how 3 hyphen 2 if 2 illegal 2 illustration 1 implementation 1, 2 implements 2 including 2 indicated 2 information 2 input 2 insert 2, 3 interest 3 interesting 3 it 2 its 2 just 2 key 2 large 2 legal 2 like 2 line 1, 2 lines 1, 2 list 1, 2 map 1, 2, 3 mark 2 marks 2 matching 2 may 2, 3 member 1, 2 members 1 mentioned 2 modify 2 more 2, 3 multipage 2 must 1, 2 name 2 necessary 2 needed 2 next 2 nodes 2 nonconforming 1 nonmember 2 number 2 numbers 1, 2 off 2 on 2 once 2 one 1, 2 only 2 opening 2 or 2, 3 order 2 other 2 out 2 output 1 over 2 page 1, 2 pages 1, 2 pair 3 pairs 2 paragraph 1 parentheses 2 part 2 partially 2 per 2 period 2 platforms 2 point 2 posted 2, 3 pressing 1 previous 1 primarily 2 problem 1 processors 2 program 1, 2 project 1, 2 projects 1 provide 1 provided 2 punctuation 2 question 2 quotation 2 relevant 3 repeated 2 required 2 requires 1 s 2 sample 1, 2 samples 2 search 1 semicolon 2 separated 1, 2 set 1, 2 should 2 simply 2 single 1, 2 size 3 skeleton 1 skeletons 2 skipping 2 small 2 solve 1 some 2 sorted 2 space 1 spaces 2 string 2 strip 2 stripped 2 stripping 2 structure 2 subject 2 submission 2 submit 2 successive 1 such 2 summary 2 symbols 2 tabs 2 takes 2 ten 2 test 1, 2 tested 2 testing 2 text 1, 2 than 2 their 3 them 2 these 2 they 2 this 1, 2, 3 those 1, 2 times 2 tree 1, 2 twice 1 two 1 update 2 use 1, 2, 3 used 2 useful 3 using 1, 2 various 2 version 2 very 1 were 1 when 2 where 1 which 2, 3 will 1, 2, 3 within 2 without 2 words 2 your 1, 2, 3 //GetWord.txt a legal word and another period. comma, colon: semicolon; (open parenthesis closed parenthesis) "opening double quote closing double quote" 'opening single quote closing single quote' Num9ber OK da-sh Good //PageNumber.txt line 1-1 line 1-2 line 1-3 line 2-1 line 2-2 line 3-1 line 3-2 line 3-3 line 3-4