2 /* format.y - SXEmacs format function
4 Copyright (C) 2006 Sebastian Freundt.
6 This file is part of SXEmacs.
8 SXEmacs is free software: you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation, either version 3 of the License, or (at your
11 option) any later version.
13 SXEmacs is distributed in the hope that it will be
14 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* Synched up with: Not in FSF. */
26 #include "cl-loop-parser.h"
28 #define YYENABLE_NLS 0
29 #define YYLTYPE_IS_TRIVIAL 1
31 static inline Lisp_Object
32 cl_loop_frob_scanner(Lisp_Object *scanner)
33 __attribute__((always_inline));
34 static inline Lisp_Object
35 cl_loop_frob_scanner(Lisp_Object *scanner)
37 if (!NILP(*scanner)) {
38 return XCAR(*scanner);
40 Fsignal(Qinvalid_read_syntax, *scanner);
46 cl_loop_step_scanner(Lisp_Object *scanner)
47 __attribute__((always_inline));
49 cl_loop_step_scanner(Lisp_Object *scanner)
51 if (!NILP(*scanner)) {
52 *scanner = XCDR(*scanner);
58 %define api.prefix {cl_loop_yy}
62 %parse-param {Lisp_Object *yyscanner}
63 %lex-param {Lisp_Object *yyscanner}
64 %parse-param {cl_loop_sentence_t *lsen}
65 %lex-param {cl_loop_sentence_t *lsen}
66 %parse-param {Lisp_Object *context}
67 %lex-param {Lisp_Object *context}
68 %parse-param {Lisp_Object *token}
69 %lex-param {Lisp_Object *token}
71 %token /* <forkeys> */
87 %token /* <withkeys> */
91 %token /* <gatherers> */
100 %token /* <terminators> */
109 %token /* <terminators> */
138 dllist_t iter = XDLLIST(lsen->iteration);
139 Lisp_Object do_clause = *context;
141 EMOD_CL_DEBUG_LOOP("accepting DO clause\n");
142 dllist_append(iter, (void*)do_clause);
145 dllist_t pro = XDLLIST(lsen->prologue);
146 Lisp_Object with_clause = *context;
148 EMOD_CL_DEBUG_LOOP("accepting WITH clause\n");
149 dllist_append(pro, (void*)with_clause);
152 dllist_t pro = XDLLIST(lsen->prologue);
153 dllist_t iter = XDLLIST(lsen->iteration);
154 Lisp_Object repeat_clause = *context;
156 EMOD_CL_DEBUG_LOOP("accepting REPEAT clause\n");
157 dllist_append(pro, (void*)repeat_clause);
158 dllist_append(iter, (void*)repeat_clause);
161 dllist_t pro = XDLLIST(lsen->prologue);
162 dllist_t iter = XDLLIST(lsen->iteration);
163 dllist_t epi = XDLLIST(lsen->epilogue);
164 Lisp_Object append_clause = *context;
166 EMOD_CL_DEBUG_LOOP("accepting APPEND clause\n");
167 dllist_append(pro, (void*)append_clause);
168 dllist_append(iter, (void*)append_clause);
169 dllist_append(epi, (void*)append_clause);
172 dllist_t pro = XDLLIST(lsen->prologue);
173 dllist_t iter = XDLLIST(lsen->iteration);
174 dllist_t epi = XDLLIST(lsen->epilogue);
175 Lisp_Object collect_clause = *context;
177 EMOD_CL_DEBUG_LOOP("accepting COLLECT clause\n");
178 dllist_append(pro, (void*)collect_clause);
179 dllist_append(iter, (void*)collect_clause);
180 dllist_append(epi, (void*)collect_clause);
183 dllist_t pro = XDLLIST(lsen->prologue);
184 dllist_t iter = XDLLIST(lsen->iteration);
185 dllist_t epi = XDLLIST(lsen->epilogue);
186 Lisp_Object nconc_clause = *context;
188 EMOD_CL_DEBUG_LOOP("accepting NCONC clause\n");
189 dllist_append(pro, (void*)nconc_clause);
190 dllist_append(iter, (void*)nconc_clause);
191 dllist_append(epi, (void*)nconc_clause);
194 dllist_t pro = XDLLIST(lsen->prologue);
195 dllist_t iter = XDLLIST(lsen->iteration);
196 dllist_t epi = XDLLIST(lsen->epilogue);
197 Lisp_Object accu_clause = *context;
199 EMOD_CL_DEBUG_LOOP("accepting SUM clause\n");
200 dllist_append(pro, (void*)accu_clause);
201 dllist_append(iter, (void*)accu_clause);
202 dllist_append(epi, (void*)accu_clause);
205 dllist_t pro = XDLLIST(lsen->prologue);
206 dllist_t iter = XDLLIST(lsen->iteration);
207 dllist_t epi = XDLLIST(lsen->epilogue);
208 Lisp_Object accu_clause = *context;
210 EMOD_CL_DEBUG_LOOP("accepting count clause\n");
211 dllist_append(pro, (void*)accu_clause);
212 dllist_append(iter, (void*)accu_clause);
213 dllist_append(epi, (void*)accu_clause);
216 dllist_t pro = XDLLIST(lsen->prologue);
217 dllist_t iter = XDLLIST(lsen->iteration);
218 dllist_t epi = XDLLIST(lsen->epilogue);
219 Lisp_Object accu_clause = *context;
221 EMOD_CL_DEBUG_LOOP("accepting MAXIMISE clause\n");
222 dllist_append(pro, (void*)accu_clause);
223 dllist_append(iter, (void*)accu_clause);
224 dllist_append(epi, (void*)accu_clause);
227 dllist_t pro = XDLLIST(lsen->prologue);
228 dllist_t iter = XDLLIST(lsen->iteration);
229 dllist_t epi = XDLLIST(lsen->epilogue);
230 Lisp_Object accu_clause = *context;
232 EMOD_CL_DEBUG_LOOP("accepting MINIMISE clause\n");
233 dllist_append(pro, (void*)accu_clause);
234 dllist_append(iter, (void*)accu_clause);
235 dllist_append(epi, (void*)accu_clause);
238 dllist_t pro = XDLLIST(lsen->prologue);
239 Lisp_Object initially_clause = *context;
241 EMOD_CL_DEBUG_LOOP("accepting INITIALLY clause\n");
242 dllist_append(pro, (void*)initially_clause);
245 dllist_t epi = XDLLIST(lsen->epilogue);
246 Lisp_Object finally_clause = *context;
248 EMOD_CL_DEBUG_LOOP("accepting FINALLY clause\n");
249 dllist_append(epi, (void*)finally_clause);
252 dllist_t epi = XDLLIST(lsen->epilogue);
253 Lisp_Object return_clause = *context;
255 EMOD_CL_DEBUG_LOOP("accepting RETURN clause\n");
256 dllist_append(epi, (void*)return_clause);
258 /* | while | until | always | never | thereis
259 * if | when | unless | else | end | named
263 /* clauses in greater detail */
267 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
269 EMOD_CL_DEBUG_LOOP("DO clause found\n");
270 *context = cl_loop_make_do_clause(form);
271 cl_loop_step_scanner(yyscanner);
275 append | append into;
278 collect | collect into;
290 minimise | minimise into;
293 maximise | maximise into;
298 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
300 EMOD_CL_DEBUG_LOOP("APPEND clause found\n");
301 *context = cl_loop_make_append_clause(form);
302 cl_loop_step_scanner(yyscanner);
308 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
310 EMOD_CL_DEBUG_LOOP("COLLECT clause found\n");
311 *context = cl_loop_make_collect_clause(form);
312 cl_loop_step_scanner(yyscanner);
318 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
320 EMOD_CL_DEBUG_LOOP("NCONC clause found\n");
321 *context = cl_loop_make_nconc_clause(form);
322 cl_loop_step_scanner(yyscanner);
328 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
330 EMOD_CL_DEBUG_LOOP("COUNT clause found\n");
331 *context = cl_loop_make_count_clause(form);
332 cl_loop_step_scanner(yyscanner);
338 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
340 EMOD_CL_DEBUG_LOOP("SUM clause found\n");
341 *context = cl_loop_make_sum_clause(form);
342 cl_loop_step_scanner(yyscanner);
348 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
350 EMOD_CL_DEBUG_LOOP("MAXIMISE clause found\n");
351 *context = cl_loop_make_maximise_clause(form);
352 cl_loop_step_scanner(yyscanner);
358 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
360 EMOD_CL_DEBUG_LOOP("MINIMISE clause found\n");
361 *context = cl_loop_make_minimise_clause(form);
362 cl_loop_step_scanner(yyscanner);
368 Lisp_Object acn_clause = *context;
369 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
371 EMOD_CL_DEBUG_LOOP("INTO found\n");
372 if (EQ(get_dynacat_type(acn_clause), Qcl_loop_collect_clause)) {
373 cl_loop_accu_clause_t *cc = get_dynacat(acn_clause);
375 } else if (EQ(get_dynacat_type(acn_clause), Qcl_loop_append_clause)) {
376 cl_loop_accu_clause_t *ac = get_dynacat(acn_clause);
378 } else if (EQ(get_dynacat_type(acn_clause), Qcl_loop_nconc_clause)) {
379 cl_loop_accu_clause_t *nc = get_dynacat(acn_clause);
381 } else if (EQ(get_dynacat_type(acn_clause), Qcl_loop_count_clause)) {
382 cl_loop_accu_clause_t *nc = get_dynacat(acn_clause);
384 } else if (EQ(get_dynacat_type(acn_clause), Qcl_loop_sum_clause)) {
385 cl_loop_accu_clause_t *nc = get_dynacat(acn_clause);
387 } else if (EQ(get_dynacat_type(acn_clause), Qcl_loop_minimise_clause)) {
388 cl_loop_accu_clause_t *nc = get_dynacat(acn_clause);
390 } else if (EQ(get_dynacat_type(acn_clause), Qcl_loop_maximise_clause)) {
391 cl_loop_accu_clause_t *nc = get_dynacat(acn_clause);
396 cl_loop_step_scanner(yyscanner);
402 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
404 EMOD_CL_DEBUG_LOOP("REPEAT clause found\n");
405 *context = cl_loop_make_repeat_clause(form);
406 cl_loop_step_scanner(yyscanner);
412 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
414 EMOD_CL_DEBUG_LOOP("RETURN clause found\n");
415 *context = cl_loop_make_return_clause(form);
416 cl_loop_step_scanner(yyscanner);
422 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
424 EMOD_CL_DEBUG_LOOP("INITIALLY clause found\n");
425 *context = cl_loop_make_initially_clause(form);
426 cl_loop_step_scanner(yyscanner);
432 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
434 EMOD_CL_DEBUG_LOOP("FINALLY clause found\n");
435 *context = cl_loop_make_finally_clause(form);
436 cl_loop_step_scanner(yyscanner);
441 with equals with_and_clause;
445 and equals with_and_clause;
449 for_clause for_and_clause;
453 and_clause for_and_clause;
457 dllist_t pro = XDLLIST(lsen->prologue);
458 dllist_t iter = XDLLIST(lsen->iteration);
459 Lisp_Object for_clause = *context;
460 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
462 EMOD_CL_DEBUG_LOOP("accepting FOR clause, arithmetic form\n");
463 fc->for_subclause = FOR_ARITHMETIC_CLAUSE;
464 dllist_append(iter, (void*)for_clause);
465 dllist_append(pro, (void*)for_clause);
468 dllist_t pro = XDLLIST(lsen->prologue);
469 dllist_t iter = XDLLIST(lsen->iteration);
470 Lisp_Object for_clause = *context;
471 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
473 EMOD_CL_DEBUG_LOOP("accepting FOR clause, in-list form\n");
474 fc->for_subclause = FOR_IN_SUBLIST_CLAUSE;
475 dllist_append(iter, (void*)for_clause);
476 dllist_append(pro, (void*)for_clause);
479 dllist_t pro = XDLLIST(lsen->prologue);
480 dllist_t iter = XDLLIST(lsen->iteration);
481 Lisp_Object for_clause = *context;
482 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
484 EMOD_CL_DEBUG_LOOP("accepting FOR clause, on-list form\n");
485 fc->for_subclause = FOR_ON_SUBLIST_CLAUSE;
486 dllist_append(iter, (void*)for_clause);
487 dllist_append(pro, (void*)for_clause);
490 dllist_t pro = XDLLIST(lsen->prologue);
491 dllist_t iter = XDLLIST(lsen->iteration);
492 Lisp_Object for_clause = *context;
493 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
495 EMOD_CL_DEBUG_LOOP("accepting FOR clause, across-array form\n");
496 fc->for_subclause = FOR_ACROSS_ARRAY_CLAUSE;
497 dllist_append(iter, (void*)for_clause);
498 dllist_append(pro, (void*)for_clause);
500 for_equals_then_clause {
501 dllist_t pro = XDLLIST(lsen->prologue);
502 dllist_t iter = XDLLIST(lsen->iteration);
503 Lisp_Object for_clause = *context;
504 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
506 EMOD_CL_DEBUG_LOOP("accepting FOR clause, =-then form\n");
507 fc->for_subclause = FOR_EQUALS_THEN_CLAUSE;
508 dllist_append(pro, (void*)for_clause);
509 dllist_append(iter, (void*)for_clause);
512 dllist_t pro = XDLLIST(lsen->prologue);
513 dllist_t iter = XDLLIST(lsen->iteration);
514 Lisp_Object for_clause = *context;
515 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
517 EMOD_CL_DEBUG_LOOP("accepting FOR clause, of-hash-table form\n");
518 fc->for_subclause = FOR_OF_HASHTABLE_CLAUSE;
519 dllist_append(pro, (void*)for_clause);
520 dllist_append(iter, (void*)for_clause);
525 cl_loop_for_clause_t *fc = get_dynacat(*context);
526 EMOD_CL_DEBUG_LOOP("accepting FOR+AND clause, arithmetic form\n");
527 fc->for_subclause = FOR_ARITHMETIC_CLAUSE;
530 cl_loop_for_clause_t *fc = get_dynacat(*context);
531 EMOD_CL_DEBUG_LOOP("accepting FOR+AND clause, in-list form\n");
532 fc->for_subclause = FOR_IN_SUBLIST_CLAUSE;
535 cl_loop_for_clause_t *fc = get_dynacat(*context);
536 EMOD_CL_DEBUG_LOOP("accepting FOR+AND clause, on-list form\n");
537 fc->for_subclause = FOR_ON_SUBLIST_CLAUSE;
540 cl_loop_for_clause_t *fc = get_dynacat(*context);
541 EMOD_CL_DEBUG_LOOP("accepting FOR+AND clause, across-array form\n");
542 fc->for_subclause = FOR_ACROSS_ARRAY_CLAUSE;
544 and_equals_then_clause {
545 cl_loop_for_clause_t *fc = get_dynacat(*context);
546 EMOD_CL_DEBUG_LOOP("accepting FOR+AND clause, =-then form\n");
547 fc->for_subclause = FOR_EQUALS_THEN_CLAUSE;
550 cl_loop_for_clause_t *fc = get_dynacat(*context);
551 EMOD_CL_DEBUG_LOOP("accepting FOR+AND clause, of-hash-table form\n");
552 fc->for_subclause = FOR_OF_HASHTABLE_CLAUSE;
573 for_equals_then_clause:
576 and_equals_then_clause:
580 for being_each_hash_key_in |
581 for being_each_hash_value_in |
582 for being_each_hash_key_in using |
583 for being_each_hash_value_in using;
586 and being_each_hash_key_in |
587 and being_each_hash_value_in |
588 and being_each_hash_key_in using |
589 and being_each_hash_value_in using;
629 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
631 EMOD_CL_DEBUG_LOOP("FOR clause found\n");
632 *context = cl_loop_make_for_clause(form);
633 cl_loop_step_scanner(yyscanner);
637 from to by | from by to | to from by | to by from | by from to | by to from;
640 from below by | from by below | below from by | below by from |
641 by from below | by below from;
644 from above by | from by above | above from by | above by from |
645 by from above | by above from;
654 from below | below from;
657 from above | above from;
671 Lisp_Object for_clause = *context;
672 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
673 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
675 EMOD_CL_DEBUG_LOOP("FROM found\n");
677 if (EQ(*token, Qdownfrom)) {
678 EMOD_CL_DEBUG_LOOP("FROM found is even a DOWNFROM\n");
679 fc->torel = ASE_BINARY_REL_GREATERP;
680 fc->byop = ASE_BINARY_OP_DIFF;
682 cl_loop_step_scanner(yyscanner);
688 Lisp_Object for_clause = *context;
689 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
690 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
692 EMOD_CL_DEBUG_LOOP("TO found\n");
694 if (EQ(*token, Qdownto)) {
695 EMOD_CL_DEBUG_LOOP("TO found is even a DOWNTO\n");
696 fc->torel = ASE_BINARY_REL_GREATERP;
697 fc->byop = ASE_BINARY_OP_DIFF;
699 cl_loop_step_scanner(yyscanner);
705 Lisp_Object for_clause = *context;
706 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
707 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
709 EMOD_CL_DEBUG_LOOP("BY found\n");
711 cl_loop_step_scanner(yyscanner);
717 Lisp_Object for_clause = *context;
718 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
719 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
721 EMOD_CL_DEBUG_LOOP("BELOW found\n");
722 fc->torel = ASE_BINARY_REL_LESSP;
723 fc->torel_strictp = 1;
724 fc->byop = ASE_BINARY_OP_SUM;
726 cl_loop_step_scanner(yyscanner);
733 Lisp_Object for_clause = *context;
734 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
735 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
737 EMOD_CL_DEBUG_LOOP("ABOVE found\n");
738 fc->torel = ASE_BINARY_REL_GREATERP;
739 fc->torel_strictp = 1;
740 fc->byop = ASE_BINARY_OP_DIFF;
742 cl_loop_step_scanner(yyscanner);
748 Lisp_Object for_clause = *context;
749 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
750 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
752 EMOD_CL_DEBUG_LOOP("IN found\n");
753 fc->inonacross = form;
754 cl_loop_step_scanner(yyscanner);
760 Lisp_Object for_clause = *context;
761 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
762 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
764 EMOD_CL_DEBUG_LOOP("ON found\n");
765 fc->inonacross = form;
766 cl_loop_step_scanner(yyscanner);
772 Lisp_Object for_clause = *context;
773 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
774 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
776 EMOD_CL_DEBUG_LOOP("ACROSS found\n");
777 fc->inonacross = form;
778 cl_loop_step_scanner(yyscanner);
784 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
786 EMOD_CL_DEBUG_LOOP("WITH clause found\n");
787 *context = cl_loop_make_with_clause(form);
788 cl_loop_step_scanner(yyscanner);
794 Lisp_Object clause = *context;
795 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
797 if (EQ(get_dynacat_type(clause), Qcl_loop_with_clause)) {
798 Lisp_Object newwf = cl_loop_make_with_clause(form);
799 cl_loop_with_clause_t *newwc = get_dynacat(newwf);
800 cl_loop_with_clause_t *oldwc = get_dynacat(clause);
802 EMOD_CL_DEBUG_LOOP("WITH+AND clause found\n");
803 newwc->next = *context;
804 newwc->depth += oldwc->depth;
806 } else if (EQ(get_dynacat_type(clause), Qcl_loop_for_clause)) {
807 Lisp_Object newff = cl_loop_make_for_clause(form);
808 cl_loop_for_clause_t *oldfc = get_dynacat(*context);
810 EMOD_CL_DEBUG_LOOP("FOR+AND clause found\n");
815 Fsignal(Qinvalid_read_syntax, *yyscanner);
818 cl_loop_step_scanner(yyscanner);
824 Lisp_Object clause = *context;
825 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
827 if (EQ(get_dynacat_type(clause), Qcl_loop_with_clause)) {
828 cl_loop_with_clause_t *wc = get_dynacat(clause);
829 EMOD_CL_DEBUG_LOOP("= found in WITH context\n");
831 } else if (EQ(get_dynacat_type(clause), Qcl_loop_for_clause)) {
832 cl_loop_for_clause_t *fc = get_dynacat(clause);
833 EMOD_CL_DEBUG_LOOP("= found in FOR context\n");
836 Fsignal(Qinvalid_read_syntax, *yyscanner);
839 cl_loop_step_scanner(yyscanner);
845 Lisp_Object for_clause = *context;
846 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
847 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
849 EMOD_CL_DEBUG_LOOP("THEN found\n");
851 cl_loop_step_scanner(yyscanner);
854 being_each_hash_key_in:
855 BEING EACH HASH_KEY IN
857 Lisp_Object for_clause = *context;
858 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
859 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
861 EMOD_CL_DEBUG_LOOP("BEING EACH HASH_KEY found\n");
862 fc->inonacross = form;
863 fc->hash_keyvar = fc->form1;
864 cl_loop_step_scanner(yyscanner);
867 being_each_hash_value_in:
868 BEING EACH HASH_VALUE IN
870 Lisp_Object for_clause = *context;
871 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
872 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
874 EMOD_CL_DEBUG_LOOP("BEING EACH HASH_VALUE found\n");
875 fc->inonacross = form;
876 fc->hash_valvar = fc->form1;
877 cl_loop_step_scanner(yyscanner);
883 Lisp_Object for_clause = *context;
884 cl_loop_for_clause_t *fc = get_dynacat(for_clause);
885 Lisp_Object form = cl_loop_frob_scanner(yyscanner);
887 EMOD_CL_DEBUG_LOOP("USING found\n");
888 if (CONSP(form) && CONSP(XCDR(form)) &&
889 EQ(XCAR(form), Qhash_key)) {
890 EMOD_CL_DEBUG_LOOP("USING specifies HASH_KEY symbol\n");
891 fc->hash_keyvar = XCAR(XCDR(form));
892 } else if (CONSP(form) && CONSP(XCDR(form)) &&
893 EQ(XCAR(form), Qhash_value)) {
894 EMOD_CL_DEBUG_LOOP("USING specifies HASH_VALUE symbol\n");
895 fc->hash_valvar = XCAR(XCDR(form));
897 cl_loop_step_scanner(yyscanner);