├── Readme.md
├── document.cc
├── document.h
├── makefile
├── test.txt
└── text_editor.cc


/Readme.md:
--------------------------------------------------------------------------------
 1 | ##Text Editor Instructions
 2 | This program is is a basic line editor that is run from the command line.file (test.txt) to edit, but any text file will do.  
 3 | 
 4 | ###Available Commands:
 5 | * g <name> Get an existing file and load it into the editor. (The angle brackets are not typed as part of the command.)
 6 | * n	Turn line numbering on if off and off if on (line numbering on means that the number of each line is displayed at the left when the t command is given). 
 7 | * q	Leave the editor without saving the text.
 8 | * x [name]	leave the editor and save the text in a file. The brackets indicate that the name is optional; if it is left out, the current file name is used. 
 9 | * s [name] 	Save the file under the current name if a new name is not provided, otherwise change the current name to name and save.
10 | * h	Print a screen summarizing the available editor commands.
11 | * a [N]	Start adding text after line N and before line N+1. Pressing return starts a new line, and typing control-D signals the end of add mode. If N is zero or missing, add lines at the beginning of the file.
12 | * t [M [N]] 	Display lines M through N on the screen. If M is given but not N, display only line M; if neither is given, display the whole document.
13 | * d M [N] 	Delete lines M through N (just line M if N is not given) and move the remaining lines up to fill the gap.
14 | * m  M [N] L 	Move lines M through N so that they come immediately after line L (and they no longer appear at their current location). When N is missing, move just line M
15 | * c M [N] L 	Copy lines M through N so that they come immediately after line L (but they still appear at their original location). When N is missing, copy just line M
16 | * f [M [N]] /word/ 	Display each line between M and N on which word appears. The slash characters are part of the command, not part of the string to be found. 
17 | * R [M [N]] /old/new/	Replace each occurrence of string old with string new on each of lines M through N. The slash characters are part of the command, not part of the strings.
18 | 


--------------------------------------------------------------------------------
/document.cc:
--------------------------------------------------------------------------------
  1 | //Craig Barstow 
  2 | //Document.cc 
  3 | //File containing the functions for the text_ed class
  4 | 
  5 | #include <iostream>
  6 | #include <fstream>
  7 | #include <string>
  8 | using namespace std;
  9 | #include "document.h"
 10 | const int DEFCAP = 5;
 11 | 
 12 | //Note that the document holds capacity lines, numbered 1... capacity.
 13 | //Spot 0 in the array is ignored, so array length is always "capacity+1"
 14 | 
 15 | //PRIVATE
 16 | 
 17 | bool text_ed::copy_to_buffer(int start, int end) {  // Copy lines start through end to the buffer.
 18 |   int buff_capacity=end-start+1;
 19 |   int i,j,k;
 20 |   buffer= new string [buff_capacity+1]; 
 21 |   for (i=start,j=0; i<=end; i++,j++) { //copy document contents into buffer
 22 |     buffer[j]=document[i];
 23 |   }
 24 |   return true;
 25 | }
 26 | 
 27 | bool text_ed::copy_to_document(int start, int end, int location) { // Copy the entire buffer to the document starting at line start.
 28 |   int buff_capacity=end-start+1;
 29 |   int i,j;
 30 |   for (i=location+1,j=0; j<buff_capacity; i++,j++) {
 31 |     document[i]=buffer[j]; //copy buffer contents to document
 32 |   }
 33 |   delete [] buffer;
 34 |   buffer = NULL; //set buffer pointer to null so destructor function works properly
 35 |   return true;
 36 | }
 37 | 
 38 | bool text_ed::open_up(int start, int num_lines) { // Create num_lines empty lines following start.
 39 |  int space_left;
 40 |  int i;
 41 |  space_left = capacity-last_line;
 42 |  while (space_left <=num_lines) {
 43 |    expand_document();
 44 |    space_left = capacity - last_line;
 45 |  }
 46 |  for (i=last_line; i>start; i--) {
 47 |    document[i+num_lines] = document[i];
 48 |  }
 49 |  last_line += num_lines;
 50 |  return true;
 51 | }
 52 | 
 53 | void text_ed::expand_document() { // Add more lines to the document array, e.g., double capacity.
 54 |  int i;
 55 |  capacity *= 2; //double document capacity
 56 |    string* temp = new string[capacity+1];
 57 |    for (i=0; i<capacity/2; i++) { //copy contents of document into temp
 58 |      temp[i]=document[i];
 59 |    }
 60 |    delete [] document; //delete contents of original document
 61 |    document = temp; //set document equal to temp contents of temp
 62 | }
 63 | 
 64 | // PUBLIC
 65 | 
 66 | text_ed::text_ed() { //constructor function
 67 |  capacity = DEFCAP;
 68 |  last_line = 0;
 69 |  document = new string[capacity+1];
 70 |  buffer = NULL;
 71 |  buffer_size = 0;
 72 | }
 73 | 
 74 | text_ed::text_ed(text_ed& rhs) { //copy constructor
 75 |  document = NULL;
 76 |  (*this) = rhs;
 77 | }
 78 | 
 79 | text_ed& text_ed::operator=(text_ed& rhs) { //overloading assignment
 80 |  if ( this != &rhs ) {
 81 |    delete [] document;
 82 |    last_line = rhs.last_line;
 83 |    capacity = rhs.capacity;
 84 |    document = new string[capacity];
 85 |    for (int i=0; i<last_line; i++) {
 86 |      document[i] = rhs.document[i];
 87 |    }
 88 |  }
 89 |  return (*this);
 90 | }
 91 | 
 92 | text_ed::~text_ed() { //destructor function
 93 |  delete [] document;
 94 |  delete [] buffer;
 95 | }
 96 | 
 97 | string text_ed::filename() { // Return current_file.
 98 |  return current_file;
 99 | }
