maybe<std::size_t> find_first_instance_of_token
(const Container& token, const Container& xs)
{
if (size_of_cont(token) > size_of_cont(xs))
return nothing<std::size_t>();
auto itInBegin = std::begin(xs);
auto itInEnd = itInBegin;
internal::advance_iterator(itInEnd, size_of_cont(token));
std::size_t idx = 0;
std::size_t last_possible_idx = size_of_cont(xs) - size_of_cont(token);
while (idx != last_possible_idx)
{
if (std::equal(itInBegin, itInEnd, std::begin(token)))
{
return just(idx);
}
++itInBegin;
++itInEnd;
++idx;
}
if (std::equal(itInBegin, itInEnd, std::begin(token)))
{
return just(idx);
}
return nothing<std::size_t>();
}
int main() {
maybe<int> q(1);
maybe<int> x;
maybe<get_fucked> death( 1 ); // boom
maybe<get_fucked> deathagain; // have fun~
std::cout << std::boolalpha;
std::cout << (q != nothing) << ' ' << (nothing != q) << ' ';
std::cout << (x != q) << ' ' << (q != x) << ' ' << (q == q);
std::cout << ' ' << (q == just(1)) << ' ' << (just(1) == q);
std::cout << ' ' << (x == x) << ' ' << (x == nothing) << ' ';
std::cout << ' ' << (nothing == x);
}
static BOOL next(int ch)
{ /* get next digit - returns FALSE if there is a problem */
int cv;
result=FALSE;
if (ipt>=dlen) return FALSE;
if (ch=='/' || ch=='.')
{
if (delim || (ch=='/' && ipt==0)) return FALSE;
delim=TRUE;
}
else
{
if (ch>='A' && ch<='F') cv=10+(ch-'A');
else cv=ch-'0';
if (mip->IOBASE<=cv) return FALSE;
}
if (ipt==0 && ch=='0') clr();
else
{
mybuff[ipt++]=ch;
mybuff[ipt]='\0';
}
just(mybuff);
cinstr(x,mybuff);
newx=TRUE;
return TRUE;
}
//TSP -> NN -> Generations( g, ForkJoin ( n, GA -> 2-OPT ) ) -> TSP'
void Pipeline2(tsp_class& tsp_instance, unsigned int number_of_tasks,
unsigned int number_of_generations)
{
#pragma region "PipelineConfiguration"
auto a = Args<General_args_type>(make_General_args(number_of_generations, number_of_tasks));
auto sa = Args<SA_args_type>();
auto aco = Args<ACO_args_type>();
auto ga = Args<GA_args_type>(make_GA_args(1000, 10, 5, 50000, 10, 0.9));
const char* pipeline_description = "TSP -> NN -> Generations( g, ForkJoin ( n, GA -> 2-OPT ) ) -> TSP'";
display_args(pipeline_description, a, sa, aco, ga);
auto g = a[0].number_of_iterations_or_generations;
auto n = a[0].number_of_tasks_in_parallel;
auto _TSP = TSP(just(tsp_instance));
auto _DisplayInput = Display("TSP INPUT", DisplayFlags::All);
auto _NN = Measure(NN(), Display("NEAREST NEIGHBOUR", DisplayFlags::EmitMathematicaGraphPlot));
auto _GA_2OPT = Chain(GA(ga[0].population_size, ga[0].mutation_percentage, ga[0].group_size,
ga[0].number_of_generations, ga[0].nearby_cities, ga[0].nearby_cities_percentage), _2OPT());
auto _ForkJoin = [](unsigned int n, TSP::transformer_type map_fun){ return Measure(ForkJoin(n, map_fun)); };
auto _DisplayOutput = Display("TSP OUTPUT", DisplayFlags::EmitMathematicaGraphPlot);
#pragma endregion
//TSP -> NN -> Generations( g, ForkJoin ( n, GA -> 2-OPT ) ) -> TSP'
auto result = _TSP
.map(_DisplayInput)
.map(_NN)
.map(Generations(g, _ForkJoin(n, _GA_2OPT)))
.map(_DisplayOutput);
}
//TSP -> NN -> Generations( g, ForkJoin ( n, SA -> 2-OPT ) ) -> TSP'
void Pipeline1(tsp_class& tsp_instance, unsigned int number_of_tasks, unsigned int number_of_generations)
{
#pragma region "PipelineConfiguration"
auto a = Args<General_args_type>(make_General_args(number_of_generations, number_of_tasks));
auto sa = Args<SA_args_type>(make_SA_args(1000.0, 0.00001, 0.999, 400));
auto aco = Args<ACO_args_type>();
auto ga = Args<GA_args_type>();
const char* pipeline_description = "TSP -> NN -> Generations( g, ForkJoin ( n, SA -> 2-OPT ) ) -> TSP'";
display_args(pipeline_description, a, sa, aco, ga);
auto g = a[0].number_of_iterations_or_generations;
auto n = a[0].number_of_tasks_in_parallel;
auto _TSP = TSP(just(tsp_instance));
auto _DisplayInput = Display("TSP INPUT", DisplayFlags::All);
auto _NN = Measure(NN(), Display("NEAREST NEIGHBOUR", DisplayFlags::EmitMathematicaGraphPlot));
auto _SA_2OPT = Chain(SA(sa[0].initial_temperature, sa[0].stopping_criteria_temperature,
sa[0].decreasing_factor, sa[0].monte_carlo_steps), _2OPT());
auto _ForkJoin = [](unsigned int n, TSP::transformer_type map_fun){ return Measure(ForkJoin(n, map_fun)); };
auto _DisplayOutput = Display("TSP OUTPUT", DisplayFlags::EmitMathematicaGraphPlot);
#pragma endregion
//TSP -> NN -> Generations( g, ForkJoin ( n, SA -> 2-OPT ) ) -> TSP'
auto result = _TSP
.map(_DisplayInput)
.map(_NN)
.map(Generations(g, _ForkJoin(n, _SA_2OPT)))
.map(_DisplayOutput);
}
monad_t* maybe_return(void* v)
{
if(v)
return just(v);
else
return nothing();
}
static void drawit(void)
{ /* Draw calculator */
int i,j;
char line[40],tline[40],bline[40];
cset(1);
line[0]=DTLHC;
for (i=1;i<38;i++) line[i]=DHORZ;
line[38]=DTRHC;
line[39]='\0';
aprint(ORDINARY,1,1,line);
for (i=1;i<22;i++) apchar(ORDINARY,1,1+i,DVERT);
line[0]=DBLHC;
line[38]=DBRHC;
aprint(ORDINARY,1,23,line);
for (i=1;i<22;i++) apchar(ORDINARY,39,1+i,DVERT);
line[0]=LSIDE; /* draw in the bar */
for (i=1;i<38;i++) line[i]=HORZ;
line[38]=RSIDE;
aprint(ORDINARY,1,4,line);
line[0]=tline[0]=bline[0]=SPACE;
line[36]=tline[36]=bline[36]=SPACE;
line[37]=tline[37]=bline[37]='\0';
for (i=1;i<36;i++)
{
switch (i%5)
{
case 1 : tline[i]=TLHC;
bline[i]=BLHC;
line[i]=VERT;
break;
default: tline[i]=HORZ;
bline[i]=HORZ;
line[i]=SPACE;
break;
case 0 : tline[i]=TRHC;
bline[i]=BRHC;
line[i]=VERT;
break;
}
}
for (j=0;j<6;j++)
{
aprint(ORDINARY,2,5+3*j,tline);
aprint(ORDINARY,2,6+3*j,line);
aprint(ORDINARY,2,7+3*j,bline);
}
cset(0);
for (j=0;j<6;j++)
for (i=0;i<7;i++)
aprint(ORDINARY,4+5*i,6+3*j,keys[j][i]);
aprint(HELPCOL,2,24,"Type 'H' for help on/off, 'O' to exit");
cotstr(x,mip->IOBUFF);
just((char *)mip->IOBUFF);
getstat();
show(TRUE);
}
Maybe<Window> open_IO( Engine& engine, const WindowConfig& windowConfig )
{
std::wstring windowNameW = s2ws( "HP_FP::" + engine.name );
Window window{ nullptr, windowNameW.c_str( ) };
if ( isOnlyInstance_IO( window.name ) )
{
// window class details
WNDCLASSEX windowClass = { 0 };
windowClass.cbSize = sizeof( WNDCLASSEX );
windowClass.style = CS_VREDRAW | CS_HREDRAW;
windowClass.lpfnWndProc = &windowProc_IO;
windowClass.cbClsExtra = 0;
windowClass.cbWndExtra = 0;
windowClass.hInstance = GetModuleHandle( nullptr );
windowClass.hIcon = 0;
windowClass.hIconSm = 0;
windowClass.hCursor = 0;
windowClass.hbrBackground = 0;
windowClass.lpszMenuName = 0;
windowClass.lpszClassName = window.name;
// register the window
if ( RegisterClassEx( &windowClass ) )
{
// find position and size
HDC screenDC = GetDC( nullptr );
unsigned left = ( GetDeviceCaps( screenDC, HORZRES ) - windowConfig.width ) / 2;
unsigned top = ( GetDeviceCaps( screenDC, VERTRES ) - windowConfig.height ) / 2;
unsigned width = windowConfig.width;
unsigned height = windowConfig.height;
ReleaseDC( nullptr, screenDC );
// set the style of the window
DWORD style = WS_VISIBLE;
if ( windowConfig.windowStyle == WindowStyle::Window )
{
style |= WS_CAPTION | WS_MINIMIZEBOX | WS_THICKFRAME | WS_MAXIMIZEBOX | WS_SYSMENU;
// adjust the window size with the borders etc.
RECT rectangle = { 0, 0, windowConfig.width, windowConfig.height };
AdjustWindowRect( &rectangle, style, false );
width = rectangle.right - rectangle.left;
height = rectangle.bottom - rectangle.top;
}
// create the window
window.handle = CreateWindowEx( 0, window.name, window.name, style, left, top, width, height, GetDesktopWindow( ), nullptr, GetModuleHandle( nullptr ), &engine );
if ( window.handle == nullptr )
{
ERR( GetLastError( ) );
return nothing<Window>( );
}
if ( windowConfig.windowStyle == WindowStyle::Fullscreen )
{
switchToFullscreen_IO( window.handle, windowConfig );
}
}
}
return just( std::move( window ) );
}
monad_t* increment_odds(int* val)
{
if(!val || 0 == ((*val) % 2))
{
return nothing();
}
int* v = malloc(sizeof(int));
*v = (*val) + 1;
return just(v);
}
int main()
{
int x = 2;
int y = 4;
int z = 6;
monad_t* m = just(&x);
print_maybe_int_monad(m);
m = m->mbind(m, (bound_func)increment_evens);
print_maybe_int_monad(m);
m = m->mbind(m, (bound_func)increment_evens);
print_maybe_int_monad(m);
m = just(&y);
m = m->mbind(m, (bound_func)increment_evens);
m = m->mbind(m, (bound_func)increment_odds);
print_maybe_int_monad(m);
m = just(&z);
m = m->mbind(m, (bound_func)increment_odds);
print_maybe_int_monad(m);
return 0;
}
monad_t* increment_evens(int* val)
{
if(!val) {
return nothing();
}
if(0 != ((*val) % 2))
{
return nothing();
}
int* v2 = malloc(sizeof(int));
*v2 = (*val) + 1;
return just(v2);
}
maybe<TOut> first_match_by(F f, const ContainerIn1& xs, const ContainerIn2& ys)
{
const auto maybe_idx = first_match_idx_by(f, xs, ys);
if (is_nothing(maybe_idx))
{
return nothing<TOut>();
}
else
{
const auto idx = maybe_idx.unsafe_get_just();
return just(std::make_pair(
elem_at_idx(idx, xs),
elem_at_idx(idx, ys)));
}
}
maybe<std::size_t> first_match_idx_by(F f,
const ContainerIn1& xs, const ContainerIn2& ys)
{
auto itXs = std::begin(xs);
auto itYs = std::begin(ys);
std::size_t minSize = std::min(size_of_cont(xs), size_of_cont(ys));
for (std::size_t i = 0; i < minSize; ++i)
{
if (internal::invoke(f, *itXs, *itYs))
{
return just(i);
}
++itXs;
++itYs;
}
return nothing<std::size_t>();
}
//TSP -> NN -> Generations( g, ForkJoin ( n, ACO -> 2-OPT ) ) -> TSP'
void Pipeline3(tsp_class& tsp_instance, unsigned int number_of_tasks,
unsigned int number_of_generations)
{
#pragma region "PipelineConfiguration"
auto a = Args<General_args_type>(make_General_args(number_of_generations, number_of_tasks));
auto sa = Args<SA_args_type>();
auto ga = Args<GA_args_type>();
const int aco_iterations = static_cast<int>(tsp_instance.cities.size() * 100);
const ants_type::size_type number_of_ants = tsp_instance.cities.size();
const double BASE_PHEROMONE = 1.0f / static_cast<double>(tsp_instance.cities.size());
const double ALPHA = 1.0;
const double BETA = 1.0;
const double RHO = 0.9;
const double QVAL = 70;
auto aco = Args<ACO_args_type>(make_ACO_args(aco_iterations, number_of_ants,
BASE_PHEROMONE, ALPHA, BETA, RHO, QVAL));
const char* pipeline_description = "TSP -> NN -> Generations( g, ForkJoin ( n, ACO -> 2-OPT ) ) -> TSP'";
display_args(pipeline_description, a, sa, aco, ga);
auto g = a[0].number_of_iterations_or_generations;
auto n = a[0].number_of_tasks_in_parallel;
auto _TSP = TSP(just(tsp_instance));
auto _DisplayInput = Display("TSP INPUT", DisplayFlags::All);
auto _NN = Measure(NN(), Display("NEAREST NEIGHBOUR", DisplayFlags::EmitMathematicaGraphPlot));
auto _ACO_2OPT = Chain(ACO(aco[0].aco_iterations, aco[0].number_of_ants, aco[0].base_pheromone,
aco[0].favor_pheromone_level_over_distance,
aco[0].favor_distance_over_pheromone_level,
aco[0].value_for_intensification_and_evaporation,
aco[0].pheronome_distribution), _2OPT());
auto _ForkJoin = [](unsigned int n, TSP::transformer_type map_fun){ return Measure(ForkJoin(n, map_fun)); };
auto _DisplayOutput = Display("TSP OUTPUT", DisplayFlags::EmitMathematicaGraphPlot);
#pragma endregion
//TSP -> NN -> Generations( g, ForkJoin ( n, ACO -> 2-OPT ) ) -> TSP'
auto result = _TSP
.map(_DisplayInput)
.map(_NN)
.map(Generations(g, _ForkJoin(n, _ACO_2OPT)))
.map(_DisplayOutput);
}
static BOOL act(int p,int q)
{ /* act on selected key */
int k,n,c;
aprint(PRESSED,4+5*p,6+3*q,keys[q][p]);
switch(p+7*q)
{
case 0: if (degrees) fmul(x,radeg,x);
if (hyp) fsinh(x,x);
else fsin(x,x);
newx=TRUE;
break;
case 1: if (degrees) fmul(x,radeg,x);
if (hyp) fcosh(x,x);
else fcos(x,x);
newx=TRUE;
break;
case 2: if (degrees) fmul(x,radeg,x);
if (hyp) ftanh(x,x);
else ftan(x,x);
newx=TRUE;
break;
case 3: if (lgbase>0)
{
n=size(x);
if (abs(n)<MR_TOOBIG)
{
convert(lgbase,x);
if (n<0) frecip(x,x);
fpower(x,abs(n),x);
newx=TRUE;
break;
}
if (lgbase==2) fmul(x,loge2,x);
if (lgbase==10) fmul(x,loge10,x);
}
fexp(x,x);
newx=TRUE;
break;
case 4: mip->RPOINT=!mip->RPOINT;
newx=TRUE;
break;
case 5: clrall();
newx=TRUE;
break;
case 6: return TRUE;
case 7: if (hyp) fasinh(x,x);
else fasin(x,x);
if (degrees) fdiv(x,radeg,x);
newx=TRUE;
break;
case 8: if (hyp) facosh(x,x);
else facos(x,x);
if (degrees) fdiv(x,radeg,x);
newx=TRUE;
break;
case 9: if (hyp) fatanh(x,x);
else fatan(x,x);
if (degrees) fdiv(x,radeg,x);
newx=TRUE;
break;
case 10: flog(x,x);
if (lgbase==2) fdiv(x,loge2,x);
if (lgbase==10) fdiv(x,loge10,x);
newx=TRUE;
break;
case 11: newx=TRUE;
k=3;
forever
{
aprint(INVER,2+stptr[k],2,settings[k][option[k]]);
curser(2+stptr[k],2);
c=arrow(gethit());
if (c==1)
{
if (option[k]==nops[k]) option[k]=0;
else option[k]+=1;
continue;
}
aprint(STATCOL,2+stptr[k],2,settings[k][option[k]]);
if (c==0 || c==2) break;
if (c==4 && k>0) k--;
if (c==3 && k<3) k++;
}
setopts();
break;
case 12: chekit(7);
break;
case 13: result=FALSE;
if (ipt==0) break;
ipt--;
mybuff[ipt]='\0';
if (ipt==0) clr();
just(mybuff);
cinstr(x,mybuff);
newx=TRUE;
break;
case 14: if (!next('7')) putchar(BELL);
break;
case 15: if (!next('8')) putchar(BELL);
break;
case 16: if (!next('9')) putchar(BELL);
break;
case 17: chekit(6);
break;
case 18: chekit(5);
break;
case 19: chekit(4);
break;
case 20: copy(m,x);
newx=TRUE;
break;
case 21: if (!next('4')) putchar(BELL);
break;
case 22: if (!next('5')) putchar(BELL);
break;
case 23: if (!next('6')) putchar(BELL);
break;
case 24: fmul(x,x,x);
newx=TRUE;
break;
case 25: froot(x,2,x);
newx=TRUE;
break;
case 26: chekit(3);
break;
case 27: brkt=0;
chekit(0);
flag=OFF;
fadd(m,x,m);
newx=TRUE;
break;
case 28: if (!next('1')) putchar(BELL);
break;
case 29: if (!next('2')) putchar(BELL);
break;
case 30: if (!next('3')) putchar(BELL);
break;
case 31: frecip(x,x);
newx=TRUE;
break;
case 32: fpi(x);
newx=TRUE;
break;
case 33: chekit(2);
break;
case 34: negify(x,x);
newx=TRUE;
break;
case 35: if (!next('0')) putchar(BELL);
break;
case 36: if (!next('/')) putchar(BELL);
break;
case 37: if (!next('.')) putchar(BELL);
break;
case 38: if (ipt>0)
{
putchar(BELL);
result=FALSE;
}
else
{
zero(x);
brkt+=1;
newx=TRUE;
}
break;
case 39: if (brkt>0)
{
chekit(0);
brkt-=1;
}
else
{
putchar(BELL);
result=FALSE;
}
break;
case 40: chekit(1);
break;
case 41: brkt=0;
equals(0);
flag=OFF;
break;
}
return FALSE;
}
void Maybe_m_return(OPObject* _self, void* data)
{
Maybe* self = (Maybe*) _self;
just(self, data);
}
vector<string> fullJustify(vector<string>& words, int maxWidth) {
int start = 0;
int cnt = 0;
int len = 0;
int sz = words.size();
if(sz == 0) return vector<string>();
vector<string> res;
for(int i = 0; i < sz; ++i) {
if(cnt == 0) {
start = i;
}
if(cnt > 0) ++len; // one space at least
if(len + words[i].size() <= maxWidth) {
++cnt;
len += words[i].size();
if(start + cnt == sz) {
goto COMBINE;
}
} else {
--i;
if(cnt > 0) --len;
goto COMBINE;
}
continue;
COMBINE:
cout << len << " : " << start << " " << cnt << endl;
int spaces = maxWidth - len + cnt - 1;
int div = cnt > 1 ? spaces / (cnt - 1) : spaces;
int ram = cnt > 1 ? spaces % (cnt - 1) : 1;
cout << spaces << " " << div << " / " << ram << endl;
string just("");
if(start + cnt == sz) {
int last = spaces - cnt + 1;
for(int cum = 0; cum < cnt; ++ cum) {
if(cum == cnt - 1) {
just += words[start + cum] + string(last, ' ');
break;
}
just += words[start + cum];
if(cnt > 1) {
just += " ";
}
}
len = 0;
cnt = 0;
res.push_back(just);
break;
}
if(cnt == 1) {
just += words[start] + string(div, ' ');
} else {
for(int cum = 0; cum < cnt; ++cum) {
if(cum == cnt - 1) {
just += words[start + cum];
break;
}
if(cum < ram) {
just += words[start + cum] + string(div + 1, ' ');
} else {
just += words[start + cum] + string(div, ' ');
}
}
}
len = 0;
cnt = 0;
res.push_back(just);
}
return res;
}
void MonadicLawsProofing()
{
//Scala notation: unit(x) flatMap f == f(x)
{
//Left Identity (1st Law)
auto x = just(read_att48_tsp());
auto f = [](TSP::T t){ return ref(t).do_cycle_length(); };
double fun_result = bnd<double>(ret(x), f); //functional composition
double oo_result = ret(x).map<double>(f); //object-oriented
bool fun_holds = fun_result == f(x);
bool oo_holds = oo_result == f(x);
std::cout << "1st Law (Left Identity) " << (fun_holds ? "holds" : "doesn't hold") << std::endl;
std::cout << "1st Law (Left Identity) " << (oo_holds ? "holds" : "doesn't hold") << std::endl;
}
//Scala notation: m flatMap unit == m
{
//Right Identity (2nd Law)
auto m = make_TSP(read_att48_tsp());
auto fun_result = bnd(m, ret);
auto oo_result = m.map(ret);
bool fun_holds = fun_result == m;
bool oo_holds = oo_result == m;
std::cout << "2nd Law (Right Identity) " << (fun_holds ? "holds" : "doesn't hold") << std::endl;
std::cout << "2nd Law (Right Identity) " << (oo_holds ? "holds" : "doesn't hold") << std::endl;
}
//Scala notation: m flatMap f flatMap g == m flatMap (x => f(x) flatMap g)
{
//Associativity (3rd Law)
auto m = make_TSP(read_att48_tsp());
auto f = [](TSP::T t) -> TSP
{
auto u = ref(t);
std::swap(u.cities[0], u.cities[1]);
return make_TSP(u);
};
auto g = [](TSP::T t) -> TSP
{
auto u = ref(t);
std::swap(u.cities[2], u.cities[3]);
return make_TSP(u);
};
auto fun_result_1 = bnd(bnd(m, f), g);
auto fun_result_2 = bnd(m, [&](TSP::T t) {
return bnd(f(t), g);
});
auto oo_result_1 = m.map(f).map(g);
auto oo_result_2 = m.map([&](TSP::T t) {
return f(t).map(g);
});
bool fun_holds = fun_result_1 == fun_result_2;
bool oo_holds = oo_result_1 == oo_result_2;
std::cout << "3rd Law (Associativity) " << (fun_holds ? "holds" : "doesn't hold") << std::endl;
std::cout << "3rd Law (Associativity) " << (oo_holds ? "holds" : "doesn't hold") << std::endl;
}
}
TSP make_TSP(const tsp_class& tsp_instance) { return TSP(just(tsp_instance)); }
Maybe<CliArgParser::HelpInfo> ExtensionArgParser::helpInfo() const {
return just(HelpInfo{"-e", "--extension", tr("ext"),
tr("Select target subtitles file extension")});
}
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
*****************************************************************************/
#include "napisy24downloadengine.h"
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QProcess>
#include <QUrl>
#include <QUrlQuery>
SubtitleDownloadEngineMetadata Napisy24DownloadEngine::metadata =
SubtitleDownloadEngineMetadata(
"Napisy24",
QObject::tr("<b>www.napisy24.pl</b> subtitle download engine"),
just(QUrl("http://napisy24.pl/cb-registration/registers")),
just(QUrl("http://napisy24.pl/dodaj-napisy")));
Napisy24DownloadEngine::Napisy24DownloadEngine(
const QString &tmpPath, const EngineConfig &config,
const QSharedPointer<const P7ZipDecoder> &p7zipDecoder,
const QStringList &subtitleExtensions)
: SubtitleDownloadEngine(tmpPath),
engineConfig(config),
p7zipDecoder(p7zipDecoder),
subtitleExtensions(subtitleExtensions) {}
Napisy24DownloadEngine::~Napisy24DownloadEngine() { cleanup(); }
SubtitleDownloadEngineMetadata Napisy24DownloadEngine::meta() const {
return Napisy24DownloadEngine::metadata;
Maybe<CliArgParser::HelpInfo> DontShowListArgParser::helpInfo() const {
return just(HelpInfo{"-d", "--dont-show-list", "",
tr("Never show a list of available subtitles")});
}
void Maybe_a_pure(OPObject* _self, void* data)
{
Maybe* self = (Maybe*) _self;
just(self, data);
}
static constexpr auto apply(Set set, Pred p) {
auto x = set.find(p);
return if_(p(x), just(x), nothing);
}
int main()
{ /* MIRACL rational calculator */
int i,j,k,p,q,c,hpos;
BOOL over,help;
screen();
#if MIRACL==16
mip=mirsys(10,0); /*** 16-bit computer ***/
#else
mip=mirsys(6,0); /*** 32-bit computer ***/
#endif
mip->ERCON=TRUE;
x=mirvar(0);
for (i=0;i<=top;i++) y[i]=mirvar(0);
m=mirvar(0);
t=mirvar(0);
radeg=mirvar(0);
loge2=mirvar(0);
loge10=mirvar(0);
eps=mirvar(0);
mip->pi=mirvar(0);
cinstr(mip->pi,cpi); /* read in constants */
fpmul(mip->pi,1,180,radeg);
cinstr(loge2,clg2);
cinstr(loge10,clg10);
cinstr(eps,ceps);
help=OFF;
show(TRUE);
p=6;
q=0;
flag=OFF;
newx=OFF;
over=FALSE;
setopts();
clrall();
drawit();
while (!over)
{ /* main loop */
if (mip->ERNUM)
{
aprint(ORDINARY,4+5*p,6+3*q,keys[q][p]);
p=5,q=0;
}
if (width==80 || !help)
{
aprint(INVER,4+5*p,6+3*q,keys[q][p]);
curser(1,24);
c=gethit();
aprint(ORDINARY,4+5*p,6+3*q,keys[q][p]);
}
else while ((c=gethit())!='H') ;
result=TRUE;
if ((k=arrow(c))!=0)
{ /* arrow key hit */
if (k==1 && q>0) q--;
if (k==2 && q<5) q++;
if (k==3 && p<6) p++;
if (k==4 && p>0) p--;
continue;
}
if (c=='H')
{ /* switch help on/off */
help=!help;
for (i=1;i<=24;i++)
{
if (width==80) hpos=41;
else hpos=1;
if (help) aprint(HELPCOL,hpos,i,htext[i-1]);
else lclr(hpos,i);
}
if (width==40 && !help) drawit();
continue;
}
if (c>='A' && c<='F')
{ /* hex only */
if (!next(c)) putchar(BELL);
else show(FALSE);
continue;
}
for (j=0;j<6;j++)
for (i=0;i<7;i++)
if (c==qkeys[j][i]) p=i,q=j,c=' ';
if (c==8 || c==127) p=6,q=1,c=' '; /* aliases */
if (c==',' || c=='a') p=5,q=5,c=' ';
if (c=='O' || c==ESC) p=6,q=0,c=' ';
if (c==13) p=6,q=5,c=' ';
if (c=='[' || c=='{') p=3,q=5,c=' ';
if (c==']' || c=='}') p=4,q=5,c=' ';
if (c=='d') p=5,q=2,c=' ';
if (c=='b') p=5,q=3,c=' ';
if (c=='^') p=3,q=2,c=' ';
if (c==' ') over=act(p,q);
else continue;
absol(x,t);
if (fcomp(t,eps)<0) zero(x);
if (result)
{ /* output result to display */
cotstr(x,mip->IOBUFF);
just((char *)mip->IOBUFF);
if (mip->ERNUM<0)
{ /* convert to radix and try again */
mip->ERNUM=0;
mip->RPOINT=ON;
cotstr(x,mip->IOBUFF);
putchar(BELL);
just((char *)mip->IOBUFF);
}
clr();
}
if (newx)
{ /* update display */
getstat();
show(FALSE);
}
}
curser(1,24);
restore();
return 0;
}
Maybe<CliArgParser::HelpInfo> ShowListArgParser::helpInfo() const {
return just(HelpInfo{"-s", "--show-list", "",
tr("Always show a list of available subtitles")});
}
