From 05575d8a0824b27b72abe0020ee93b861108dec1 Mon Sep 17 00:00:00 2001 From: Simon Forman Date: Mon, 6 Feb 2023 12:59:39 -0800 Subject: [PATCH] A bunch of definitions. Still to do: the comparison functions. --- implementations/C/convert_defs.py | 46 ++-- implementations/C/definitions.c | 207 ++++++++++++++++- implementations/C/definitions.h | 69 +++++- implementations/C/defs.txt | 5 - implementations/C/keywords.c | 368 +++++++++++++++++++++--------- 5 files changed, 557 insertions(+), 138 deletions(-) diff --git a/implementations/C/convert_defs.py b/implementations/C/convert_defs.py index 4282eda..d26ef11 100644 --- a/implementations/C/convert_defs.py +++ b/implementations/C/convert_defs.py @@ -15,29 +15,29 @@ Eh? ''' import sys -#list(open('../defs.txt')) -defs = '''\ -abs dup 0 < [] [neg] branch -anamorphism [pop []] swap [dip swons] genrec -app1 grba infrst -app2 [grba swap grba swap] dip [infrst] cons ii -app3 3 appN -appN [grabN] codi map reverse disenstacken -at drop first -average [sum] [size] cleave / -b [i] dip i -binary unary popd -ccccons ccons ccons -ccons cons cons -cleave fork popdd -clop cleave popdd -codi cons dip -codireco codi reco -dinfrirst dip infrst -dipd [dip] codi -disenstacken ? [uncons ?] loop pop -swons swap cons -infra swons swaack [i] dip swaack'''.splitlines() +defs = [line.strip() for line in open('./defs.txt')] +##defs = '''\ +##abs dup 0 < [] [neg] branch +##anamorphism [pop []] swap [dip swons] genrec +##app1 grba infrst +##app2 [grba swap grba swap] dip [infrst] cons ii +##app3 3 appN +##appN [grabN] codi map reverse disenstacken +##at drop first +##average [sum] [size] cleave / +##b [i] dip i +##binary unary popd +##ccccons ccons ccons +##ccons cons cons +##cleave fork popdd +##clop cleave popdd +##codi cons dip +##codireco codi reco +##dinfrirst dip infrst +##dipd [dip] codi +##disenstacken ? [uncons ?] loop pop +##swons swap cons +##infra swons swaack [i] dip swaack'''.splitlines() print(f'''\ diff --git a/implementations/C/definitions.c b/implementations/C/definitions.c index c423aa3..05eb455 100644 --- a/implementations/C/definitions.c +++ b/implementations/C/definitions.c @@ -31,8 +31,75 @@ JoyList def_codireco_body; JoyList def_dinfrirst_body; JoyList def_dipd_body; JoyList def_disenstacken_body; -JoyList def_swons_body; +JoyList def_down_to_zero_body; +JoyList def_drop_body; +JoyList def_dupd_body; +JoyList def_dupdd_body; +JoyList def_dupdip_body; +JoyList def_dupdipd_body; +JoyList def_enstacken_body; +JoyList def_flatten_body; +JoyList def_fork_body; +JoyList def_fourth_body; +JoyList def_gcd_body; +JoyList def_genrec_body; +JoyList def_grabN_body; +JoyList def_grba_body; +JoyList def_hypot_body; +JoyList def_ifte_body; +JoyList def_ii_body; JoyList def_infra_body; +JoyList def_infrst_body; +JoyList def_make_generator_body; +JoyList def_mod_body; +JoyList def_neg_body; +JoyList def_not_body; +JoyList def_nulco_body; +JoyList def_nullary_body; +JoyList def_of_body; +JoyList def_pam_body; +JoyList def_pm_body; +JoyList def_popd_body; +JoyList def_popdd_body; +JoyList def_popop_body; +JoyList def_popopop_body; +JoyList def_popopd_body; +JoyList def_popopdd_body; +JoyList def_product_body; +JoyList def_quoted_body; +JoyList def_range_body; +JoyList def_range_to_zero_body; +JoyList def_reco_body; +JoyList def_reverse_body; +JoyList def_rrest_body; +JoyList def_run_body; +JoyList def_second_body; +JoyList def_shift_body; +JoyList def_shunt_body; +JoyList def_size_body; +JoyList def_spiral_next_body; +JoyList def_split_at_body; +JoyList def_split_list_body; +JoyList def_sqr_body; +JoyList def_stackd_body; +JoyList def_step_zero_body; +JoyList def_stuncons_body; +JoyList def_sum_body; +JoyList def_swapd_body; +JoyList def_swons_body; +JoyList def_swoncat_body; +JoyList def_tailrec_body; +JoyList def_take_body; +JoyList def_ternary_body; +JoyList def_third_body; +JoyList def_tuck_body; +JoyList def_unary_body; +JoyList def_uncons_body; +JoyList def_unit_body; +JoyList def_unquoted_body; +JoyList def_unswons_body; +JoyList def_while_body; +JoyList def_x_body; /* @@ -62,8 +129,75 @@ init_defs(void) def_dinfrirst_body = text_to_expression("dip infrst"); def_dipd_body = text_to_expression("[dip] codi"); def_disenstacken_body = text_to_expression("? [uncons ?] loop pop"); - def_swons_body = text_to_expression("swap cons"); + def_down_to_zero_body = text_to_expression("[0 >] [dup --] while"); + def_drop_body = text_to_expression("[rest] times"); + def_dupd_body = text_to_expression("[dup] dip"); + def_dupdd_body = text_to_expression("[dup] dipd"); + def_dupdip_body = text_to_expression("dupd dip"); + def_dupdipd_body = text_to_expression("dup dipd"); + def_enstacken_body = text_to_expression("stack [clear] dip"); + def_flatten_body = text_to_expression("<{} [concat] step"); + def_fork_body = text_to_expression("[i] app2"); + def_fourth_body = text_to_expression("rest third"); + def_gcd_body = text_to_expression("true [tuck mod dup 0 >] loop pop"); + def_genrec_body = text_to_expression("[[genrec] ccccons] nullary swons concat ifte"); + def_grabN_body = text_to_expression("<{} [cons] times"); + def_grba_body = text_to_expression("[stack popd] dip"); + def_hypot_body = text_to_expression("[sqr] ii + sqrt"); + def_ifte_body = text_to_expression("[nullary] dipd swap branch"); + def_ii_body = text_to_expression("[dip] dupdip i"); def_infra_body = text_to_expression("swons swaack [i] dip swaack"); + def_infrst_body = text_to_expression("infra first"); + def_make_generator_body = text_to_expression("[codireco] ccons"); + def_mod_body = text_to_expression("%"); + def_neg_body = text_to_expression("0 swap -"); + def_not_body = text_to_expression("[true] [false] branch"); + def_nulco_body = text_to_expression("[nullary] cons"); + def_nullary_body = text_to_expression("[stack] dinfrirst"); + def_of_body = text_to_expression("swap at"); + def_pam_body = text_to_expression("[i] map"); + def_pm_body = text_to_expression("[+] [-] clop"); + def_popd_body = text_to_expression("[pop] dip"); + def_popdd_body = text_to_expression("[pop] dipd"); + def_popop_body = text_to_expression("pop pop"); + def_popopop_body = text_to_expression("pop popop"); + def_popopd_body = text_to_expression("[popop] dip"); + def_popopdd_body = text_to_expression("[popop] dipd"); + def_product_body = text_to_expression("1 swap [*] step"); + def_quoted_body = text_to_expression("[unit] dip"); + def_range_body = text_to_expression("[0 <=] [1 - dup] anamorphism"); + def_range_to_zero_body = text_to_expression("unit [down_to_zero] infra"); + def_reco_body = text_to_expression("rest cons"); + def_reverse_body = text_to_expression("<{} shunt"); + def_rrest_body = text_to_expression("rest rest"); + def_run_body = text_to_expression("<{} infra"); + def_second_body = text_to_expression("rest first"); + def_shift_body = text_to_expression("uncons [swons] dip"); + def_shunt_body = text_to_expression("[swons] step"); + def_size_body = text_to_expression("[pop ++] step_zero"); + def_spiral_next_body = text_to_expression("[[[abs] ii <=] [[<>] [pop !-] ||] &&] [[!-] [[++]] [[--]] ifte dip] [[pop !-] [--] [++] ifte] ifte"); + def_split_at_body = text_to_expression("[drop] [take] clop"); + def_split_list_body = text_to_expression("[take reverse] [drop] clop"); + def_sqr_body = text_to_expression("dup *"); + def_stackd_body = text_to_expression("[stack] dip"); + def_step_zero_body = text_to_expression("0 roll> step"); + def_stuncons_body = text_to_expression("stack uncons"); + def_sum_body = text_to_expression("[+] step_zero"); + def_swapd_body = text_to_expression("[swap] dip"); + def_swons_body = text_to_expression("swap cons"); + def_swoncat_body = text_to_expression("swap concat"); + def_tailrec_body = text_to_expression("[i] genrec"); + def_take_body = text_to_expression("<<{} [shift] times pop"); + def_ternary_body = text_to_expression("binary popd"); + def_third_body = text_to_expression("rest second"); + def_tuck_body = text_to_expression("dup swapd"); + def_unary_body = text_to_expression("nullary popd"); + def_uncons_body = text_to_expression("[first] [rest] cleave"); + def_unit_body = text_to_expression("[] cons"); + def_unquoted_body = text_to_expression("[i] dip"); + def_unswons_body = text_to_expression("uncons swap"); + def_while_body = text_to_expression("swap nulco dupdipd concat loop"); + def_x_body = text_to_expression("dup i"); } @@ -90,5 +224,72 @@ void def_codireco(__attribute__((unused)) JoyListPtr stack, JoyListPtr expressio void def_dinfrirst(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dinfrirst_body, expression); } void def_dipd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dipd_body, expression); } void def_disenstacken(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_disenstacken_body, expression); } -void def_swons(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_swons_body, expression); } +void def_down_to_zero(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_down_to_zero_body, expression); } +void def_drop(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_drop_body, expression); } +void def_dupd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dupd_body, expression); } +void def_dupdd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dupdd_body, expression); } +void def_dupdip(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dupdip_body, expression); } +void def_dupdipd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dupdipd_body, expression); } +void def_enstacken(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_enstacken_body, expression); } +void def_flatten(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_flatten_body, expression); } +void def_fork(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_fork_body, expression); } +void def_fourth(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_fourth_body, expression); } +void def_gcd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_gcd_body, expression); } +void def_genrec(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_genrec_body, expression); } +void def_grabN(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_grabN_body, expression); } +void def_grba(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_grba_body, expression); } +void def_hypot(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_hypot_body, expression); } +void def_ifte(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_ifte_body, expression); } +void def_ii(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_ii_body, expression); } void def_infra(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_infra_body, expression); } +void def_infrst(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_infrst_body, expression); } +void def_make_generator(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_make_generator_body, expression); } +void def_mod(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_mod_body, expression); } +void def_neg(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_neg_body, expression); } +void def_not(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_not_body, expression); } +void def_nulco(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_nulco_body, expression); } +void def_nullary(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_nullary_body, expression); } +void def_of(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_of_body, expression); } +void def_pam(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_pam_body, expression); } +void def_pm(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_pm_body, expression); } +void def_popd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_popd_body, expression); } +void def_popdd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_popdd_body, expression); } +void def_popop(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_popop_body, expression); } +void def_popopop(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_popopop_body, expression); } +void def_popopd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_popopd_body, expression); } +void def_popopdd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_popopdd_body, expression); } +void def_product(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_product_body, expression); } +void def_quoted(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_quoted_body, expression); } +void def_range(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_range_body, expression); } +void def_range_to_zero(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_range_to_zero_body, expression); } +void def_reco(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_reco_body, expression); } +void def_reverse(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_reverse_body, expression); } +void def_rrest(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_rrest_body, expression); } +void def_run(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_run_body, expression); } +void def_second(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_second_body, expression); } +void def_shift(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_shift_body, expression); } +void def_shunt(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_shunt_body, expression); } +void def_size(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_size_body, expression); } +void def_spiral_next(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_spiral_next_body, expression); } +void def_split_at(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_split_at_body, expression); } +void def_split_list(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_split_list_body, expression); } +void def_sqr(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_sqr_body, expression); } +void def_stackd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_stackd_body, expression); } +void def_step_zero(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_step_zero_body, expression); } +void def_stuncons(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_stuncons_body, expression); } +void def_sum(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_sum_body, expression); } +void def_swapd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_swapd_body, expression); } +void def_swons(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_swons_body, expression); } +void def_swoncat(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_swoncat_body, expression); } +void def_tailrec(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_tailrec_body, expression); } +void def_take(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_take_body, expression); } +void def_ternary(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_ternary_body, expression); } +void def_third(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_third_body, expression); } +void def_tuck(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_tuck_body, expression); } +void def_unary(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_unary_body, expression); } +void def_uncons(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_uncons_body, expression); } +void def_unit(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_unit_body, expression); } +void def_unquoted(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_unquoted_body, expression); } +void def_unswons(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_unswons_body, expression); } +void def_while(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_while_body, expression); } +void def_x(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_x_body, expression); } diff --git a/implementations/C/definitions.h b/implementations/C/definitions.h index 638fbb8..2b12ce2 100644 --- a/implementations/C/definitions.h +++ b/implementations/C/definitions.h @@ -22,5 +22,72 @@ void def_codireco(JoyListPtr stack, JoyListPtr expression); void def_dinfrirst(JoyListPtr stack, JoyListPtr expression); void def_dipd(JoyListPtr stack, JoyListPtr expression); void def_disenstacken(JoyListPtr stack, JoyListPtr expression); -void def_swons(JoyListPtr stack, JoyListPtr expression); +void def_down_to_zero(JoyListPtr stack, JoyListPtr expression); +void def_drop(JoyListPtr stack, JoyListPtr expression); +void def_dupd(JoyListPtr stack, JoyListPtr expression); +void def_dupdd(JoyListPtr stack, JoyListPtr expression); +void def_dupdip(JoyListPtr stack, JoyListPtr expression); +void def_dupdipd(JoyListPtr stack, JoyListPtr expression); +void def_enstacken(JoyListPtr stack, JoyListPtr expression); +void def_flatten(JoyListPtr stack, JoyListPtr expression); +void def_fork(JoyListPtr stack, JoyListPtr expression); +void def_fourth(JoyListPtr stack, JoyListPtr expression); +void def_gcd(JoyListPtr stack, JoyListPtr expression); +void def_genrec(JoyListPtr stack, JoyListPtr expression); +void def_grabN(JoyListPtr stack, JoyListPtr expression); +void def_grba(JoyListPtr stack, JoyListPtr expression); +void def_hypot(JoyListPtr stack, JoyListPtr expression); +void def_ifte(JoyListPtr stack, JoyListPtr expression); +void def_ii(JoyListPtr stack, JoyListPtr expression); void def_infra(JoyListPtr stack, JoyListPtr expression); +void def_infrst(JoyListPtr stack, JoyListPtr expression); +void def_make_generator(JoyListPtr stack, JoyListPtr expression); +void def_mod(JoyListPtr stack, JoyListPtr expression); +void def_neg(JoyListPtr stack, JoyListPtr expression); +void def_not(JoyListPtr stack, JoyListPtr expression); +void def_nulco(JoyListPtr stack, JoyListPtr expression); +void def_nullary(JoyListPtr stack, JoyListPtr expression); +void def_of(JoyListPtr stack, JoyListPtr expression); +void def_pam(JoyListPtr stack, JoyListPtr expression); +void def_pm(JoyListPtr stack, JoyListPtr expression); +void def_popd(JoyListPtr stack, JoyListPtr expression); +void def_popdd(JoyListPtr stack, JoyListPtr expression); +void def_popop(JoyListPtr stack, JoyListPtr expression); +void def_popopop(JoyListPtr stack, JoyListPtr expression); +void def_popopd(JoyListPtr stack, JoyListPtr expression); +void def_popopdd(JoyListPtr stack, JoyListPtr expression); +void def_product(JoyListPtr stack, JoyListPtr expression); +void def_quoted(JoyListPtr stack, JoyListPtr expression); +void def_range(JoyListPtr stack, JoyListPtr expression); +void def_range_to_zero(JoyListPtr stack, JoyListPtr expression); +void def_reco(JoyListPtr stack, JoyListPtr expression); +void def_reverse(JoyListPtr stack, JoyListPtr expression); +void def_rrest(JoyListPtr stack, JoyListPtr expression); +void def_run(JoyListPtr stack, JoyListPtr expression); +void def_second(JoyListPtr stack, JoyListPtr expression); +void def_shift(JoyListPtr stack, JoyListPtr expression); +void def_shunt(JoyListPtr stack, JoyListPtr expression); +void def_size(JoyListPtr stack, JoyListPtr expression); +void def_spiral_next(JoyListPtr stack, JoyListPtr expression); +void def_split_at(JoyListPtr stack, JoyListPtr expression); +void def_split_list(JoyListPtr stack, JoyListPtr expression); +void def_sqr(JoyListPtr stack, JoyListPtr expression); +void def_stackd(JoyListPtr stack, JoyListPtr expression); +void def_step_zero(JoyListPtr stack, JoyListPtr expression); +void def_stuncons(JoyListPtr stack, JoyListPtr expression); +void def_sum(JoyListPtr stack, JoyListPtr expression); +void def_swapd(JoyListPtr stack, JoyListPtr expression); +void def_swons(JoyListPtr stack, JoyListPtr expression); +void def_swoncat(JoyListPtr stack, JoyListPtr expression); +void def_tailrec(JoyListPtr stack, JoyListPtr expression); +void def_take(JoyListPtr stack, JoyListPtr expression); +void def_ternary(JoyListPtr stack, JoyListPtr expression); +void def_third(JoyListPtr stack, JoyListPtr expression); +void def_tuck(JoyListPtr stack, JoyListPtr expression); +void def_unary(JoyListPtr stack, JoyListPtr expression); +void def_uncons(JoyListPtr stack, JoyListPtr expression); +void def_unit(JoyListPtr stack, JoyListPtr expression); +void def_unquoted(JoyListPtr stack, JoyListPtr expression); +void def_unswons(JoyListPtr stack, JoyListPtr expression); +void def_while(JoyListPtr stack, JoyListPtr expression); +void def_x(JoyListPtr stack, JoyListPtr expression); diff --git a/implementations/C/defs.txt b/implementations/C/defs.txt index 849e81c..02cb88f 100644 --- a/implementations/C/defs.txt +++ b/implementations/C/defs.txt @@ -10,10 +10,8 @@ b [i] dip i binary unary popd ccccons ccons ccons ccons cons cons -clear [] swaack pop cleave fork popdd clop cleave popdd -cmp [[>] swap] dipd [ifte] ccons [=] swons ifte codi cons dip codireco codi reco dinfrirst dip infrst @@ -26,7 +24,6 @@ dupdd [dup] dipd dupdip dupd dip dupdipd dup dipd enstacken stack [clear] dip -first uncons pop flatten <{} [concat] step fork [i] app2 fourth rest third @@ -59,7 +56,6 @@ quoted [unit] dip range [0 <=] [1 - dup] anamorphism range_to_zero unit [down_to_zero] infra reco rest cons -rest uncons popd reverse <{} shunt rrest rest rest run <{} infra @@ -78,7 +74,6 @@ sum [+] step_zero swapd [swap] dip swons swap cons swoncat swap concat -sqr dup mul tailrec [i] genrec take <<{} [shift] times pop ternary binary popd diff --git a/implementations/C/keywords.c b/implementations/C/keywords.c index 8747df6..c7c559d 100644 --- a/implementations/C/keywords.c +++ b/implementations/C/keywords.c @@ -1,6 +1,6 @@ /* ANSI-C code produced by gperf version 3.1 */ /* Command-line: gperf --output-file=keywords.c --readonly-tables --enum --includes --hash-function-name=keyword_hash KEYWORDS.txt */ -/* Computed positions: -k'2,$' */ +/* Computed positions: -k'2-3,$' */ #if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \ && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \ @@ -36,7 +36,7 @@ #line 13 "KEYWORDS.txt" struct dict_entry; #include -/* maximum key range = 64, duplicates = 0 */ +/* maximum key range = 189, duplicates = 0 */ #ifdef __GNUC__ __inline @@ -50,38 +50,41 @@ keyword_hash (register const char *str, register size_t len) { static const unsigned char asso_values[] = { - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 60, 65, 65, - 65, 65, 55, 50, 65, 45, 65, 35, 65, 40, - 35, 25, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 20, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 20, 0, 0, - 25, 5, 65, 65, 25, 10, 65, 15, 30, 5, - 0, 0, 20, 65, 0, 0, 0, 15, 0, 5, - 65, 5, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65 + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 80, 190, 190, + 190, 190, 65, 40, 190, 10, 190, 5, 190, 105, + 90, 70, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 35, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 55, 20, 65, + 5, 35, 40, 30, 30, 0, 15, 90, 10, 10, + 15, 5, 0, 15, 65, 20, 45, 15, 65, 50, + 15, 75, 190, 25, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190 }; register unsigned int hval = len; switch (hval) { default: + hval += asso_values[(unsigned char)str[2]+1]; + /*FALLTHROUGH*/ + case 2: hval += asso_values[(unsigned char)str[1]]; /*FALLTHROUGH*/ case 1: @@ -95,116 +98,269 @@ in_word_set (register const char *str, register size_t len) { enum { - TOTAL_KEYWORDS = 42, + TOTAL_KEYWORDS = 109, MIN_WORD_LENGTH = 1, - MAX_WORD_LENGTH = 12, + MAX_WORD_LENGTH = 14, MIN_HASH_VALUE = 1, - MAX_HASH_VALUE = 64 + MAX_HASH_VALUE = 189 }; static const struct dict_entry wordlist[] = { {""}, -#line 44 "KEYWORDS.txt" - {"b", def_b}, -#line 42 "KEYWORDS.txt" - {"at", def_at}, -#line 36 "KEYWORDS.txt" - {"abs", def_abs}, -#line 24 "KEYWORDS.txt" - {"cons", cons}, -#line 47 "KEYWORDS.txt" - {"ccons", def_ccons}, -#line 25 "KEYWORDS.txt" - {"concat", concat}, -#line 46 "KEYWORDS.txt" - {"ccccons", def_ccccons}, -#line 51 "KEYWORDS.txt" - {"codireco", def_codireco}, -#line 32 "KEYWORDS.txt" - {"rest", rest}, -#line 55 "KEYWORDS.txt" - {"swons", def_swons}, #line 29 "KEYWORDS.txt" {"i", i_joyfunc}, -#line 43 "KEYWORDS.txt" - {"average", def_average}, - {""}, -#line 50 "KEYWORDS.txt" - {"codi", def_codi}, -#line 28 "KEYWORDS.txt" - {"first", first}, -#line 37 "KEYWORDS.txt" - {"anamorphism", def_anamorphism}, +#line 71 "KEYWORDS.txt" + {"ii", def_ii}, + {""}, {""}, {""}, +#line 19 "KEYWORDS.txt" + {"/", tdiv_q}, {""}, {""}, -#line 52 "KEYWORDS.txt" - {"dinfrirst", def_dinfrirst}, -#line 33 "KEYWORDS.txt" - {"stack", stack}, -#line 45 "KEYWORDS.txt" - {"binary", def_binary}, -#line 54 "KEYWORDS.txt" - {"disenstacken", def_disenstacken}, -#line 31 "KEYWORDS.txt" - {"pop", pop}, #line 30 "KEYWORDS.txt" {"loop", loop}, -#line 56 "KEYWORDS.txt" - {"infra", def_infra}, -#line 34 "KEYWORDS.txt" - {"swaack", swaack}, {""}, -#line 23 "KEYWORDS.txt" - {"cmp", cmp_joyfunc}, -#line 35 "KEYWORDS.txt" - {"swap", swap}, +#line 18 "KEYWORDS.txt" + {"-", sub}, + {""}, {""}, +#line 49 "KEYWORDS.txt" + {"clop", def_clop}, {""}, -#line 21 "KEYWORDS.txt" - {"branch", branch}, +#line 123 "KEYWORDS.txt" + {"x", def_x}, {""}, #line 26 "KEYWORDS.txt" {"dip", dip}, #line 20 "KEYWORDS.txt" {"bool", truthy}, -#line 22 "KEYWORDS.txt" - {"clear", clear}, -#line 19 "KEYWORDS.txt" - {"/", tdiv_q}, {""}, -#line 27 "KEYWORDS.txt" - {"dup", dup}, +#line 44 "KEYWORDS.txt" + {"b", def_b}, +#line 82 "KEYWORDS.txt" + {"pm", def_pm}, +#line 31 "KEYWORDS.txt" + {"pop", pop}, #line 53 "KEYWORDS.txt" {"dipd", def_dipd}, - {""}, -#line 48 "KEYWORDS.txt" - {"cleave", def_cleave}, - {""}, {""}, -#line 41 "KEYWORDS.txt" - {"appN", def_appN}, - {""}, -#line 18 "KEYWORDS.txt" - {"-", sub}, - {""}, {""}, -#line 40 "KEYWORDS.txt" - {"app3", def_app3}, - {""}, +#line 85 "KEYWORDS.txt" + {"popop", def_popop}, +#line 90 "KEYWORDS.txt" + {"quoted", def_quoted}, +#line 86 "KEYWORDS.txt" + {"popopop", def_popopop}, +#line 23 "KEYWORDS.txt" + {"cmp", cmp_joyfunc}, +#line 83 "KEYWORDS.txt" + {"popd", def_popd}, +#line 84 "KEYWORDS.txt" + {"popdd", def_popdd}, +#line 87 "KEYWORDS.txt" + {"popopd", def_popopd}, +#line 88 "KEYWORDS.txt" + {"popopdd", def_popopdd}, +#line 27 "KEYWORDS.txt" + {"dup", dup}, +#line 24 "KEYWORDS.txt" + {"cons", cons}, +#line 78 "KEYWORDS.txt" + {"nulco", def_nulco}, +#line 59 "KEYWORDS.txt" + {"dupdip", def_dupdip}, +#line 55 "KEYWORDS.txt" + {"down_to_zero", def_down_to_zero}, +#line 96 "KEYWORDS.txt" + {"run", def_run}, +#line 57 "KEYWORDS.txt" + {"dupd", def_dupd}, +#line 58 "KEYWORDS.txt" + {"dupdd", def_dupdd}, #line 17 "KEYWORDS.txt" {"+", add}, - {""}, {""}, -#line 49 "KEYWORDS.txt" - {"clop", def_clop}, +#line 60 "KEYWORDS.txt" + {"dupdipd", def_dupdipd}, +#line 108 "KEYWORDS.txt" + {"sum", def_sum}, +#line 50 "KEYWORDS.txt" + {"codi", def_codi}, {""}, +#line 118 "KEYWORDS.txt" + {"uncons", def_uncons}, + {""}, +#line 75 "KEYWORDS.txt" + {"mod", def_mod}, +#line 93 "KEYWORDS.txt" + {"reco", def_reco}, + {""}, +#line 97 "KEYWORDS.txt" + {"second", def_second}, +#line 62 "KEYWORDS.txt" + {"flatten", def_flatten}, +#line 51 "KEYWORDS.txt" + {"codireco", def_codireco}, +#line 41 "KEYWORDS.txt" + {"appN", def_appN}, +#line 115 "KEYWORDS.txt" + {"third", def_third}, +#line 37 "KEYWORDS.txt" + {"anamorphism", def_anamorphism}, + {""}, {""}, +#line 52 "KEYWORDS.txt" + {"dinfrirst", def_dinfrirst}, + {""}, +#line 25 "KEYWORDS.txt" + {"concat", concat}, + {""}, +#line 102 "KEYWORDS.txt" + {"split_at", def_split_at}, +#line 100 "KEYWORDS.txt" + {"size", def_size}, +#line 103 "KEYWORDS.txt" + {"split_list", def_split_list}, #line 16 "KEYWORDS.txt" {"*", mul}, - {""}, {""}, + {""}, +#line 77 "KEYWORDS.txt" + {"not", def_not}, +#line 56 "KEYWORDS.txt" + {"drop", def_drop}, +#line 28 "KEYWORDS.txt" + {"first", first}, +#line 101 "KEYWORDS.txt" + {"spiral_next", def_spiral_next}, +#line 54 "KEYWORDS.txt" + {"disenstacken", def_disenstacken}, + {""}, +#line 35 "KEYWORDS.txt" + {"swap", swap}, +#line 110 "KEYWORDS.txt" + {"swons", def_swons}, +#line 105 "KEYWORDS.txt" + {"stackd", def_stackd}, + {""}, +#line 92 "KEYWORDS.txt" + {"range_to_zero", def_range_to_zero}, +#line 119 "KEYWORDS.txt" + {"unit", def_unit}, +#line 109 "KEYWORDS.txt" + {"swapd", def_swapd}, +#line 15 "KEYWORDS.txt" + {"%", tdiv_r}, +#line 80 "KEYWORDS.txt" + {"of", def_of}, +#line 81 "KEYWORDS.txt" + {"pam", def_pam}, +#line 61 "KEYWORDS.txt" + {"enstacken", def_enstacken}, +#line 122 "KEYWORDS.txt" + {"while", def_while}, +#line 45 "KEYWORDS.txt" + {"binary", def_binary}, +#line 121 "KEYWORDS.txt" + {"unswons", def_unswons}, +#line 36 "KEYWORDS.txt" + {"abs", def_abs}, +#line 40 "KEYWORDS.txt" + {"app3", def_app3}, +#line 47 "KEYWORDS.txt" + {"ccons", def_ccons}, +#line 48 "KEYWORDS.txt" + {"cleave", def_cleave}, +#line 42 "KEYWORDS.txt" + {"at", def_at}, +#line 120 "KEYWORDS.txt" + {"unquoted", def_unquoted}, +#line 70 "KEYWORDS.txt" + {"ifte", def_ifte}, +#line 98 "KEYWORDS.txt" + {"shift", def_shift}, +#line 73 "KEYWORDS.txt" + {"infrst", def_infrst}, +#line 46 "KEYWORDS.txt" + {"ccccons", def_ccccons}, +#line 76 "KEYWORDS.txt" + {"neg", def_neg}, +#line 106 "KEYWORDS.txt" + {"step_zero", def_step_zero}, +#line 91 "KEYWORDS.txt" + {"range", def_range}, + {""}, +#line 111 "KEYWORDS.txt" + {"swoncat", def_swoncat}, +#line 104 "KEYWORDS.txt" + {"sqr", def_sqr}, +#line 113 "KEYWORDS.txt" + {"take", def_take}, +#line 72 "KEYWORDS.txt" + {"infra", def_infra}, +#line 64 "KEYWORDS.txt" + {"fourth", def_fourth}, +#line 79 "KEYWORDS.txt" + {"nullary", def_nullary}, +#line 65 "KEYWORDS.txt" + {"gcd", def_gcd}, #line 39 "KEYWORDS.txt" {"app2", def_app2}, {""}, -#line 15 "KEYWORDS.txt" - {"%", tdiv_r}, +#line 66 "KEYWORDS.txt" + {"genrec", def_genrec}, + {""}, {""}, +#line 116 "KEYWORDS.txt" + {"tuck", def_tuck}, +#line 117 "KEYWORDS.txt" + {"unary", def_unary}, + {""}, +#line 89 "KEYWORDS.txt" + {"product", def_product}, + {""}, +#line 63 "KEYWORDS.txt" + {"fork", def_fork}, +#line 22 "KEYWORDS.txt" + {"clear", clear}, +#line 21 "KEYWORDS.txt" + {"branch", branch}, {""}, {""}, #line 38 "KEYWORDS.txt" - {"app1", def_app1} + {"app1", def_app1}, +#line 67 "KEYWORDS.txt" + {"grabN", def_grabN}, + {""}, +#line 94 "KEYWORDS.txt" + {"reverse", def_reverse}, + {""}, +#line 32 "KEYWORDS.txt" + {"rest", rest}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 114 "KEYWORDS.txt" + {"ternary", def_ternary}, +#line 107 "KEYWORDS.txt" + {"stuncons", def_stuncons}, + {""}, +#line 69 "KEYWORDS.txt" + {"hypot", def_hypot}, + {""}, +#line 112 "KEYWORDS.txt" + {"tailrec", def_tailrec}, + {""}, +#line 74 "KEYWORDS.txt" + {"make_generator", def_make_generator}, +#line 99 "KEYWORDS.txt" + {"shunt", def_shunt}, + {""}, +#line 43 "KEYWORDS.txt" + {"average", def_average}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 95 "KEYWORDS.txt" + {"rrest", def_rrest}, + {""}, {""}, {""}, {""}, +#line 33 "KEYWORDS.txt" + {"stack", stack}, + {""}, {""}, {""}, {""}, {""}, +#line 34 "KEYWORDS.txt" + {"swaack", swaack}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, +#line 68 "KEYWORDS.txt" + {"grba", def_grba} }; if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)