100 | 
101 | int text_ed::get_last_line() { // Return last_line.
102 |  return last_line;
103 | }
104 | 
105 | bool text_ed::load_file(string filename) { // Read the file and remember the name in current_file.
106 |  string nextline;
107 |  current_file = filename;
108 |  last_line=0;
109 |  ifstream form (filename.c_str());
110 |  while (getline(form,nextline)) { //while lines can be retrieved, insert them into document array
111 |    insert_line(nextline,last_line);
112 |  }
113 |  form.close();
114 |  return true;
115 | }
116 | 
117 | bool text_ed::save_file() { //function to check if saving to a given filename is possible and save it
118 |  if (save_file(current_file)) { 
119 |  return true;
120 |  } else {
121 |    return false;
122 |  }
123 | }
124 | 
125 | bool text_ed::save_file (string filename) { // Save the text under the new name; remember the new name in current_file.
126 |  ofstream savefile;
127 |  int i;
128 |  savefile.open(filename.c_str());
129 |  for (i=1; i<=last_line; i++) { //save each line from document arry to file
130 |    savefile << document[i]; 
131 |    savefile << endl;
132 |  }
133 |  savefile.close();
134 |  return true;
135 | }
136 | 
137 | bool text_ed::insert_line(string newline,int n) { // Insert newline as a new line following line n.
138 |  open_up(n,1);
139 |  document[n+1] = newline;
140 |  if (n > last_line-1) {
141 |    n=last_line+1;
142 |      }
143 |  return true;
144 | }
145 | 
146 | bool text_ed::delete_lines(int start, int end) { // Delete lines from start position to end position.
147 |   int i;
148 |   int num_lines = end-start;
149 |   for (i=start; i<=last_line; i++) { //delete lines from start to end positions
150 |     document[i] = document[i+num_lines+1];
151 |   }
152 |   last_line = last_line-num_lines-1;
153 |   return true;
154 | }
155 | 
156 | bool text_ed::get_line(string& dest, int n) { // Copy line n into dest.
157 |   if (n>last_line) {
158 |     return false;
159 |   }
160 |  dest = document[n];
161 |  return true;
162 | }
163 | 
164 | bool text_ed::copy_lines(int start, int end, int location) { //copy lines start through end to follow line location.
165 |   int buff_capacity=end-start+1;
166 |   copy_to_buffer(start,end);
167 |   open_up(location, buff_capacity);
168 |   copy_to_document(start,end,location);
169 |   return true;
170 | }
171 | 
172 | bool text_ed::move_lines(int start, int end, int location) { //move lines between two given lines (start to end) to after the given line location
173 |   if (location<start || location>end) { //make sure new line location isnt between the start and end selections
174 |     copy_lines(start,end,location);
175 |     delete_lines(start,end); //delete the original lines so there aren't duplicates
176 |     return true;
177 |   } else {
178 |     cout << "Error. Make sure location given is not between the two lines selected." << endl;
179 |     return false;
180 |   }
181 | }
182 | 
183 | bool text_ed::replace(string oldstr, string newstr, int start, int end) { //replace old word with new word between given lines (start to end)
184 |   int i, j;
185 |   for (i=start; i<=end; i++) { //for each line in the given area
186 |     for(j=0;j<document[i].length(); j++){ //for character in string
187 |       if(document[i].substr(j,oldstr.length())==oldstr){ //if substring found starting at the character position
188 | 	document[i].replace(j,oldstr.length(),newstr); //replace old string with new string
189 |       }
190 |     }
191 |   }
192 |   return true;
193 | }
194 | 


