void fn_make (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
if (words.size() <= 0){
cout << "mkdir: missing operand" << endl;
return;
}
wordvec newData(words.begin()+2, words.end());
wordvec pathvec = split (words[1], "/");
string fullpath = "";
string filename = *(pathvec.end()-1);
for (auto it = pathvec.begin(); it != pathvec.end()-1; ++it)
fullpath += (*it + "/");
inode_ptr res = resolvePath(fullpath, state.getCwd()); //resulting path before filename
if (res == nullptr) return;
inode_ptr file = res->getContents()->getNode(filename); //search directory for filename if existing
if (file != nullptr && res != nullptr) {
if(file->isDirectory()) //getContents()->getNode(words[1])
return;
file->getContents()->writefile(newData);
return;
}
res->getContents()->mkfile(filename);
res->getContents()->getNode(filename)->getContents()->writefile(newData);
inode_ptr ogcwd = state.getCwd();
//inode_ptr newFile = state.getCwd()->getContents()->mkfile(words[1]);
//wordvec newData(words.begin()+2, words.end());
//newFile->getContents()->writefile(newData);
}
void fn_cd (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
/*
if(words.size() > 1) {
wordvec nav_path = split(words[1], "/");
state.final_cd(nav_path);
} else {
wordvec root_dir{};
state.final_cd(root_dir);
}
*/
if(words.size() > 2){
complain() << "cd: Too many arguments" << endl;
return;
}
if(words.size() > 1) path_name_set(words.at(1));
if(words.size() == 1){
state.setCwd(state.get_root());
return;
} else if(words.at(1).at(0) == '/'){
state.setCwd(state.get_root());
}
wordvec nav_path = split(words.at(1), "/");
state.final_cd(nav_path);
}
void print_dir(inode_state& state) {
cout << pathname(state.get_contents().at("."),
state.get_root()->get_inode_nr()) << ":" << endl;
for(auto elem : state.get_contents()) {
cout << "\t" << elem.second->get_inode_nr() << " "
<< elem.second->size() << " "
<< elem.first << " "
<< endl;
}
cout << endl;
}
void fn_cat (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
string filename = *(words.end()-1);
inode_ptr ogcwd = state.getCwd();
inode_ptr res = resolvePath(words[1], state.getCwd());
if (res == nullptr){
throw command_error ("cat: " + filename + ": file does not exist");
return; }
if (res->isDirectory()) return; //error here
cout << res->getContents()->readfile() << endl;
}
void fn_ls (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
inode_ptr ogcwd = state.getCwd();
inode_ptr res = ogcwd;
if(words.size() > 1)
res = resolvePath(words[1], state.getCwd());
if (res == nullptr) return;
auto pathList = res->getContents()->getAllPaths();
state.setCwd(res);
fn_pwd(state, words);
for (size_t i = 0; i < pathList.size(); i++){
cout << pathList[i] << endl;
}
state.setCwd(ogcwd);
}
void fn_rm (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
if (words.size() <= 0) return; //error here?
wordvec pathvec = split(words[1],"/");
string fullpath = "";
string name = *(pathvec.end()-1);
for (auto it = pathvec.begin(); it != pathvec.end()-1; ++it)
fullpath += (*it + "/");
inode_ptr res = resolvePath(fullpath,state.getCwd());
if (res == nullptr) return; //error
inode_ptr rmfile = res->getContents()->getNode(name);
if (res != nullptr && rmfile != nullptr){
if(rmfile->isDirectory()){
if(rmfile->getContents()->getAllPaths().size() <= 2){
res->getContents()->remove(name);
return;
} else { return; /* not empty */ }}
res->getContents()->remove(name);
return;
}
/*
for (auto it = words.begin()+1; it != words.end(); ++it){
state.getCwd()->getContents()->remove(*it);
}
*/
}
void fn_make (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
if(words.size() < 2){
complain() << "make: Specify pathname" << endl;
return;
}
const auto placeholder = state.get_cwd();
if(words.at(1).at(0) == '/'){
state.setCwd(state.get_root());
}
wordvec nav_path = split(words[1], "/");
wordvec insertion(&words[2], &words[words.size()]);
state.final_make_file(nav_path, insertion);
state.setCwd(placeholder);
}
void fn_mkdir (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
inode_ptr cwd = state.get_cwd();
const string filename = words[1];
cwd->mkdirectory(filename, cwd);
}
void fn_prompt (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
string temp;
for(unsigned int i =1; i < words.size(); i++)
temp += words[i] + " ";
state.set_prompt(temp);
}
void fn_rmr (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
if(words.size() == 1){
complain() << "rmr: Specify file name" << endl;
} else if(words.size() > 2){
complain() << "rmr: Too many arguments" << endl;
} else if(words.at(1) == "." or words.at(1) == ".." or
(words.at(1).at(0) == '/' and words.at(1).length() == 1)){
complain() << "rmr: Cannot remove directory" << endl;
} else {
path_name_set(words.at(1));
const auto placeholder = state.get_cwd();
if(words.at(1).at(0) == '/') state.setCwd(state.get_root());
wordvec navpath = split(words[1], "/");
string ffname = navpath.back();
if(navpath.size() == 1){
state.function_rmr(state.get_cwd(), ffname);
return;
}
wordvec filepath(&navpath[0], &navpath[navpath.size() - 1]);
state.function_final_rmr(ffname, filepath);
state.setCwd(placeholder);
}
}
//DONEDONEDONEDONEDONEDONEDONE///////////////////////////////////////
void fn_ls (inode_state& state, const wordvec& words){
bool r = false;
string orig = pathname(state.get_contents().at("."),
state.get_root()->get_inode_nr());
if (words.size() > 1) {
for(auto word = words.begin()+1; word != words.end(); word++) {
if((*word)[0] == '/') r = true;
state.set_cwd(split(*word,"/"), r);
print_dir(state);
state.set_cwd(split(orig,"/"),true);
}
}
else
print_dir(state);
DEBUGF ('c', state);
DEBUGF ('c', words);
}
void fn_lsr (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
inode_ptr ogcwd = state.getCwd();
inode_ptr newCwd = ogcwd;
if (words.size() > 0){
newCwd = resolvePath(words[1], state.getCwd());
state.setCwd(newCwd);
}
auto pathList = newCwd->getContents()->getAllDirs();
wordvec ls {"ls"};
fn_ls(state, ls);
for(int i = 0; i < pathList.size(); i++){
DFS(pathList[i], state);
}
state.setCwd(ogcwd);
}
void fn_pwd (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
if(words.size() > 1) {
complain() << "pwd: Too many arguments" << endl;
return;
}
state.fn_pwd();
}
void fn_prompt (inode_state& state, const wordvec& words){
string str {};
for (auto iter = words.begin()+1; iter != words.end(); ++iter){
str = str + *iter + " ";
}
state.set_prompt(str);
DEBUGF ('c', state);
DEBUGF ('c', words);
}
void fn_make (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
inode_ptr cwd = state.get_cwd();
wordvec w(words.begin() + 1, words.end());
cwd->mkfile(cwd,w);
}
void fn_cd (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
if(words.size() > 2)
throw yshell_exn("Too many operands");
inode_ptr cwd = state.get_cwd();
state.set_cwd(cwd, words[1]);
if(words[1] == "..")
{state.directory_path_name.pop_back();}
else if (state.directory_path_name.size() > 1)
{state.directory_path_name.push_back("/"+words[1]);}
else if (state.directory_path_name.size() == 1)
{state.directory_path_name.push_back(words[1]);}
}
void fn_mkdir (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
if (words.size() <= 0){
cout << "mkdir: missing operand" << endl;
return;
}
//root case?
if (words[1] == "/"){
inode_ptr ogcwd = state.getCwd();
auto root = state.getCwd()->getContents()->mkdir(words[1]);
root->getContents()->setPath("..", ogcwd);
root->getContents()->setPath(".", root);
return;
}
wordvec pathvec = split(words[1], "/");
string dirname = *(pathvec.end()-1);
string fullpath = "";
for (auto it = pathvec.begin(); it != pathvec.end()-1; ++it)
fullpath += (*it + "/");
inode_ptr res = resolvePath(fullpath,state.getCwd());
if (res == nullptr) return;
inode_ptr directory = res->getContents()->getNode(dirname);
if (directory != nullptr && res != nullptr) //if filename exists and path exists
//dont overwrite anything (ie file or directory)
return;
inode_ptr dir = res->getContents()->mkdir(dirname);
dir->getContents()->setPath("..", res);
dir->getContents()->setPath(".",res->getContents()->getNode(dirname));
/*if (state.getCwd()->getContents()->getNode(filename) != nullptr)
return; */
/*
inode_ptr ogcwd = state.getCwd();
for (auto it = words.begin()+1; it != words.end(); ++it){
auto newDir = state.getCwd()->getContents()->mkdir(*it);
newDir->getContents()->setPath("..", ogcwd);
newDir->getContents()->setPath(".", newDir);
}
*/
}
void fn_ls (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
for(unsigned int i = 0; i<state.directory_path_name.size(); i++)
cout << state.directory_path_name[i];
cout << ":\n";
if(words.size() == 1){
inode_ptr cwd = state.get_cwd();
cwd->list_files(cwd);
//treat "ls /" the same as "ls "
} else if(words[1] == "/" and words.size() == 2){
inode_ptr cwd = state.get_cwd();
cwd->list_files(cwd);
}
}
void DFS(string s, inode_state& state){
wordvec newLs {"ls", s};
fn_ls(state, newLs);
auto dirList = state.getCwd()->getContents()->getAllDirs();
if (dirList.size() == 0)
return;
map<string, int> disc;
for (int i = 0; i < dirList.size(); i++){
disc[dirList[i]] = 0;
}
for (auto it = disc.begin(); it != disc.end(); ++it){
if (it->second == 0){
disc[it->first] = 1;
inode_ptr ogcwd = state.getCwd();
state.setCwd(state.getCwd()->getContents()->getNode(it->first));
DFS(it->first, state);
state.setCwd(ogcwd);
}
}
}
void fn_pwd (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
string pwd = state.getCwd()->getContents()->getPwd();
if (pwd.length() == 2){
cout << "/" << endl;
} else {
pwd = pwd.substr(2, pwd.length()-2);
cout << pwd << endl;
}
}
void fn_mkdir (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
//NEED TO CHECK IF THE DIR IS ALREADY IN THE DIR.
if(words.size() < 2){
complain() << "mkdir: Too few arguments" << endl;
} else if(words.size() > 2) {
complain() << "mkdir: Too many arguments" << endl;
} else {
path_name_set(words.at(1));
const auto placeholder = state.get_cwd();
if(words.at(1).at(0) == '/') {
state.setCwd(state.get_root());
}
path_name_set(words.at(1));
wordvec nav_path = split(words.at(1), "/");
state.final_mkdir(nav_path);
state.setCwd(placeholder);
}
}
//DONEDONEDONEDONEDONEDONE
void fn_make (inode_state& state, const wordvec& words){
bool r = false;
wordvec data;
if(words[1][0] == '/') r = true;
wordvec pathname = split(words[1],"/");
for (auto iter = words.begin() + 2; iter != words.end(); iter++){
data.push_back(*iter);
}
state.add_file(data,pathname,r);
DEBUGF ('c', state);
DEBUGF ('c', words);
}
void fn_prompt (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
if(words.size() < 2){
complain() << "prompt: Too few arguments" << endl;
return;
}
string nprompt = "";
wordvec vec (&words[1], &words[words.size()]);
for(const auto& wrd: vec) nprompt += wrd + " ";
state.set_prompt(nprompt);
}
void fn_cat (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
if(words.size() < 2){
complain() << "cat: Too few arguments" << endl;
} else {
const string firstword = words.at(1);
path_name_set(firstword);
if(firstword.at(0) == '/' and firstword.length() > 1){
string navname = firstword.substr(1, firstword.length());
cout << navname << endl;
const auto placeholder = state.get_cwd();
wordvec nav_path {};
nav_path = split(navname, "/");
state.setCwd(state.get_root());
state.final_func_cat(nav_path);
state.setCwd(placeholder);
return;
} else if(firstword.length() == 1 and firstword.at(0) == '/'){
complain() << "cat: /: File is Directory" << endl;
return;
}
wordvec nav_path = split(firstword, "/");
state.final_func_cat(nav_path);
}
}
void fn_exit (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
wordvec vec(&words[1], &words[words.size()]);
string exit_stat_str = "";
for(const auto& wrd : vec) exit_stat_str += wrd;
if(vec.size() == 0){
state.endprog();
throw ysh_exit_exn();
} else {
try {
int exit_stat_int = stoi(exit_stat_str);
exit_status::set(exit_stat_int);
state.endprog();
throw ysh_exit_exn();
} catch (invalid_argument&) {
exit_status::set(127);
state.endprog();
throw ysh_exit_exn();
}
}
}
//ALL THE STUBS
void fn_cat (inode_state& state, const wordvec& words){
if(words.size() > 1) {
for (auto word = words.begin()+1; word != words.end(); word++){
bool r = ((*word)[0] == '/');
cout << state.readfile(split(*word,"/"),r) << endl;
}
}
else {
throw yshell_exn("cat:: no file given");
}
DEBUGF ('c', state);
DEBUGF ('c', words);
}
void cmd::fn_cd(inode_state& state, const util::wordvec& args) {
DEBUGF('c', state);
DEBUGF('c', args);
if (args.size() > 1) {
throw util::yshell_exn("cd: Expecting only one path arg");
}
// If: empty args, cd to root (ie "/")
// elif: args[0] is "/" then cd to root
// else: split args[0] on "/" & cd
state.cd(args.size() == 0
? util::wordvec{"/"}
: (args[0] == "/"
? util::wordvec{"/"}
: util::split(args[0], "/")));
}
void fn_cd (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
inode_ptr ogcwd = state.getCwd();
if (words.size() == 1){
state.setCwd(state.getRoot()->getContents()->getNode("/"));
return;
}
if (words.size() > 2) return;
if (ogcwd == state.getRoot()->getContents()->getNode("/") && words[1] == "..") return;
inode_ptr res = resolvePath(words[1], state.getCwd());
if (res == nullptr) return;
if (!res->isDirectory()) return;
state.setCwd(res);
}
void fn_cat (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
if (words.size() >= 2){
inode_ptr cwd = state.get_cwd();
for(unsigned int i = 1; i<words.size(); i++){
string w(words.at(i));
cwd->locate_plain_file(cwd, w);
cout << '\n';
}
} else if (words.size() == 1){
throw yshell_exn("cat: No filename specified");
}
/*
else if(words.size() > 2){
throw yshell_exn("cat: Too many operands");
}
*/
}
void fn_lsr (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
if(words.size() > 2){
complain() << "lsr: Too many arguments" << endl;
return;
} else if(words.size() == 1){
state.function_list_r(state.get_cwd());
} else if(words.at(1).at(0) == '/'){
if(words.at(1).length() == 1){
state.function_list_r(state.get_root());
return;
}
const auto placeholder = state.get_cwd();
state.setCwd(state.get_root());
wordvec nav_path = split(words.at(1), "/");
state.function_list_r(state.get_working_ptr(nav_path));
state.setCwd(placeholder);
} else {
wordvec nav_path = split(words[1], "/");
state.function_list_r(state.get_working_ptr(nav_path));
}
}
