zawz/lxsh
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Performance optimizations

Browse source 
- Replaced some exec() calls with functions
- Removed resolved code being resolved again
- Removed empty string subargs inserted upon parsing
This commit is contained in:
zawz 2020-11-13 15:18:30 +01:00
parent 5a7c2e0bf0
commit a0155991e3
10 changed files with 157 additions and 89 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
include/recursive.hpp
View file

@ -7,13 +7,14 @@
// boolean value of fct: if true, recurse on this object, if false, skip this object
template<class... Args>
void recurse(void (&fct)(_obj*, Args...), _obj* o, Args... args)
void recurse(bool (&fct)(_obj*, Args...), _obj* o, Args... args)
{
if(o == nullptr)
return;
// execution
fct(o, args...);
if(!fct(o, args...))
return; // skip recurse if false
// recursive calls
switch(o->type)

5
include/resolve.hpp
View file

@ -3,6 +3,11 @@
#include "struc.hpp"
extern std::vector<std::string> included;
bool add_include(std::string const& file);
void resolve(_obj* sh, shmain* parent);
void resolve(shmain* sh);
#endif //RESOLVE_HPP

2
include/struc.hpp
View file

@ -76,8 +76,6 @@ extern std::string g_origin;
cmd* make_cmd(std::vector<std::string> args);
bool add_include(std::string const& file);
class _obj
{
public:

3
include/util.hpp
View file

@ -18,6 +18,9 @@
extern std::string indenting_string;
std::string basename(std::string const& in);
std::string dirname(std::string const& in);
std::string indent(int n);
std::vector<std::string> split(std::string const& in, const char* splitters);

14
src/generate.cpp
View file

@ -6,8 +6,6 @@
#include "options.hpp"
#include "parse.hpp"
std::vector<std::string> included;
bool is_sub_special_cmd(std::string in)
{
return in == "%include_sub" || in == "%resolve_sub";
@ -111,18 +109,6 @@ std::string list::generate(int ind, bool first_indent)
return ret;
}
bool add_include(std::string const& file)
{
std::string truepath=ztd::exec("readlink", "-f", file).first;
for(auto it: included)
{
if(it == truepath)
return false;
}
included.push_back(truepath);
return true;
}
// BLOCK
std::string block::generate_redirs(int ind)

9
src/main.cpp
View file

@ -86,7 +86,7 @@ int main(int argc, char* argv[])
// do parsing
for(uint32_t i=0 ; i<args.size() ; i++)
{
std::string& file = args[i];
std::string file = args[i];
std::string filecontents=import_file(file);
// parse
g_origin=file;
@ -98,7 +98,7 @@ int main(int argc, char* argv[])
{
first_run=false;
// resolve shebang
bool shebang_is_bin = ztd::exec("basename", argv[0]).first == ztd::exec("basename", tsh->shebang).first;
bool shebang_is_bin = basename(argv[0]) == basename(tsh->shebang);
if(shebang_is_bin)
tsh->shebang="#!/bin/sh";
@ -112,7 +112,6 @@ int main(int argc, char* argv[])
if(!is_exec && args.size() > 1) // not exec: parse options on args
{
std::string t=args[0];
args=options.process(args);
}
@ -123,7 +122,9 @@ int main(int argc, char* argv[])
/* mid processing */
// resolve/include
if(g_include || g_resolve)
{
resolve(tsh);
}
// concatenate to main
sh->concat(tsh);
@ -180,7 +181,7 @@ int main(int argc, char* argv[])
printFormatError(e);
return 100;
}
catch(std::exception& e)
catch(std::runtime_error& e)
{
if(tsh != nullptr)
delete tsh;

27
src/minimize.cpp
View file

@ -87,10 +87,10 @@ std::string get_varname(subarg* in)
/** VAR RECURSE **/
void get_map_varname(_obj* in, std::map<std::string,uint32_t>* variable_map)
bool get_map_varname(_obj* in, std::map<std::string,uint32_t>* variable_map)
{
if(variable_map == nullptr)
return;
return false;
switch(in->type)
{
case _obj::subarg_variable: {
@ -122,9 +122,10 @@ void get_map_varname(_obj* in, std::map<std::string,uint32_t>* variable_map)
}; break;
default: break;
}
return true;
}
void replace_varname(_obj* in, std::map<std::string,std::string>* varmap)
bool replace_varname(_obj* in, std::map<std::string,std::string>* varmap)
{
switch(in->type)
{
@ -170,15 +171,13 @@ void replace_varname(_obj* in, std::map<std::string,std::string>* varmap)
}; break;
default: break;
}
return true;
}
/** FCT RECURSE **/
void get_map_cmd(_obj* in, std::map<std::string,uint32_t>* all_cmds)
bool get_map_cmd(_obj* in, std::map<std::string,uint32_t>* all_cmds)
{
if(all_cmds == nullptr)
return;
switch(in->type)
{
case _obj::block_cmd: {
@ -189,12 +188,11 @@ void get_map_cmd(_obj* in, std::map<std::string,uint32_t>* all_cmds)
}; break;
default: break;
}
return true;
}
void get_map_fctname(_obj* in, std::map<std::string,uint32_t>* fct_map)
bool get_map_fctname(_obj* in, std::map<std::string,uint32_t>* fct_map)
{
if(fct_map == nullptr)
return;
switch(in->type)
{
case _obj::block_function: {
@ -204,9 +202,10 @@ void get_map_fctname(_obj* in, std::map<std::string,uint32_t>* fct_map)
}; break;
default: break;
}
return true;
}
void replace_fctname(_obj* in, std::map<std::string,std::string>* fctmap)
bool replace_fctname(_obj* in, std::map<std::string,std::string>* fctmap)
{
switch(in->type)
{
@ -228,9 +227,10 @@ void replace_fctname(_obj* in, std::map<std::string,std::string>* fctmap)
}; break;
default: break;
}
return true;
}
void delete_fcts(_obj* in, std::set<std::string>* fcts)
bool delete_fcts(_obj* in, std::set<std::string>* fcts)
{
switch(in->type)
{
@ -253,6 +253,7 @@ void delete_fcts(_obj* in, std::set<std::string>* fcts)
}
default: break;
}
return true;
}
/** name things **/
@ -366,7 +367,7 @@ void delete_unused_fct(_obj* in, std::regex exclude)
recurse(delete_fcts, in, &unused);
}
void list_stuff(_obj* in, std::regex exclude, void (&fct)(_obj*,std::map<std::string,uint32_t>*) )
void list_stuff(_obj* in, std::regex exclude, bool (&fct)(_obj*,std::map<std::string,uint32_t>*) )
{
std::map<std::string,uint32_t> map;
recurse(fct, in, &map);

35
src/parse.cpp
View file

@ -243,7 +243,9 @@ std::pair<arg*, uint32_t> parse_arg(const char* in, uint32_t size, uint32_t star
else if( word_eq("$((", in, size, i) ) // arithmetic operation
{
// add previous subarg
ret->sa.push_back(new string_subarg(std::string(in+j, i-j)));
std::string tmpstr=std::string(in+j, i-j);
if(tmpstr!="")
ret->sa.push_back(new string_subarg(tmpstr));
// get arithmetic
auto r=parse_arithmetic(in, size, i+3);
ret->sa.push_back(r.first);
@ -252,7 +254,9 @@ std::pair<arg*, uint32_t> parse_arg(const char* in, uint32_t size, uint32_t star
else if( word_eq("$(", in, size, i) ) // substitution
{
// add previous subarg
ret->sa.push_back(new string_subarg(std::string(in+j, i-j)));
std::string tmpstr=std::string(in+j, i-j);
if(tmpstr!="")
ret->sa.push_back(new string_subarg(tmpstr));
// get subshell
auto r=parse_subshell(in, size, i+2);
ret->sa.push_back(new subshell_subarg(r.first, true));
@ -261,7 +265,9 @@ std::pair<arg*, uint32_t> parse_arg(const char* in, uint32_t size, uint32_t star
else if( word_eq("${", in, size, i) ) // variable manipulation
{
// add previous subarg
ret->sa.push_back(new string_subarg(std::string(in+j, i-j)));
std::string tmpstr=std::string(in+j, i-j);
if(tmpstr!="")
ret->sa.push_back(new string_subarg(tmpstr));
// get manipulation
auto r=parse_manipulation(in, size, i+2);
ret->sa.push_back(r.first);
@ -273,7 +279,9 @@ std::pair<arg*, uint32_t> parse_arg(const char* in, uint32_t size, uint32_t star
if(r.second > i+1)
{
// add previous subarg
ret->sa.push_back(new string_subarg(std::string(in+j, i-j)));
std::string tmpstr=std::string(in+j, i-j);
if(tmpstr!="")
ret->sa.push_back(new string_subarg(tmpstr));
// add varname
ret->sa.push_back(new variable_subarg(r.first));
j = i = r.second;
@ -302,7 +310,9 @@ std::pair<arg*, uint32_t> parse_arg(const char* in, uint32_t size, uint32_t star
else if( word_eq("$((", in, size, i) ) // arithmetic operation
{
// add previous subarg
ret->sa.push_back(new string_subarg(std::string(in+j, i-j)));
std::string tmpstr=std::string(in+j, i-j);
if(tmpstr!="")
ret->sa.push_back(new string_subarg(tmpstr));
// get arithmetic
auto r=parse_arithmetic(in, size, i+3);
ret->sa.push_back(r.first);
@ -311,7 +321,9 @@ std::pair<arg*, uint32_t> parse_arg(const char* in, uint32_t size, uint32_t star
else if( word_eq("$(", in, size, i) ) // substitution
{
// add previous subarg
ret->sa.push_back(new string_subarg(std::string(in+j, i-j)));
std::string tmpstr=std::string(in+j, i-j);
if(tmpstr!="")
ret->sa.push_back(new string_subarg(tmpstr));
// get subshell
auto r=parse_subshell(in, size, i+2);
ret->sa.push_back(new subshell_subarg(r.first, false));
@ -320,7 +332,9 @@ std::pair<arg*, uint32_t> parse_arg(const char* in, uint32_t size, uint32_t star
else if( word_eq("${", in, size, i) ) // variable manipulation
{
// add previous subarg
ret->sa.push_back(new string_subarg(std::string(in+j, i-j)));
std::string tmpstr=std::string(in+j, i-j);
if(tmpstr!="")
ret->sa.push_back(new string_subarg(tmpstr));
// get manipulation
auto r=parse_manipulation(in, size, i+2);
ret->sa.push_back(r.first);
@ -332,7 +346,9 @@ std::pair<arg*, uint32_t> parse_arg(const char* in, uint32_t size, uint32_t star
if(r.second > i+1)
{
// add previous subarg
ret->sa.push_back(new string_subarg(std::string(in+j, i-j)));
std::string tmpstr=std::string(in+j, i-j);
if(tmpstr!="")
ret->sa.push_back(new string_subarg(tmpstr));
// add varname
ret->sa.push_back(new variable_subarg(r.first));
j = i = r.second;
@ -346,7 +362,8 @@ std::pair<arg*, uint32_t> parse_arg(const char* in, uint32_t size, uint32_t star
// add string subarg
std::string val=std::string(in+j, i-j);
ret->sa.push_back(new string_subarg(val));
if(val != "")
ret->sa.push_back(new string_subarg(val));
}
catch(ztd::format_error& e)

125
src/resolve.cpp
View file

@ -7,29 +7,45 @@
#include "options.hpp"
#include "util.hpp"
#include "parse.hpp"
#include "timer.hpp"
std::vector<std::string> included;
// -- CD STUFF --
std::string pwd()
{
char buf[2048];
if(getcwd(buf, 2048) != NULL)
if(getcwd(buf, 2048) == NULL)
{
std::string ret=ztd::exec("pwd").first; // getcwd failed: call pwd
ret.pop_back();
return ret;
throw std::runtime_error("getcwd failed with errno "+std::to_string(errno));
}
return std::string(buf);
}
bool add_include(std::string const& file)
{
std::string truepath;
if(file[0] == '/')
truepath = file;
else
truepath=pwd() + '/' + file;
for(auto it: included)
{
if(it == truepath)
return false;
}
included.push_back(truepath);
return true;
}
// returns path to old dir
std::string _pre_cd(shmain* parent)
{
if(parent->is_dev_file() || parent->filename == "")
return "";
std::string dir=pwd();
std::string cddir=ztd::exec("dirname", parent->filename).first;
cddir.pop_back();
std::string cddir=dirname(parent->filename);
if(chdir(cddir.c_str()) != 0)
throw std::runtime_error("Cannot cd to '"+cddir+"'");
return dir;
@ -47,8 +63,6 @@ void _cd(std::string const& dir)
std::vector<std::pair<std::string, std::string>> do_include_raw(condlist* cmd, shmain* parent, std::string* ex_dir=nullptr)
{
std::vector<std::pair<std::string, std::string>> ret;
if(!g_include)
return ret;
ztd::option_set opts = create_include_opts();
std::vector<std::string> rargs;
@ -73,14 +87,16 @@ std::vector<std::pair<std::string, std::string>> do_include_raw(condlist* cmd, s
for(auto it: rargs)
command += it + ' ';
command += "; do echo $I ; done";
std::string inc=ztd::sh(command);
std::string inc=ztd::sh(command); /* takes 1ms */
auto v = split(inc, '\n');
for(auto it: v)
{
if(opts['f'] || add_include(it))
{
ret.push_back(std::make_pair(it, import_file(it)));
}
}
if(ex_dir==nullptr)
@ -92,13 +108,10 @@ std::vector<std::pair<std::string, std::string>> do_include_raw(condlist* cmd, s
std::vector<condlist*> do_include_parse(condlist* cmd, shmain* parent)
{
std::vector<condlist*> ret;
if(!g_include)
return ret;
std::string dir;
auto incs=do_include_raw(cmd, parent, &dir);
for(auto it: incs)
{
shmain* sh=parse_text(it.second, it.first);
@ -119,8 +132,6 @@ std::vector<condlist*> do_include_parse(condlist* cmd, shmain* parent)
std::pair<std::string, std::string> do_resolve_raw(condlist* cmd, shmain* parent, std::string* ex_dir=nullptr)
{
std::pair<std::string, std::string> ret;
if(!g_resolve)
return ret;
ztd::option_set opts = create_resolve_opts();
std::vector<std::string> rargs;
@ -169,8 +180,6 @@ std::pair<std::string, std::string> do_resolve_raw(condlist* cmd, shmain* parent
std::vector<condlist*> do_resolve_parse(condlist* cmd, shmain* parent)
{
std::vector<condlist*> ret;
if(!g_resolve)
return ret;
std::pair<std::string,std::string> p;
try
@ -199,26 +208,27 @@ std::vector<condlist*> do_resolve_parse(condlist* cmd, shmain* parent)
// -- OBJECT CALLS --
std::vector<condlist*> resolve_condlist(condlist* in, shmain* parent)
std::pair< std::vector<condlist*> , bool > resolve_condlist(condlist* in, shmain* parent)
{
cmd* tc = in->first_cmd();
if(tc == nullptr)
return std::vector<condlist*>();
return std::make_pair(std::vector<condlist*>(), false);
std::string const& strcmd=tc->firstarg_string();
if(strcmd == "%include")
return do_include_parse(in, parent);
else if(strcmd == "%resolve")
return do_resolve_parse(in, parent);
if(g_include && strcmd == "%include")
return std::make_pair(do_include_parse(in, parent), true);
else if(g_resolve && strcmd == "%resolve")
return std::make_pair(do_resolve_parse(in, parent), true);
else
return std::vector<condlist*>();
return std::make_pair(std::vector<condlist*>(), false);
}
std::vector<arg*> resolve_arg(arg* in, shmain* parent, bool forcequote=false)
std::pair< std::vector<arg*> , bool > resolve_arg(arg* in, shmain* parent, bool forcequote=false)
{
std::vector<arg*> ret;
arg* ta=nullptr;
bool has_resolved=false;
uint32_t j=0;
for(uint32_t i=0 ; i<in->sa.size() ; i++)
{
@ -234,18 +244,21 @@ std::vector<arg*> resolve_arg(arg* in, shmain* parent, bool forcequote=false)
continue;
std::string strcmd=c->firstarg_string();
std::string fulltext;
if(strcmd == "%include")
if(g_include && strcmd == "%include")
{
for(auto it: do_include_raw(tc, parent) )
fulltext += it.second;
}
else if(strcmd == "%resolve")
else if(g_resolve && strcmd == "%resolve")
{
fulltext = do_resolve_raw(tc, parent).second;
}
else // skip
continue;
// start of resolve
has_resolved = true;
if(tsh->quoted || forcequote)
{
stringReplace(fulltext, "\"", "\\\"");
@ -301,34 +314,42 @@ std::vector<arg*> resolve_arg(arg* in, shmain* parent, bool forcequote=false)
delete ta;
in->sa.resize(0);
}
return ret;
return std::make_pair(ret, has_resolved);
}
// -- RECURSIVE CALL --
void resolve_recurse(_obj* o, shmain* parent)
bool resolve_recurse(_obj* o, shmain* parent)
{
switch(o->type)
{
// in case of applicable object:
// check every sub-object
// execute resolve manually
// instruct parent resolve to not resolve
case _obj::_list :
{
auto t = dynamic_cast<list*>(o);
for(uint32_t i=0 ; i<t->cls.size() ; i++)
{
std::vector<condlist*> r=resolve_condlist(t->cls[i], parent);
if(r.size()>0)
auto r=resolve_condlist(t->cls[i], parent);
if(r.second)
{
// add new cls after current
t->cls.insert(t->cls.begin()+i+1, r.begin(), r.end());
t->cls.insert(t->cls.begin()+i+1, r.first.begin(), r.first.end());
// delete current
delete t->cls[i];
t->cls.erase(t->cls.begin()+i);
// back to previous object
i--;
// skip to after inserted cls
i += r.first.size()-1;
}
else
{
resolve(t->cls[i], parent);
}
}
// list
return false;
} break;
case _obj::_arglist :
{
@ -336,24 +357,33 @@ void resolve_recurse(_obj* o, shmain* parent)
for(uint32_t i=0 ; i<t->args.size() ; i++)
{
auto r=resolve_arg(t->args[i], parent);
if(r.size()>0)
if(r.first.size()>0)
{
// add new args
t->args.insert(t->args.begin()+i+1, r.begin(), r.end());
t->args.insert(t->args.begin()+i+1, r.first.begin(), r.first.end());
// delete current
delete t->args[i];
t->args.erase(t->args.begin()+i);
i += r.size()-1;
i += r.first.size()-1;
}
else
{
resolve(t->args[i], parent);
}
}
// arglist
return;
return false;
} break;
case _obj::block_cmd :
{
auto t = dynamic_cast<cmd*>(o);
for(auto it: t->var_assigns)
for(auto it: t->var_assigns) // var assigns
{
resolve_arg(it.second, parent, true); // force quoted
resolve(it.second, parent);
}
resolve(t->redirs, parent);
resolve(t->args, parent);
return false;
}; break;
case _obj::block_case :
{
@ -361,18 +391,27 @@ void resolve_recurse(_obj* o, shmain* parent)
for(auto sc: t->cases)
{
resolve_arg(t->carg, parent, true); // force quoted
resolve(t->carg, parent);
for(auto it: sc.first)
{
for(auto it: sc.first)
resolve_arg(it, parent, true); // force quoted
resolve_arg(it, parent, true); // force quoted
resolve(it, parent);
}
resolve(sc.second, parent);
}
}; break;
default: break;
}
return;
return true;
}
// recursive call of resolve
void resolve(_obj* in, shmain* parent)
{
recurse(resolve_recurse, in, parent);
}
void resolve(shmain* sh)
{
recurse(resolve_recurse, sh, sh);

21
src/util.cpp
View file

@ -20,6 +20,24 @@ std::string indent(int n)
return ret;
}
std::string basename(std::string const& in)
{
size_t slr=in.rfind('/');
if(slr != std::string::npos)
return in.substr(slr);
else
return in;
}
std::string dirname(std::string const& in)
{
size_t slr=in.rfind('/');
if(slr != std::string::npos)
return in.substr(0,slr);
else
return ".";
}
std::vector<std::string> split(std::string const& in, const char* splitters)
{
uint32_t i=0,j=0;
@ -229,8 +247,7 @@ int execute(shmain* sh, std::vector<std::string>& args)
{
std::string data=sh->generate();
std::string filename=ztd::exec("basename", args[0]).first;
filename.pop_back();
std::string filename = basename(args[0]);
// generate path
std::string tmpdir = (getenv("TMPDIR") != NULL) ? getenv("TMPDIR") : "/tmp" ;