--------------------------------------------------------------------------------
/document.h:
--------------------------------------------------------------------------------
 1 | //Craig Barstow
 2 | //Document.h
 3 | //Header file for text_ed class
 4 | 
 5 | class text_ed {
 6 |  private:
 7 |   string *document; // Array of strings, one for each line
 8 |   string *buffer;   // A scratch area; makes copy and move easier
 9 | 
10 |   int last_line,buffer_size,capacity;
11 | 
12 |   string current_file; // The name of the file being edited
13 | 
14 |   bool copy_to_buffer(int start, int end);
15 |      // Copy lines start through end to the buffer.
16 |   bool copy_to_document(int start, int end, int location);
17 |      // Copy the entire buffer to the document starting at line start.
18 |   bool open_up(int start, int num_lines);
19 |      // Create num_lines empty lines following start.
20 |   void expand_document(); 
21 |      // Add more lines to the document array, e.g., double capacity.
22 | 
23 |  public:
24 |   text_ed();
25 |   text_ed(text_ed&);
26 |   text_ed& operator=(text_ed&);
27 |   ~text_ed();
28 |   string filename();
29 |      // Return current_file.
30 |   int get_last_line();
31 |      // Return last_line.
32 |   bool load_file(string filename);  
33 |      // Read the file and remember the name in current_file.
34 |   bool save_file();
35 |      //function to check if saving to a given filename is possible and save it
36 |   bool save_file(string filename);  
37 |      // Save the text under the new name; remember the new name 
38 |      // in current_file.
39 |   bool insert_line(string newline,int n);
40 |      // Insert newline as a new line following line n.
41 |   bool delete_lines(int start, int end);
42 |      // Delete lines from start position to end position.
43 |   bool get_line(string& dest, int n);
44 |      // Copy line n into dest.
45 |   bool copy_lines(int start, int end, int location);
46 |      // Copy lines start through end to follow line location.
47 |   bool move_lines(int start, int end, int location);
48 |      // Move lines start through end to follow line location.
49 |   bool replace(string oldstr, string newstr, int start, int end);
50 |      // Replace oldstr with newstr on lines start through end.
51 | };
52 | 


--------------------------------------------------------------------------------
/makefile:
--------------------------------------------------------------------------------
1 | text_editor: text_editor.o document.o
2 | 	g++ -o text_editor text_editor.o document.o
3 | 
4 | text_editor.o: text_editor.cc document.h
5 | 	g++ -c text_editor.cc
6 | 
7 | document.o: document.cc document.h 
8 | 	g++ -c document.cc 


--------------------------------------------------------------------------------
/test.txt:
--------------------------------------------------------------------------------
 1 | Test File
 2 | line 2 
 3 | line 3 
 4 | line 4 
 5 | line 5 
 6 | line 6 
 7 | line 7 
 8 | line 8  
 9 | line 9 
10 | line 10
11 | line 11
12 | line 12
13 | line 13
14 | line 14
15 | line 15
16 | line 16
17 | line 17
18 | line 18
19 | line 19
20 | line 20
21 | 


--------------------------------------------------------------------------------
/text_editor.cc:
--------------------------------------------------------------------------------
  1 | //Craig Barstow
  2 | //Test Editor
  3 | 
  4 | #include <iostream>
  5 | #include <fstream>
  6 | #include <iomanip>
  7 | #include <string>
  8 | #include <math.h>
  9 | #include <locale>
 10 | #include <sstream>
 11 | using namespace std;
 12 | #include "document.h"
 13 | #define NOT_FOUND -1
 14 | 
 15 | void Show_Commands() { //display all available commands
 16 |  cout << "h                        Show this list" << endl;
 17 |  cout << "g <name>                 Get a file" << endl;
 18 |  cout << "n                        Toggle line numbering" << endl;
 19 |  cout << "q                        Quit without saving file" << endl;
 20 |  cout << "x [name]                 Save file and exit" << endl;
 21 |  cout << "s [name]                 Save file" << endl;
 22 |  cout << "a [N]                    Add lines after line N" << endl;
 23 |  cout << "t [M [N]]                Type lines M through N" << endl;
 24 |  cout << "d M [N]                  Delete lines M through N" << endl;
 25 |  cout << "m M [N] L                Move lines M through N to follow line L" << endl;
 26 |  cout << "c M [N] L                Copy lines M through N to follow line L" << endl;
 27 |  cout << "f [M [N]] /word/         Type lines M through N containing word" << endl;
 28 |  cout << "r [M [N]] /word1/word2/  Replace word1 by word2 on lines M through N" << endl;
 29 | }
 30 | 
 31 | bool get_file(text_ed & T, string cl) { //load file to be edited
 32 |  string filename;
 33 |  string::size_type start,end;
 34 |  start = cl.find_first_not_of(' ',1); //find start of filename substring starting after the 'g' command
 35 |  if (start == string::npos) { //if string not found return false
 36 |    return false;
 37 |  }
 38 |  end = cl.find(' ',start);
 39 |  if ( end == string::npos ) { //if end of filename substring cant be found, set it equal to the end of the string
 40 |    end = cl.size();
 41 |  }
 42 |  filename = cl.substr(start,end-start);
 43 |  return T.load_file(filename); //load the file 
 44 | }
 45 | 
 46 | bool save_file(text_ed & T, string cl) { //take out couts
 47 |   string fn, new_name,CL=cl;
 48 |   int start,end;
 49 |   bool ok;
 50 |   string current_file = T.filename();
 51 |   if (cl.find_first_not_of(" ", 1)==string::npos) {  //if no filename given, save as current filename
 52 |     T.save_file(current_file); 
 53 |     cout << "Saved as \"" << current_file <<"\""<< endl;
 54 |     return true;
 55 |   } else { //if filename give after s in command line, save as given filename
 56 |     new_name = cl.substr(2,cl.length());
 57 |     ok = T.save_file(new_name);
 58 |     if (!ok) { //if it cant save to the given filename return an error message
 59 |       cout << "Can't save to file \"" << T.filename() << "\"." << endl;
 60 |     }
 61 |     return ok; //return the boolean value indicating whether the save was successful
 62 |   }
 63 | }
 64 | 
 65 | bool type_lines(text_ed & T, string cl, bool toggle) { //type lines between two given integers. If only one integer is given, type just that line. If no integers are given, type the whole document.
 66 |   bool error_state=false;
 67 |   string aline,m_string,n_string;
 68 |   int i=0,m=0,n=0,p=1,m_begin, m_end, n_begin, n_end,document_length,count=0;
 69 |   if (cl.find_first_not_of(" ",1)!=string::npos){ //this section selects the first integer from the substring
 70 |     m_begin= cl.find_first_not_of(" ",1);
 71 |     m_end = cl.find_first_of(" ", m_begin)-2;
 72 |     m_string=cl.substr(m_begin,m_end);
 73 |     if (!(istringstream(m_string) >> m)) { //if the substring cant be converted to an integer, set error state to false
 74 |       error_state=true;
 75 |     } else {count++;} //if it can be converted, increment the count
 76 |     if (cl.find_first_not_of(" ", m_end+2)!=string::npos){ //this section selects the second integer from the substring
 77 |       n_begin = cl.find_first_not_of(" ", m_end+2);
 78 |       n_end = cl.find_first_of("",n_begin);
 79 |       n_string=cl.substr(n_begin,n_end);
 80 |       if (!(istringstream(n_string) >> n)){
 81 | 	error_state=true;
 82 |       } else {count++;} //if it can be converted, increment the count
 83 |     }
 84 |     //SECTION TO MAKE SURE INTEGERS MAKE SENSE
 85 |     if (m<=0){ //if the line number is below 1, this automatically sets it to one
 86 |       error_state=true;
 87 |     }
 88 |     document_length = T.get_last_line();
 89 |     if (m>document_length) { //this makes sure that the starting position is less than the last line of the document
 90 |       error_state = true;
 91 |       cout << "The first line number given exceeds file length." << endl;
 92 |     }
 93 |     if (n>document_length) { //if the ending position is greater than the document length, toggle error state to true
 94 |       error_state=true;
 95 |     }
 96 |     if (count!=1 && n<m){ //if both a  start position and an end position are put in, and the end value is greater than the starting value, the error state will be toggled to true
 97 |       error_state=true;
 98 |     }
 99 |   }
100 |   if (!error_state) { 
101 |     switch (count) {
102 |     case 0: //if no integers are input, print the entire document
103 |       n = T.get_last_line();
104 |       for (i = 1; i<=n ;i++) {
105 | 	if (toggle) { //if toggling line numbers is on, print line numbers
106 | 	  cout << setw(2) << i << "  ";
107 | 	}
108 | 	if (T.get_line(aline,i)) { //if the given line can be retrieved, display it
109 | 	  cout << aline << endl;
110 | 	} else { //if it can't, return false
111 | 	  return false;
112 | 	}
113 |       }      
114 |       break;
115 |     case 1: //if one integer is input, print just that line
116 |       if (toggle) { //if toggling line numbers is on, print line numbers
117 | 	cout << setw(2) << m << "  ";
118 |       }
119 |       if (T.get_line(aline,m)) { //if the line can be retrieved, display it
120 | 	cout << aline << endl;
121 |       } else {return false;} 
122 |       break; 
123 |     case 2:
124 |       for (i = m; i<=n; i++){ // for each line between the start and end line positions
125 | 	if (toggle) { //if toggling line numbers is on, print the line numbers
126 | 	  cout << setw(2) << i << " ";
127 | 	} 
128 | 	if (T.get_line(aline,i)) { //if the line can be retrieved, display it
129 | 	  cout << aline << endl;
130 | 	} else {
131 | 	  return false;
132 | 	}
133 |       }
134 |       break;
135 |     }
136 |     return true;
137 |   }
138 |   return false;
139 | }
140 | 
141 | bool add_lines (text_ed & T, string cl) { //add lines to the array representing the document, but don't save it
142 |   bool error_state = false;
143 |   int m_begin, m_end, m, count=0;  
144 |   string new_line, m_string;
145 |   if (cl.find_first_not_of(" ",1)!=string::npos){ //this section selects the integer from the substring
146 |     m_begin= cl.find_first_not_of(" ",1);
147 |     m_end = cl.find_first_of(" ", m_begin)-2;
148 |     m_string=cl.substr(m_begin,m_end);
149 |     if (istringstream(m_string) >> m) { //if the substring can be converted to an integer, increment the count
150 |       count++;
151 |     }
152 |     //SECTION TO MAKE SURE INTEGER MAKES SENSE
153 |     if ((m < 0 || m > T.get_last_line()) && count==1) {
154 |       error_state=true;
155 |     }
156 |     if (count==1 && m==0) { //if m is equal to zero, set count to zero so lines will be added at the beginning of the document
157 |       count=0;
158 |     }
159 |   }
160 |   if (!error_state) {
161 |     switch (count) {
162 |     case 0: //if no integer is present, add lines starting at document start
163 |       cout << " Press Control +  D to stop"<<endl;
164 |       while (getline(cin,new_line)){ //continue accepting new lines until ctrl d is entered
165 | 	T.insert_line(new_line,m=0);
166 | 	m++;
167 |       }
168 |       cin.clear();
169 |       cout << endl;
170 |       break;
171 |     case 1:
172 |       cout << " Press control-D to stop"<<endl;
173 |       while (getline(cin,new_line)){ //continue accepting new lines until ctrl d is entered
174 | 	T.insert_line(new_line,m);
175 | 	m++;
176 |       }
177 |       cin.clear();
178 |       cout << endl;
179 |       break;
180 |     default:
181 |       return false;
182 |     }
183 |     return true; //return true after running switch statement contents
184 |   }
185 |     return false; //return false if error state is true
186 | }
187 | 
188 | bool delete_line (text_ed & T, string cl) { //delete lines between two given line positions. If only one position is given, delete just that line
189 |   bool error_state=false;
190 |   string aline,M_string,N_string;
191 |   int i = 0,m=0,n=0,p=1,m_start, m_end, n_start, n_end,number, count=0;
192 |   if (cl.find_first_not_of(" ",1)!=string::npos){ //if first integer is part of substring isolate it
193 |     m_start= cl.find_first_not_of(" ",1);
194 |     m_end = cl.find_first_of(" ", m_start)-2;
195 |     M_string=cl.substr(m_start,m_end);
196 |     if (!(istringstream(M_string) >> m)) { //if substring representing first integer can't be converted to integer form, toggle error state to true
197 |       error_state=true;
198 |     } else {count++;} //else, increment count to show that first integer is present
199 |     if (cl.find_first_not_of(" ", m_end+2)!=string::npos){ //if second integer is part of substring isolate it
200 |       n_start = cl.find_first_not_of(" ", m_end+2);
201 |       n_end = cl.find_first_of("",n_start);
202 |       N_string=cl.substr(n_start,n_end);
203 |       if (!(istringstream(N_string) >> n)){ //if substring representing second integer can't be converted to int form, toggle error state to true
204 | 	error_state=true;
205 |       } else {count++;} //increment count to show that second integer is present
206 |     }
207 |     //section to make sure the integer values are reasonable
208 |     if (m<=0){ //if integer value of starting position is less 1, toggle error
209 |       error_state=true;
210 |     }
211 |     if (count==2) { //if two integers are present, if second is less than first, or if first is greater than document length, toggle error state
212 |       if (n<m || n>T.get_last_line()) {
213 | 	error_state=true;
214 |       }
215 |     }
216 |     if (!error_state) {
217 |       if (count==2){ //if two integers are present, delete the lines between them
218 | 	T.delete_lines(m,n);
219 |       }
220 |       else if (count==1) { //if one integer is present, delete just that line
221 | 	T.delete_lines(m,m);
222 |       }
223 |     } else {
224 |       return false; //return false if something other than 1 or two integers are present
225 |     } return true; //if !error_state
226 |   }
227 |   return false; //return false if nothing is found after the 'd' statement in the command line, or if error state is true
228 | }
229 | 
230 | bool copy_line (text_ed & T, string cl) { //Copy area between two given line numbers (inclusive) to after a third given line number if three numbers are given. If only two integers are given, move the line at the first position to after the position given by the second integer
231 |   bool error_state=false;
232 |   string aline,M_string,N_string,O_string;
233 |   int i = 0,m=0,n=0,o=0,p=1,m_start, m_end, n_start, n_end, o_start, o_end, number, count=0;
234 |   if (cl.find_first_not_of(" ",1)!=string::npos){ //section to isolate the first integer from the string entered into the command line
235 |     m_start= cl.find_first_not_of(" ",1);
236 |     m_end = cl.find_first_of(" ", m_start)-2;
237 |     M_string=cl.substr(m_start,m_end);
238 |     if (!(istringstream(M_string) >> m)) { //if the substring representing the first integer cannot be converted to an integer, toggle the error state to true
239 |       error_state=true;
240 |       m=1;
241 |     } else {count++;} //increment count to show one integer is present
242 |     if (cl.find_first_not_of(" ", m_end+2)!=string::npos){ //section to isolate the second integer from the string entered into the command line
243 |       n_start = cl.find_first_not_of(" ", m_end+2);
244 |       n_end = cl.find_first_of(" ",n_start);
245 |       N_string=cl.substr(n_start,n_end);
246 |       if (!(istringstream(N_string) >> n)){ //if the substring representing the second integer cannot be converted to an integer, toggle the error state to true
247 | 	error_state=true;
248 |       } else {count++;} //increment count to show that two integers are present
249 |       if (cl.find_first_not_of(" ", n_end+1)!=string::npos) { //section to isolate the third integer from the string entered into the command line
250 | 	  o_start = cl.find_first_not_of(" ", n_end+1);
251 | 	  o_end = cl.find_first_of("",o_start);
252 | 	  O_string=cl.substr(o_start,o_end);
253 | 	  if (istringstream(O_string) >> o){ //if substring can be converted to an integer, increment count to show a third integer is present
254 | 	    count++; 
255 | 	  } 
256 | 	}
257 |     }
258 |     //SECTION TO MAKE SURE INTEGERS MAKE SENSE
259 |     if (m<1){ //if first integer is less than 1, toggle error state to true
260 |       error_state=true;
261 |     }
262 |     if (n>T.get_last_line()) { //if second int is greater than document length, toggle error state
263 |       error_state=true;
264 |     }
265 |     if (n<1) { //if second it is less than one, toggle error state to true
266 |       error_state=true;
267 |     }
268 |     if (count==3) {
269 |       if (n<m) { //if three integers are present and the first 
270 | 	error_state = true;
271 |       }
272 |       if (o<=0) { //if the third integer is less than three, toggle error state to true
273 | 	error_state = true;
274 |       }
275 |       if (o>T.get_last_line()) { //if third integer is greater than document length, reset it
276 | 	o=T.get_last_line();
277 |       }
278 |     }
279 |     if (!error_state) { 
280 |       if (count==3){ //if three integers are present, copy lines from the start position to the end position to after the given location
281 | 	T.copy_lines(m,n,o);
282 |        }
283 |       else if (count==2) { //if two integers are present, copy the line given by the first position to after the position denoted by the second integer
284 | 	T.copy_lines(m,m,n);
285 |       }	
286 |       return true; //return true if error state is false
287 |     } else {
288 |       return false; //return false if error state is true
289 |     }
290 |   }
291 |   return false; //return false if nothing is found after the initial 'c' substring in the input string
292 | }
293 | 
294 | bool move_line (text_ed & T, string cl) {
295 |   bool error_state=false;
296 |   string aline,M_string,N_string,O_string;
297 |   int i = 0,m=0,n=0,o=0,p=1,m_start, m_end, n_start, n_end, o_start, o_end, number, count=0;
298 |   if (cl.find_first_not_of(" ",1)!=string::npos){ //section to isolate the substring representing the first integer from the given string
299 |     m_start= cl.find_first_not_of(" ",1);
300 |     m_end = cl.find_first_of(" ", m_start)-2;
301 |     M_string=cl.substr(m_start,m_end);
302 |     if (!(istringstream(M_string) >> m)) { //if substring cant be converted to an integer, toggle error state to true
303 |       error_state=true;
304 |     } else {count++;} //if it can, increment count to show first integer is present
305 |     if (cl.find_first_not_of(" ", m_end+2)!=string::npos){ //section to isolate the substring representing the second integer from the given string
306 |       n_start = cl.find_first_not_of(" ", m_end+2);
307 |       n_end = cl.find_first_of(" ",n_start);
308 |       N_string=cl.substr(n_start,n_end);
309 |       if (!(istringstream(N_string) >> n)){ //if substring cant be converted to an integer, toggle error state to true
310 | 	error_state=true;
311 |       } else {count++;} //if it can be, increment count to show second integer is present
312 |       if (cl.find_first_not_of(" ", n_end+1)!=string::npos) { //section to isolate the substring representing the third integer from the given string
313 | 	o_start = cl.find_first_not_of(" ", n_end+1);
314 | 	o_end = cl.find_first_of("",o_start);
315 | 	O_string=cl.substr(o_start,o_end);
316 | 	if (istringstream(O_string) >> o){ //if substring can be converted to an integer, increment count to show third integer is present
317 | 	  count++;
318 | 	} 
319 |       }
320 |     }
321 |     //SECTION TO MAKE SURE THE INTEGERS MAKE SENSE
322 |     if (m<=0){ //if first integer is less than 1, toggle error state to true
323 |       error_state=true;
324 |     }
325 |     if (count<=2){
326 |       if (n>T.get_last_line()) { //if second int is greater than document length, reset it
327 | 	n=T.get_last_line();
328 |       }
329 |       if (n<=0) { //if second it is less than zero, toggle error state to true
330 | 	error_state=true;
331 |       }
332 |     }
333 |     if (count==3) {
334 |       if (n<m) { //if three integers are present and the first 
335 | 	error_state = true;
336 |       }
337 |       if (o<=0 || o>T.get_last_line()) { //if the third integer is less than three, toggle error state to true
338 | 	error_state = true;
339 |       }
340 |     }
341 |     if (!error_state) {
342 |       if (count==3){ //if three integers are present, move the lines from the first to the second integer to after the position given by the third integer
343 | 	T.move_lines(m,n,o);
344 |        } else if (count==2) { //if two integers are present, move the first line to after the position given by the second
345 | 	T.move_lines(m,m,n); //n+1
346 |       }	else if (count==1) {
347 | 	return false;  //return false if only one integer is found
348 |       }
349 |       return true; //if error state is false, return true
350 |     }
351 |   }
352 |   return false; //if error state is true or the first integer isnt found, return false
353 | }
354 | 
355 | bool find_and_type(text_ed & T, string cl, bool toggle) { //search area from first given line to second for a given word. Type all lines where word is found.
356 |   bool error_state=false;
357 |   string aline,m_string,n_string, word;
358 |   int i = 0,m=0,n=0,p=1,m_begin, m_end, n_begin, n_end,document_length, word_start, word_end,count=0; 
359 |   if (cl.find_first_not_of(" ",1)!=string::npos){ //section to isolate substring representing the first integer from the string
360 |     m_begin= cl.find_first_not_of(" ",1);
361 |     m_end = cl.find_first_of(" ", m_begin)-2;
362 |     m_string=cl.substr(m_begin,m_end);
363 |     if (istringstream(m_string) >> m) { //if substring can be converted to an integer, increment count to show the first integer is present
364 |       count++;}
365 |     if (cl.find_first_not_of(" ", m_end+2)!=string::npos){ //section to isolate substring representing the second integer from the string
366 |       n_begin = cl.find_first_not_of(" ", m_end+2);
367 |       n_end = cl.find_first_of("",n_begin);
368 |       n_string=cl.substr(n_begin,n_end);
369 |       if (istringstream(n_string) >> n){ //if substring can be converted to an integer, increment count to show the second integer is present
370 | 	count++;
371 |       }
372 |     }
373 |     //SECTION TO MAKE SURE THE INTEGER VALUES MAKE SENSE
374 |     document_length = T.get_last_line();
375 |     if ((m<=0 || m>document_length) && count!=0){ //if first integer is less than the starting line number toggle error state on
376 |       error_state=true;
377 |     }
378 |     if (n>document_length) { //if ending integer value is greater than the document length, toggle error state on
379 |       error_state=true;
380 |     }
381 |     if (n<m && count==2){ //if the second integer is greater than the first, toggle error state on
382 |       error_state=true;
383 |     }
384 |   }
385 |   //section to isolate the substring representing the word to be searched for from the string
386 |   if (cl.find_first_of("/")!=string::npos){ 
387 |     word_start = cl.find_first_of("/")+1;
388 |     word_end = cl.find_first_of("/",word_start);
389 |     word = cl.substr(word_start,word_end-word_start); //select the correct substring from the string
390 |   } else { //if word can't be found, return false, as there is no point in continuing
391 |     return false;
392 |   }
393 | 
394 |   if (!error_state) {
395 |     switch (count) {
396 |     case 0: //if no integers are present, search the whole document for the word
397 |       n = T.get_last_line();
398 |       for (i=1; i<=document_length; i++){
399 | 	if (T.get_line(aline,i)) {
400 | 	  if (aline.find(word)!=string::npos){
401 | 	    if (toggle) {  
402 | 	      cout << setw(2) << i << " ";
403 | 	    } else {
404 | 	      cout << " ";
405 | 	    }
406 | 	    cout << aline << endl;
407 | 	  }
408 | 	} else {
409 | 	  cout << "No line " << i << endl;
410 | 	  return false;
411 | 	}
412 |       }
413 |       break;
414 |     case 1: //if 1 integer is present, search just that line for the given word
415 |       if (T.get_line(aline,m)) {
416 | 	if (aline.find(word)!=string::npos){
417 | 	  if (toggle) {  
418 | 	    cout << setw(2) << m << " ";
419 | 	  } else {
420 | 	    cout << " ";
421 | 	  }
422 | 	  cout << aline << endl;
423 | 	} else {
424 | 	  cout << "No line " << i << endl;
425 | 	  return false;
426 | 	}
427 |       }
428 |       break;
429 |     case 2: //if two integers are present, search from the starting int to the ending int for the word
430 |       for (i = m; i<=n; i++){
431 | 	if (T.get_line(aline,i)) {
432 | 	  if (aline.find(word)!=string::npos){
433 | 	    if (toggle) {  
434 | 	      cout << setw(2) << i << " ";
435 | 	    } else {
436 | 	      cout << " ";
437 | 	    }
438 | 	    cout << aline << endl;
439 | 	  }
440 | 	} else {
441 | 	  cout << "No line " << i << endl;
442 | 	  return false;
443 | 	}
444 |       }
445 |     }
446 |     return true; //return true if !error state
447 |   } 
448 |   return false; //return true if error state
449 | }
450 | 
451 | bool find_and_replace(text_ed & T, string cl) { 
452 |   bool error_state=false;
453 |   string aline,m_string,n_string, word, second_word;
454 |   int i = 0,m=0,n=0,p=1,m_begin, m_end,m_length, n_begin, n_end, n_length, document_length, word_start, word_end, second_word_start, second_word_end, count=0;
455 |     //SECTION TO ISOLATE INTEGERS FROM THE GIVEN STRING
456 |   if (cl.find_first_not_of(" ",1)!=string::npos){ //section to isolate first integer from string
457 |     m_begin= cl.find_first_not_of(" ",1);
458 |     m_end = cl.find_first_of(" ", m_begin+1); 
459 |     m_length = m_end-m_begin;
460 |     m_string=cl.substr(m_begin,m_length);
461 |     if (istringstream(m_string) >> m) { //if first substring can be converted to an integer, increment the count to show it is present
462 |       count++;
463 |     }
464 |     if (cl.find_first_not_of(" ", m_end+1)!=string::npos){ //section to isolate second integer from the string
465 |       n_begin = cl.find_first_not_of(" ", m_end+1);
466 |       n_end = cl.find_first_of(" ",n_begin);
467 |       n_length = n_end-n_begin;
468 |       n_string=cl.substr(n_begin,n_length);
469 |       if (istringstream(n_string) >> n){ //if the second substring can be converted to an integer, increment the count to show it is present
470 | 	count++;
471 |       }
472 |     }
473 |   }
474 |    //SECTION TO MAKE SURE THE INTEGER VALUES MAKE SENSE
475 |     document_length = T.get_last_line();
476 |     if ((m<=0 || m>document_length)&& count!=0){ //if first integer is less than the starting line number, set it to the starting line number
477 |       error_state=true;
478 |     }
479 |     if (n>document_length) { //if ending integer value is greater than the document length, toggle error state to true
480 |       error_state=true;
481 |     }
482 |     if (n<m && count==2){ //if the second integer is greater than the first, toggle error state on
483 |       error_state=true;
484 |     }
485 | 
486 |     //SECTION TO ISOLATE WORDS FROM THE STRING
487 |     if (cl.find_first_of("/")!=string::npos){ //portion to isolate first word
488 |       word_start = cl.find_first_of("/")+1;
489 |       word_end = cl.find_first_of("/",word_start);
490 |       word = cl.substr(word_start,word_end-word_start);
491 |     } else {error_state=true;} //if first word can't be found, toggle error state to true
492 |     if (cl.find_first_of("/",word_end+1)!=string::npos){ //portion to isolate the replacement word
493 |       second_word_start = cl.find_first_not_of("/",word_end);
494 |       second_word_end = cl.find_first_of("/",second_word_start);
495 |       second_word = cl.substr(second_word_start, second_word_end-second_word_start);
496 |     } else {error_state=true;} //if second word can't be found, toggle error state to true
497 |     if (!error_state) {
498 |       switch (count) {
499 |       case 0: //if no integers present, find and replace throughout document
500 | 	T.replace(word,second_word,1,document_length); //if no integer present, replace old word with new word throughout the document
501 | 	break;
502 |       case 1: //if one integer is present, find and replace on just that line
503 | 	T.replace(word,second_word,m,m);
504 | 	break;
505 |       case 2: //if two integers present, replace old word with new word from line m to line n
506 | 	T.replace(word,second_word,m,n);
507 | 	break;
508 |       }
509 |       return true;
510 |     } else {
511 |       return false; //if error state is true, return false
512 |     }
513 |   }
514 | 
515 | 
516 | bool Do_Command (text_ed & T, bool& toggle) { //
517 |  char command;
518 |  string command_line;
519 |  bool success, filename_presence=false;
520 |  cout << "File is \"" << T.filename() << "\"." << endl; //print out filename
521 |  cout << "--> ";
522 |  getline(cin,command_line);  //get input from command line
523 |  command = command_line[0];
524 |  switch (command) {
525 |  case 'h':
526 |  case 'H': Show_Commands(); break;
527 |  case 'a':
528 |  case 'A': success = add_lines(T,command_line); break;
529 |  case 'q':
530 |  case 'Q': return false;
531 |  case 's':
532 |  case 'S':
533 |    if (command_line.find_first_not_of(" ",1)!=string::npos) { //if filename is present, toggle bool to true
534 |      filename_presence = true;
535 |    } 
536 |    if (filename_presence) { //if filename is present, save file to filename and retrieve new filename
537 |      success = save_file(T,command_line) && get_file(T,command_line);
538 |    } else { //otherwise save the file under the current name
539 |      success = save_file(T,command_line);
540 |    }
541 |    break;
542 |  break;
543 |  case 't':
544 |  case 'T': success = type_lines(T,command_line, toggle); break;
545 |  case 'x':
546 |  case 'X': success = save_file(T,command_line);
547 | 	   return false;
548 | 	   break;
549 |  case 'g':
550 |  case 'G': success = get_file(T,command_line); break;
551 |  case 'n':
552 |  case 'N': if (!toggle) {
553 | 	    toggle=true;
554 | 	   } else {
555 | 	    toggle=false;
556 | 	   }
557 | 	   success = true; 
558 | 	   break;
559 |  case 'd':
560 |  case 'D': success = delete_line(T,command_line); break;
561 |  case 'c':
562 |  case 'C': success = copy_line(T,command_line); break;
563 |  case 'm':
564 |  case 'M': success = move_line(T,command_line); break;
565 |  case 'f':
566 |  case 'F': success = find_and_type(T,command_line, toggle); break;
567 |  case 'r':
568 |  case 'R': success = find_and_replace(T,command_line); break;
569 |  default: if (command) {
570 |               cout << "\"" << command << "\" is not a valid command." << endl;
571 |       cout << "Type \"h\" for help." << endl;
572 |       success = true;
573 |           } else {
574 |     success = true;
575 |   }
576 |  }
577 |  if ( !success ) cout << "Error" << endl;
578 |  return true;
579 | }
580 | 
581 | int main (int argc, char** argv) {
582 |  bool toggle=true;  //initiate with line numbering on
583 |  text_ed T;
584 |  if (argc > 1) {
585 |    if (!T.load_file(argv[1]))
586 |      cerr << "Could not open file \"" << argv[1] << "\"." << endl;
587 |  }
588 |  bool keep_going;
589 |  do {
590 |    keep_going = Do_Command(T,toggle);
591 |  } while (keep_going);
592 | }
593 | 


--------------------------------------------------------------------------------