kb_mapping_macros

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.cyc.cycjava.cycl
Class kb_mapping_macros

java.lang.Object
  com.cyc.tool.subl.util.SubLTrampolineFile
      com.cyc.tool.subl.util.SubLTranslatedFile
          com.cyc.cycjava.cycl.kb_mapping_macros

All Implemented Interfaces:: CommonSymbols, SubLFile

public final class kb_mapping_macros
extends SubLTranslatedFile
extends SubLTranslatedFile

Nested Class Summary
`static class`	`kb_mapping_macros.$assertion_semantically_matches_simple_final_index_specP$BinaryFunction`
`static class`	`kb_mapping_macros.$clear_simple_term_assertion_list_filtered$ZeroArityFunction`
`static class`	`kb_mapping_macros.$decontextualized_ist_predicate_rule_final_index_spec_iterator_doneP$UnaryFunction`
`static class`	`kb_mapping_macros.$decontextualized_ist_predicate_rule_final_index_spec_iterator_next$UnaryFunction`
`static class`	`kb_mapping_macros.$decontextualized_ist_predicate_rule_index_asent_match_p$BinaryFunction`
`static class`	`kb_mapping_macros.$gaf_arg_final_index_spec_iterator_doneP$UnaryFunction`
`static class`	`kb_mapping_macros.$gaf_arg_final_index_spec_iterator_next$UnaryFunction`
`static class`	`kb_mapping_macros.$nart_arg_final_index_spec_iterator_doneP$UnaryFunction`
`static class`	`kb_mapping_macros.$nart_arg_final_index_spec_iterator_next$UnaryFunction`
`static class`	`kb_mapping_macros.$other_index_assertion_match_p$BinaryFunction`
`static class`	`kb_mapping_macros.$pred_arg2_rule_final_index_spec_iterator_doneP$UnaryFunction`
`static class`	`kb_mapping_macros.$pred_arg2_rule_final_index_spec_iterator_next$UnaryFunction`
`static class`	`kb_mapping_macros.$predicate_extent_final_index_spec_iterator_doneP$UnaryFunction`
`static class`	`kb_mapping_macros.$predicate_extent_final_index_spec_iterator_next$UnaryFunction`
`static class`	`kb_mapping_macros.$predicate_rule_final_index_spec_iterator_doneP$UnaryFunction`
`static class`	`kb_mapping_macros.$predicate_rule_final_index_spec_iterator_next$UnaryFunction`

Nested classes/interfaces inherited from class com.cyc.tool.subl.util.SubLTranslatedFile
`SubLTranslatedFile.SubL`

Field Summary
`static SubLObject`	`$const103$termOfUnit`
`static SubLObject`	`$const138$isa`
`static SubLObject`	`$const147$quotedIsa`
`static SubLObject`	`$const154$genls`
`static SubLObject`	`$const162$genlMt`
`static SubLObject`	`$const319$abnormal`
`static SubLObject`	`$const320$meetsPragmaticRequirement`
`static SubLObject`	`$const321$ist`
`static SubLInteger`	`$int311$512`
`static SubLSymbol`	`$kw108$SENSE`
`static SubLSymbol`	`$kw109$POS`
`static SubLSymbol`	`$kw110$NEG`
`static SubLSymbol`	`$kw119$SENSE_KEYS_ARE_FRESH`
`static SubLSymbol`	`$kw120$PREDICATE_RULE`
`static SubLSymbol`	`$kw122$MT_KEYS_ARE_FRESH`
`static SubLSymbol`	`$kw130$DECONTEXTUALIZED_IST_PREDICATE_RULE`
`static SubLSymbol`	`$kw139$ISA_RULE`
`static SubLSymbol`	`$kw148$QUOTED_ISA_RULE`
`static SubLSymbol`	`$kw155$GENLS_RULE`
`static SubLSymbol`	`$kw163$GENL_MT_RULE`
`static SubLSymbol`	`$kw17$ALLOW_OTHER_KEYS`
`static SubLSymbol`	`$kw174$FUNCTION_RULE`
`static SubLSymbol`	`$kw18$TRUTH`
`static SubLSymbol`	`$kw184$EXCEPTION_RULE`
`static SubLSymbol`	`$kw19$DIRECTION`
`static SubLSymbol`	`$kw193$PRAGMA_RULE`
`static SubLSymbol`	`$kw20$DONE`
`static SubLSymbol`	`$kw206$TYPE`
`static SubLSymbol`	`$kw223$SIMPLE`
`static SubLSymbol`	`$kw224$OTHER`
`static SubLSymbol`	`$kw238$MT`
`static SubLSymbol`	`$kw239$BROAD_MT`
`static SubLSymbol`	`$kw248$METHODS`
`static SubLSymbol`	`$kw257$OVERLAP`
`static SubLSymbol`	`$kw261$INDEX_TYPE`
`static SubLSymbol`	`$kw270$TERM`
`static SubLSymbol`	`$kw271$ARGNUM`
`static SubLSymbol`	`$kw275$TERMS`
`static SubLSymbol`	`$kw28$GAF`
`static SubLSymbol`	`$kw285$FUNCTION_EXTENT`
`static SubLSymbol`	`$kw294$FUNCTOR`
`static SubLSymbol`	`$kw30$RULE`
`static SubLSymbol`	`$kw303$NART`
`static SubLSymbol`	`$kw313$_MEMOIZED_ITEM_NOT_FOUND_`
`static SubLSymbol`	`$kw35$PROGRESS_MESSAGE`
`static SubLSymbol`	`$kw55$INDEX`
`static SubLSymbol`	`$kw56$PREDICATE`
`static SubLSymbol`	`$kw66$ANY`
`static SubLSymbol`	`$kw69$ARGNUM_KEYS_ARE_FRESH`
`static SubLSymbol`	`$kw70$GAF_ARG`
`static SubLSymbol`	`$kw71$PREDICATE_KEYS_ARE_FRESH`
`static SubLSymbol`	`$kw80$PREDICATE_EXTENT`
`static SubLSymbol`	`$kw83$FUNCTION`
`static SubLSymbol`	`$kw90$NART_ARG`
`static SubLSymbol`	`$kw92$FUNCTION_KEYS_ARE_FRESH`
`static SubLList`	`$list0`
`static SubLList`	`$list102`
`static SubLList`	`$list104`
`static SubLList`	`$list105`
`static SubLList`	`$list106`
`static SubLList`	`$list111`
`static SubLList`	`$list112`
`static SubLList`	`$list13`
`static SubLList`	`$list132`
`static SubLList`	`$list15`
`static SubLList`	`$list156`
`static SubLList`	`$list16`
`static SubLList`	`$list166`
`static SubLList`	`$list176`
`static SubLList`	`$list195`
`static SubLList`	`$list204`
`static SubLList`	`$list205`
`static SubLList`	`$list212`
`static SubLList`	`$list213`
`static SubLList`	`$list220`
`static SubLList`	`$list230`
`static SubLList`	`$list231`
`static SubLList`	`$list24`
`static SubLList`	`$list240`
`static SubLList`	`$list243`
`static SubLList`	`$list244`
`static SubLList`	`$list246`
`static SubLList`	`$list247`
`static SubLList`	`$list251`
`static SubLList`	`$list27`
`static SubLList`	`$list276`
`static SubLList`	`$list277`
`static SubLList`	`$list280`
`static SubLList`	`$list3`
`static SubLList`	`$list300`
`static SubLList`	`$list302`
`static SubLList`	`$list304`
`static SubLList`	`$list306`
`static SubLList`	`$list314`
`static SubLList`	`$list315`
`static SubLList`	`$list317`
`static SubLList`	`$list318`
`static SubLList`	`$list33`
`static SubLList`	`$list34`
`static SubLList`	`$list38`
`static SubLList`	`$list40`
`static SubLList`	`$list41`
`static SubLList`	`$list44`
`static SubLList`	`$list45`
`static SubLList`	`$list5`
`static SubLList`	`$list53`
`static SubLList`	`$list54`
`static SubLList`	`$list63`
`static SubLList`	`$list72`
`static SubLList`	`$list81`
`static SubLList`	`$list82`
`static SubLList`	`$list9`
`static SubLList`	`$list93`
`static SubLList`	`$list98`
`static SubLList`	`$list99`
`static SubLString`	`$str121$predicate_rule_iterator_quiescens`
`static SubLString`	`$str131$ist_predicate_rule_iterator_quies`
`static SubLString`	`$str164$pred_arg2_rule_iterator_quiescens`
`static SubLString`	`$str165$unexpected_pred_in_pred_arg2_inde`
`static SubLString`	`$str175$function_rule_iterator_quiescense`
`static SubLString`	`$str185$exception_rule_iterator_quiescens`
`static SubLString`	`$str194$pragma_rule_iterator_quiescense_f`
`static SubLString`	`$str203$unbound_predicate_rule_iterator_q`
`static SubLString`	`$str229$Iterate_over_all_assertions_index`
`static SubLString`	`$str233$do_broad_mt_index`
`static SubLString`	`$str262$Skip_iteration`
`static SubLString`	`$str263$Unsupported_method__S_in__S_in_DO`
`static SubLString`	`$str289$Unsupported_method__S_in__S_in_DO`
`static SubLString`	`$str301$Unexpected_non_simple_index__s`
`static SubLString`	`$str305$unexpected_type__s_in_simple_fina`
`static SubLString`	`$str62$Iterate_over_an_index_of_gaf_asse`
`static SubLString`	`$str91$nart_arg_keys_should_never_be_irr`
`static SubLSymbol`	`$sym1$PWHEN`
`static SubLSymbol`	`$sym10$ASSERTION_HAS_TRUTH`
`static SubLSymbol`	`$sym100$TOU`
`static SubLSymbol`	`$sym101$GAF_ARG1`
`static SubLSymbol`	`$sym107$DO_PREDICATE_RULE_INDEX`
`static SubLSymbol`	`$sym11$COR`
`static SubLSymbol`	`$sym113$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym114$DO_PREDICATE_RULE_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym115$NEW_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym116$PREDICATE_RULE_INDEX_ASENT_MATCH_P`
`static SubLSymbol`	`$sym117$PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_`
`static SubLSymbol`	`$sym118$PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT`
`static SubLSymbol`	`$sym12$NULL`
`static SubLSymbol`	`$sym123$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym124$DO_DECONTEXTUALIZED_IST_PREDICATE_RULE_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym125$NEW_DECONTEXTUALIZED_IST_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym126$DO_DECONTEXTUALIZED_IST_PREDICATE_RULE_INDEX`
`static SubLSymbol`	`$sym127$DECONTEXTUALIZED_IST_PREDICATE_RULE_INDEX_ASENT_MATCH_P`
`static SubLSymbol`	`$sym128$DECONTEXTUALIZED_IST_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_DON`
`static SubLSymbol`	`$sym129$DECONTEXTUALIZED_IST_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_NEX`
`static SubLSymbol`	`$sym133$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym134$DO_ISA_RULE_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym135$NEW_ISA_RULE_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym136$DO_ISA_RULE_INDEX`
`static SubLSymbol`	`$sym137$ISA_RULE_INDEX_ASENT_MATCH_P`
`static SubLSymbol`	`$sym14$ASSERTION_HAS_DIRECTION_SPEC`
`static SubLSymbol`	`$sym140$PRED_ARG2_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_`
`static SubLSymbol`	`$sym141$PRED_ARG2_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT`
`static SubLSymbol`	`$sym142$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym143$DO_QUOTED_ISA_RULE_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym144$NEW_QUOTED_ISA_RULE_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym145$DO_QUOTED_ISA_RULE_INDEX`
`static SubLSymbol`	`$sym146$QUOTED_ISA_RULE_INDEX_ASENT_MATCH_P`
`static SubLSymbol`	`$sym149$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym150$DO_GENLS_RULE_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym151$NEW_GENLS_RULE_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym152$DO_GENLS_RULE_INDEX`
`static SubLSymbol`	`$sym153$GENLS_RULE_INDEX_ASENT_MATCH_P`
`static SubLSymbol`	`$sym157$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym158$DO_GENL_MT_RULE_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym159$NEW_GENL_MT_RULE_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym160$DO_GENL_MT_RULE_INDEX`
`static SubLSymbol`	`$sym161$GENL_MT_RULE_INDEX_ASENT_MATCH_P`
`static SubLSymbol`	`$sym167$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym168$DO_FUNCTION_RULE_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym169$NEW_FUNCTION_RULE_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym170$DO_FUNCTION_RULE_INDEX`
`static SubLSymbol`	`$sym171$FUNCTION_RULE_INDEX_ASENT_MATCH_P`
`static SubLSymbol`	`$sym172$FUNCTION_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_`
`static SubLSymbol`	`$sym173$FUNCTION_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT`
`static SubLSymbol`	`$sym177$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym178$DO_EXCEPTION_RULE_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym179$NEW_EXCEPTION_RULE_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym180$DO_EXCEPTION_RULE_INDEX`
`static SubLSymbol`	`$sym181$EXCEPTION_RULE_INDEX_ASENT_MATCH_P`
`static SubLSymbol`	`$sym182$EXCEPTION_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_`
`static SubLSymbol`	`$sym183$EXCEPTION_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT`
`static SubLSymbol`	`$sym186$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym187$DO_PRAGMA_RULE_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym188$NEW_PRAGMA_RULE_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym189$DO_PRAGMA_RULE_INDEX`
`static SubLSymbol`	`$sym190$PRAGMA_RULE_INDEX_ASENT_MATCH_P`
`static SubLSymbol`	`$sym191$PRAGMA_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_`
`static SubLSymbol`	`$sym192$PRAGMA_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT`
`static SubLSymbol`	`$sym196$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym197$DO_UNBOUND_PREDICATE_RULE_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym198$NEW_UNBOUND_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym199$DO_UNBOUND_PREDICATE_RULE_INDEX`
`static SubLSymbol`	`$sym2$RELEVANT_PRED_`
`static SubLSymbol`	`$sym200$UNBOUND_PREDICATE_RULE_INDEX_ASENT_MATCH_P`
`static SubLSymbol`	`$sym201$UNBOUND_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_`
`static SubLSymbol`	`$sym202$UNBOUND_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT`
`static SubLSymbol`	`$sym207$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym208$DO_MT_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym209$MT_FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym21$DO_LIST`
`static SubLSymbol`	`$sym210$DO_MT_INDEX`
`static SubLSymbol`	`$sym211$MT_INDEX_ASSERTION_MATCH_P`
`static SubLSymbol`	`$sym214$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym215$DO_OTHER_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym216$OTHER_FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym217$DO_OTHER_INDEX_ASSERTION_MATCH_P`
`static SubLSymbol`	`$sym218$DO_OTHER_INDEX`
`static SubLSymbol`	`$sym219$OTHER_INDEX_ASSERTION_MATCH_P`
`static SubLSymbol`	`$sym22$PWHEN_ASSERTION_HAS_TRUTH`
`static SubLSymbol`	`$sym221$OTHER_FINAL_INDEX_SPEC_P`
`static SubLSymbol`	`$sym222$DO_TERM_INDEX`
`static SubLSymbol`	`$sym225$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym226$DO_TERM_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym227$NEW_TERM_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym228$DO_TERM_INDEX_ASSERTION_MATCH_P`
`static SubLSymbol`	`$sym23$PWHEN_ASSERTION_HAS_DIRECTION_SPEC`
`static SubLSymbol`	`$sym232$DO_BROAD_MT_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym234$DO_BROAD_MT_INDEX_MATCH_P`
`static SubLSymbol`	`$sym235$DO_BROAD_MT_INDEX`
`static SubLSymbol`	`$sym236$PCASE`
`static SubLSymbol`	`$sym237$DO_MT_CONTENTS_METHOD`
`static SubLSymbol`	`$sym241$DO_MT_CONTENTS`
`static SubLSymbol`	`$sym242$HLMT_P`
`static SubLSymbol`	`$sym245$GATHER_OVERLAP_INDEX`
`static SubLSymbol`	`$sym249$DO_GAF_LOOKUP_INDEX`
`static SubLSymbol`	`$sym25$DO_ASSERTION_LIST`
`static SubLSymbol`	`$sym250$BEST_GAF_LOOKUP_INDEX`
`static SubLSymbol`	`$sym252$L_INDEX`
`static SubLSymbol`	`$sym253$METHOD`
`static SubLSymbol`	`$sym254$DO_GLI_EXTRACT_METHOD`
`static SubLSymbol`	`$sym255$DO_GLI_VIA_GAF_ARG`
`static SubLSymbol`	`$sym256$DO_GLI_VIA_PREDICATE_EXTENT`
`static SubLSymbol`	`$sym258$DO_GLI_VIA_OVERLAP`
`static SubLSymbol`	`$sym259$OTHERWISE`
`static SubLSymbol`	`$sym26$DO_SIMPLE_INDEX_TERM_ASSERTION_LIST`
`static SubLSymbol`	`$sym260$DO_GLI_METHOD_ERROR`
`static SubLSymbol`	`$sym264$TERM`
`static SubLSymbol`	`$sym265$ARGNUM`
`static SubLSymbol`	`$sym266$PREDICATE`
`static SubLSymbol`	`$sym267$CMULTIPLE_VALUE_BIND`
`static SubLSymbol`	`$sym268$DO_GLI_VGA_EXTRACT_KEYS`
`static SubLSymbol`	`$sym269$PIF`
`static SubLSymbol`	`$sym272$DO_GLI_VPE_EXTRACT_KEY`
`static SubLSymbol`	`$sym273$DO_OVERLAP_INDEX`
`static SubLSymbol`	`$sym274$DO_GLI_VO_EXTRACT_KEY`
`static SubLSymbol`	`$sym278$DO_NAT_LOOKUP_INDEX`
`static SubLSymbol`	`$sym279$BEST_NAT_LOOKUP_INDEX`
`static SubLSymbol`	`$sym281$L_INDEX`
`static SubLSymbol`	`$sym282$METHOD`
`static SubLSymbol`	`$sym283$DO_NLI_EXTRACT_METHOD`
`static SubLSymbol`	`$sym284$DO_NLI_VIA_NART_ARG`
`static SubLSymbol`	`$sym286$DO_NLI_VIA_FUNCTION_EXTENT`
`static SubLSymbol`	`$sym287$DO_NLI_VIA_OVERLAP`
`static SubLSymbol`	`$sym288$DO_NLI_METHOD_ERROR`
`static SubLSymbol`	`$sym29$GAF_ASSERTION_`
`static SubLSymbol`	`$sym290$TERM`
`static SubLSymbol`	`$sym291$ARGNUM`
`static SubLSymbol`	`$sym292$FUNCTOR`
`static SubLSymbol`	`$sym293$DO_NLI_VNA_EXTRACT_KEYS`
`static SubLSymbol`	`$sym295$DO_NLI_VFE_EXTRACT_KEY`
`static SubLSymbol`	`$sym296$DO_NLI_VO_EXTRACT_KEY`
`static SubLSymbol`	`$sym297$ASSERTION_SEMANTICALLY_MATCHES_SIMPLE_FINAL_INDEX_SPEC_`
`static SubLSymbol`	`$sym298$FINAL_INDEX_ITERATOR_FILTERED`
`static SubLSymbol`	`$sym299$QUOTE`
`static SubLSymbol`	`$sym307$FINAL_INDEX_P`
`static SubLSymbol`	`$sym308$ASSERTION_MATCHES_TYPE_TRUTH_AND_DIRECTION_`
`static SubLSymbol`	`$sym309$SIMPLE_TERM_ASSERTION_LIST_FILTERED`
`static SubLSymbol`	`$sym31$RULE_ASSERTION_`
`static SubLSymbol`	`$sym310$_SIMPLE_TERM_ASSERTION_LIST_FILTERED_CACHING_STATE_`
`static SubLSymbol`	`$sym312$CLEAR_SIMPLE_TERM_ASSERTION_LIST_FILTERED`
`static SubLSymbol`	`$sym316$EL_FORMULA_P`
`static SubLSymbol`	`$sym32$ASSERTION_HAS_TYPE`
`static SubLSymbol`	`$sym36$UNTIL_MAPPING_FINISHED`
`static SubLSymbol`	`$sym37$SOME_ASSERTIONS_INTERNAL`
`static SubLSymbol`	`$sym39$SOME_ASSERTIONS`
`static SubLSymbol`	`$sym4$RELEVANT_MT_`
`static SubLSymbol`	`$sym42$DO_ASSERTIONS`
`static SubLSymbol`	`$sym43$DO_FINAL_INDEX_FROM_SPEC`
`static SubLSymbol`	`$sym46$FINAL_INDEX_ITERATOR`
`static SubLSymbol`	`$sym47$CLET`
`static SubLSymbol`	`$sym48$CUNWIND_PROTECT`
`static SubLSymbol`	`$sym49$CSETQ`
`static SubLSymbol`	`$sym50$NEW_FINAL_INDEX_ITERATOR`
`static SubLSymbol`	`$sym51$DO_ITERATOR_WITHOUT_VALUES_INTERNAL`
`static SubLSymbol`	`$sym52$DESTROY_FINAL_INDEX_ITERATOR`
`static SubLSymbol`	`$sym57$PRED_VAR`
`static SubLSymbol`	`$sym58$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym59$DO_GAF_ARG_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym6$PROGN`
`static SubLSymbol`	`$sym60$NEW_GAF_ARG_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym61$DO_GAF_ARG_INDEX`
`static SubLSymbol`	`$sym64$ASSERTION`
`static SubLSymbol`	`$sym65$GAF_ARG`
`static SubLSymbol`	`$sym67$GAF_ARG_FINAL_INDEX_SPEC_ITERATOR_DONE_`
`static SubLSymbol`	`$sym68$GAF_ARG_FINAL_INDEX_SPEC_ITERATOR_NEXT`
`static SubLSymbol`	`$sym7$TRUTH_RELEVANT_P`
`static SubLSymbol`	`$sym73$PRED_VAR`
`static SubLSymbol`	`$sym74$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym75$DO_PREDICATE_EXTENT_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym76$NEW_PREDICATE_EXTENT_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym77$DO_PREDICATE_EXTENT_INDEX`
`static SubLSymbol`	`$sym78$PREDICATE_EXTENT_FINAL_INDEX_SPEC_ITERATOR_DONE_`
`static SubLSymbol`	`$sym79$PREDICATE_EXTENT_FINAL_INDEX_SPEC_ITERATOR_NEXT`
`static SubLSymbol`	`$sym8$PWHEN_TRUTH_RELEVANT`
`static SubLSymbol`	`$sym84$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym85$DO_NART_ARG_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym86$NEW_NART_ARG_FINAL_INDEX_SPEC_ITERATOR`
`static SubLSymbol`	`$sym87$DO_NART_ARG_INDEX`
`static SubLSymbol`	`$sym88$NART_ARG_FINAL_INDEX_SPEC_ITERATOR_DONE_`
`static SubLSymbol`	`$sym89$NART_ARG_FINAL_INDEX_SPEC_ITERATOR_NEXT`
`static SubLSymbol`	`$sym94$FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym95$DO_FUNCTION_EXTENT_INDEX_KEY_VALIDATOR`
`static SubLSymbol`	`$sym96$FUNCTION_EXTENT_FINAL_INDEX_SPEC`
`static SubLSymbol`	`$sym97$DO_FUNCTION_EXTENT_INDEX`
`static SubLFile`	`me`
`static java.lang.String`	`myName`

Fields inherited from class com.cyc.tool.subl.util.SubLTranslatedFile
`EMPTY_SUBL_OBJECT_ARRAY`

Fields inherited from interface com.cyc.tool.subl.jrtl.nativeCode.subLisp.CommonSymbols
ANSWER_TAG, APPEND_KEYWORD, APPEND_STACK_TRACES_TO_ERROR_MESSAGES, AREF, ASSEMBLE_FIXNUMS_TO_INTEGER, ATOM, BIGNUMP, BINARY_KEYWORD, BINDING_TYPE, BOOLEANP, CAAR, CADR, CAND, CAR, CCATCH, CDEC, CDESTRUCTURING_BIND, CDO, CDO_ALL_SYMBOLS, CDO_EXTERNAL_SYMBOLS, CDO_SYMBOLS, CDOHASH, CDOLIST, CDOTIMES, CDR, CHAR, CHAR_E_SYMBOL, CHAR_EQUAL_SYMBOL, CHAR_GREATER_THAN_OR_EQUAL_SYMBOL, CHAR_GREATER_THAN_SYMBOL, CHAR_GT_SYMBOL, CHAR_GTE_SYMBOL, CHAR_LESS_THAN_OR_EQUAL_SYMBOL, CHAR_LESS_THAN_SYMBOL, CHAR_LT_SYMBOL, CHAR_LTE_SYMBOL, CHAR_NE_SYMBOL, CHAR_NOT_EQUAL_SYMBOL, CHARACTERP, CHECK_TYPE, CINC, CLET, CMULTIPLE_VALUE_BIND, CNOT, CONS, CONSP, CONSTANT, COR, CPOP, CPROGV, CPUSH, CPUSHNEW, CREATE_KEYWORD, CSETF, CSETQ, CSOME, CTIME, CUNWIND_PROTECT, CVS_ID, DEBUG_IO, DECLAIM, DECLARE, DEFCONSTANT, DEFINE, DEFLEXICAL, DEFMACRO, DEFPARAMETER, DEFVAR, DIRECTION_KEYWORD, DYNAMIC, EIGHT_INTEGER, EIGHTEEN_INTEGER, ELEMENT_TYPE_KEYWORD, ELEVEN_INTEGER, END_KEYWORD, ENFORCE_MUST, ENFORCE_TYPE, EQ, EQL, EQUAL, EQUALP, ERROR, ERROR_KEYWORD, ERROR_OUTPUT, EVAL, EXTERNAL_FORMAT_KEYWORD, EXTERNAL_KEYWORD, FIF, FIFTEEN_INTEGER, FIRST, FIVE_INTEGER, FIXNUMP, FLOATP, FOUR_INTEGER, FOURTEEN_INTEGER, FUNCTION, FUNCTION_SPEC_P, FUNCTIONP, FUNLESS, FWHEN, GET, GETHASH, GETHASH_WITHOUT_VALUES, GUID_P, HASH_TABLE_ITERATOR_P, HASH_TABLE_P, IDENTITY, IF_DOES_NOT_EXIST_KEYWORD, IF_EXISTS_KEYWORD, IGNORE, INITIALIZATION_TYPE, INITIALIZER, INPUT_KEYWORD, INPUT_STREAM_P, INTEGERP, INTERNAL_KEYWORD, IO_KEYWORD, KEYWORDP, KILL_KEYWORD, LAMBDA_SYMBOL, LEXICAL, LIST, LISTP, LISTS, LOCK_P, LONG_BIGNUM_P, MACRO_ENV, MACRO_FORM, MEDIUM_BIGNUM_P, MEMBER, MINUS_ONE_INTEGER, MULTIPLE_VALUE_LIST, MUST, NCONC, NEW_VERSION_KEYWORD, NIL, NINE_INTEGER, NINETEEN_INTEGER, NREVERSE, NTH, NTH_VALUE, NULL, NULL_INPUT, NULL_OUTPUT, NUM_E_SYMBOL, NUM_GT_SYMBOL, NUM_GTE_SYMBOL, NUM_LT_SYMBOL, NUM_LTE_SYMBOL, NUM_NE_SYMBOL, NUMBERP, ONE_HUNDRED_THIRTY_SEVEN_INTEGER, ONE_HUNDRED_TWENTY_SEVEN_INTEGER, ONE_INTEGER, ONE_THOUSAND_INTEGER, OPTIONAL_SYMBOL, OTHERWISE, OUTPUT_KEYWORD, OUTPUT_STREAM_P, OVERWRITE_KEYWORD, PACKAGEP, PCASE, PCOND, PIF, PROBE_KEYWORD, PROCESS_TO_END, PROCESSP, PROCLAIM, PROGN, PUNLESS, PWHEN, QUERY_IO, QUIT, QUOTE, RENAME_AND_DELETE_KEYWORD, REST_SYMBOL, RET, RET_NIL, RET_T, RETURN_TAG, REVERSE, RW_LOCK_P, SECOND, SEQUENCEP, SEVEN_INTEGER, SEVENTEEN_INTEGER, SHORT_BIGNUM_P, SHOW_STACK_TRACES, SIX_INTEGER, SIXTEEN_INTEGER, SIXTY_FOUR_INTEGER, SORT, SSS, STANDARD_INPUT, STANDARD_OUTPUT, START_KEYWORD, STREAMP, STRING_E_SYMBOL, STRING_EQUAL_SYMBOL, STRING_GREATER_THAN_OR_EQUAL_SYMBOL, STRING_GREATER_THAN_SYMBOL, STRING_GT_SYMBOL, STRING_GTE_SYMBOL, STRING_LESS_THAN_OR_EQUAL_SYMBOL, STRING_LESS_THAN_SYMBOL, STRING_LT_SYMBOL, STRING_LTE_SYMBOL, STRING_NE_SYMBOL, STRING_NOT_EQUAL_SYMBOL, STRINGP, STRUCTURE_P, SUPERSEDE_KEYWORD, SUSPEND_TYPE_CHECKING, SYMBOL_FUNCTION, SYMBOL_VALUE, SYMBOLP, T, TEN_INTEGER, TERMINAL_IO, TEXT_KEYWORD, THIRTEEN_INTEGER, THIRTY_FOUR_INTEGER, THIRTY_THREE_INTEGER, THIRTY_TWO_INTEGER, THREE_INTEGER, TRACE_OUTPUT, TRUE, TWELVE_INTEGER, TWENTY_INTEGER, TWO_HUNDRED_FIFTY_FOUR_INTEGER, TWO_HUNDRED_FORTY_FOUR_INTEGER, TWO_INTEGER, UNDECLARED, UNPROVIDED, VALUES, VECTOR, VECTORP, WITH_ERROR_HANDLER, WITH_STATIC_AREA, WITH_THREAD_PRIVATE_AREA, WITH_WORKING_AREA, WORLD, ZERO_DOUBLE, ZERO_INTEGER

Fields inherited from interface com.cyc.tool.subl.jrtl.nativeCode.subLisp.CommonSymbols

ANSWER_TAG, APPEND_KEYWORD, APPEND_STACK_TRACES_TO_ERROR_MESSAGES, AREF, ASSEMBLE_FIXNUMS_TO_INTEGER, ATOM, BIGNUMP, BINARY_KEYWORD, BINDING_TYPE, BOOLEANP, CAAR, CADR, CAND, CAR, CCATCH, CDEC, CDESTRUCTURING_BIND, CDO, CDO_ALL_SYMBOLS, CDO_EXTERNAL_SYMBOLS, CDO_SYMBOLS, CDOHASH, CDOLIST, CDOTIMES, CDR, CHAR, CHAR_E_SYMBOL, CHAR_EQUAL_SYMBOL, CHAR_GREATER_THAN_OR_EQUAL_SYMBOL, CHAR_GREATER_THAN_SYMBOL, CHAR_GT_SYMBOL, CHAR_GTE_SYMBOL, CHAR_LESS_THAN_OR_EQUAL_SYMBOL, CHAR_LESS_THAN_SYMBOL, CHAR_LT_SYMBOL, CHAR_LTE_SYMBOL, CHAR_NE_SYMBOL, CHAR_NOT_EQUAL_SYMBOL, CHARACTERP, CHECK_TYPE, CINC, CLET, CMULTIPLE_VALUE_BIND, CNOT, CONS, CONSP, CONSTANT, COR, CPOP, CPROGV, CPUSH, CPUSHNEW, CREATE_KEYWORD, CSETF, CSETQ, CSOME, CTIME, CUNWIND_PROTECT, CVS_ID, DEBUG_IO, DECLAIM, DECLARE, DEFCONSTANT, DEFINE, DEFLEXICAL, DEFMACRO, DEFPARAMETER, DEFVAR, DIRECTION_KEYWORD, DYNAMIC, EIGHT_INTEGER, EIGHTEEN_INTEGER, ELEMENT_TYPE_KEYWORD, ELEVEN_INTEGER, END_KEYWORD, ENFORCE_MUST, ENFORCE_TYPE, EQ, EQL, EQUAL, EQUALP, ERROR, ERROR_KEYWORD, ERROR_OUTPUT, EVAL, EXTERNAL_FORMAT_KEYWORD, EXTERNAL_KEYWORD, FIF, FIFTEEN_INTEGER, FIRST, FIVE_INTEGER, FIXNUMP, FLOATP, FOUR_INTEGER, FOURTEEN_INTEGER, FUNCTION, FUNCTION_SPEC_P, FUNCTIONP, FUNLESS, FWHEN, GET, GETHASH, GETHASH_WITHOUT_VALUES, GUID_P, HASH_TABLE_ITERATOR_P, HASH_TABLE_P, IDENTITY, IF_DOES_NOT_EXIST_KEYWORD, IF_EXISTS_KEYWORD, IGNORE, INITIALIZATION_TYPE, INITIALIZER, INPUT_KEYWORD, INPUT_STREAM_P, INTEGERP, INTERNAL_KEYWORD, IO_KEYWORD, KEYWORDP, KILL_KEYWORD, LAMBDA_SYMBOL, LEXICAL, LIST, LISTP, LISTS, LOCK_P, LONG_BIGNUM_P, MACRO_ENV, MACRO_FORM, MEDIUM_BIGNUM_P, MEMBER, MINUS_ONE_INTEGER, MULTIPLE_VALUE_LIST, MUST, NCONC, NEW_VERSION_KEYWORD, NIL, NINE_INTEGER, NINETEEN_INTEGER, NREVERSE, NTH, NTH_VALUE, NULL, NULL_INPUT, NULL_OUTPUT, NUM_E_SYMBOL, NUM_GT_SYMBOL, NUM_GTE_SYMBOL, NUM_LT_SYMBOL, NUM_LTE_SYMBOL, NUM_NE_SYMBOL, NUMBERP, ONE_HUNDRED_THIRTY_SEVEN_INTEGER, ONE_HUNDRED_TWENTY_SEVEN_INTEGER, ONE_INTEGER, ONE_THOUSAND_INTEGER, OPTIONAL_SYMBOL, OTHERWISE, OUTPUT_KEYWORD, OUTPUT_STREAM_P, OVERWRITE_KEYWORD, PACKAGEP, PCASE, PCOND, PIF, PROBE_KEYWORD, PROCESS_TO_END, PROCESSP, PROCLAIM, PROGN, PUNLESS, PWHEN, QUERY_IO, QUIT, QUOTE, RENAME_AND_DELETE_KEYWORD, REST_SYMBOL, RET, RET_NIL, RET_T, RETURN_TAG, REVERSE, RW_LOCK_P, SECOND, SEQUENCEP, SEVEN_INTEGER, SEVENTEEN_INTEGER, SHORT_BIGNUM_P, SHOW_STACK_TRACES, SIX_INTEGER, SIXTEEN_INTEGER, SIXTY_FOUR_INTEGER, SORT, SSS, STANDARD_INPUT, STANDARD_OUTPUT, START_KEYWORD, STREAMP, STRING_E_SYMBOL, STRING_EQUAL_SYMBOL, STRING_GREATER_THAN_OR_EQUAL_SYMBOL, STRING_GREATER_THAN_SYMBOL, STRING_GT_SYMBOL, STRING_GTE_SYMBOL, STRING_LESS_THAN_OR_EQUAL_SYMBOL, STRING_LESS_THAN_SYMBOL, STRING_LT_SYMBOL, STRING_LTE_SYMBOL, STRING_NE_SYMBOL, STRING_NOT_EQUAL_SYMBOL, STRINGP, STRUCTURE_P, SUPERSEDE_KEYWORD, SUSPEND_TYPE_CHECKING, SYMBOL_FUNCTION, SYMBOL_VALUE, SYMBOLP, T, TEN_INTEGER, TERMINAL_IO, TEXT_KEYWORD, THIRTEEN_INTEGER, THIRTY_FOUR_INTEGER, THIRTY_THREE_INTEGER, THIRTY_TWO_INTEGER, THREE_INTEGER, TRACE_OUTPUT, TRUE, TWELVE_INTEGER, TWENTY_INTEGER, TWO_HUNDRED_FIFTY_FOUR_INTEGER, TWO_HUNDRED_FORTY_FOUR_INTEGER, TWO_INTEGER, UNDECLARED, UNPROVIDED, VALUES, VECTOR, VECTORP, WITH_ERROR_HANDLER, WITH_STATIC_AREA, WITH_THREAD_PRIVATE_AREA, WITH_WORKING_AREA, WORLD, ZERO_DOUBLE, ZERO_INTEGER

Method Summary
`static SubLObject`	`asent_syntactically_matches_simple_rule_final_index_specP(SubLObject asent, SubLObject v_term, SubLObject asent_func)`
`static SubLObject`	`assertion_matches_syntactic_indexing_typeP(SubLObject assertion, SubLObject type)`
`static SubLObject`	`assertion_semantically_matches_simple_final_index_specP(SubLObject assertion, SubLObject simple_final_index_spec)` Assumes that ASSERTION syntactically matches SIMPLE-FINAL-INDEX-SPEC
`static SubLObject`	`assertion_syntactically_matches_simple_assertion_final_index_specP(SubLObject assertion, SubLObject v_term, SubLObject assertion_final_index_spec)`
`static SubLObject`	`assertion_syntactically_matches_simple_final_index_specP(SubLObject assertion, SubLObject simple_final_index_spec)`
`static SubLObject`	`clear_simple_term_assertion_list_filtered()`
`static SubLObject`	`declare_kb_mapping_macros_file()`
`void`	`declareFunctions()` Declares the mapping between functions and symbols for all named functions defined in the file.
`static SubLObject`	`decontextualized_ist_predicate_rule_current_relevant_keylist(SubLObject state)` If STATE's current keylist is valid, returns it.
`static SubLObject`	`decontextualized_ist_predicate_rule_final_index_spec_iterator_doneP(SubLObject state)`
`static SubLObject`	`decontextualized_ist_predicate_rule_final_index_spec_iterator_next_direction_key(SubLObject state)`
`static SubLObject`	`decontextualized_ist_predicate_rule_final_index_spec_iterator_next(SubLObject state)`
`static SubLObject`	`decontextualized_ist_predicate_rule_final_index_spec_iterator_quiesce_one_step(SubLObject state)` STATE is assumed to be invalid.
`static SubLObject`	`decontextualized_ist_predicate_rule_final_index_spec_iterator_quiesce(SubLObject state)` Iterates over the keys in STATE until it ends up with its current keylist (@see decontextualized-ist-predicate-rule-current-keylist) being valid and relevant, with validity and relevance being determined by @xref decontextualized-ist-predicate-rule-current-relevant-keylist.
`static SubLObject`	`decontextualized_ist_predicate_rule_final_index_spec_iterator_refill_direction_keys(SubLObject state)` refill the direction-keys by popping a sense but don't actually pop the sense if it's fresh, just note that it's unfresh now
`static SubLObject`	`decontextualized_ist_predicate_rule_final_index_spec_iterator_state_direction_keys(SubLObject state)` The remaining directions left to iterate over
`static SubLObject`	`decontextualized_ist_predicate_rule_final_index_spec_iterator_state_direction(SubLObject state)` The input direction
`static SubLObject`	`decontextualized_ist_predicate_rule_final_index_spec_iterator_state_note(SubLObject state)` A note containing information about the state of the keys, used to control code flow
`static SubLObject`	`decontextualized_ist_predicate_rule_final_index_spec_iterator_state_predicate(SubLObject state)` The input predicate
`static SubLObject`	`decontextualized_ist_predicate_rule_final_index_spec_iterator_state_sense_keys(SubLObject state)` The remaining senses to iterate over
`static SubLObject`	`decontextualized_ist_predicate_rule_index_asent_match_p(SubLObject asent, SubLObject predicate)`
`static SubLObject`	`decontextualized_ist_predicate_rule_keylist_to_final_index_spec(SubLObject pred, SubLObject keylist)`
`static SubLObject`	`destroy_final_index_iterator(SubLObject final_index_iterator)`
`static SubLObject`	`do_decontextualized_ist_predicate_rule_index_key_validator(SubLObject predicate, SubLObject sense, SubLObject direction)`
`static SubLObject`	`do_exception_rule_index_key_validator(SubLObject rule, SubLObject direction)`
`static SubLObject`	`do_function_extent_index_key_validator(SubLObject function)` Return T iff FUNCTION is a valid key for DO-FUNCTION-EXTENT-INDEX.
`static SubLObject`	`do_function_rule_index_key_validator(SubLObject function, SubLObject direction)`
`static SubLObject`	`do_gaf_arg_index_key_validator(SubLObject v_term, SubLObject argnum, SubLObject predicate)` Return T iff TERM, ARGNUM and PREDICATE are valid keys for DO-GAF-ARG-INDEX.
`static SubLObject`	`do_genl_mt_rule_index_key_validator(SubLObject genl_mt, SubLObject sense, SubLObject direction)`
`static SubLObject`	`do_genls_rule_index_key_validator(SubLObject collection, SubLObject sense, SubLObject direction)`
`static SubLObject`	`do_gli_extract_method(SubLObject lookup_index)`
`static SubLObject`	`do_gli_vga_extract_keys(SubLObject lookup_index)`
`static SubLObject`	`do_gli_vpe_extract_key(SubLObject lookup_index)`
`static SubLObject`	`do_isa_rule_index_key_validator(SubLObject collection, SubLObject sense, SubLObject direction)`
`static SubLObject`	`do_mt_index_key_validator(SubLObject mt, SubLObject type)`
`static SubLObject`	`do_nart_arg_index_key_validator(SubLObject v_term, SubLObject index, SubLObject function)` Return T iff TERM, INDEX and FUNCTION are valid keys for DO-NART-ARG-INDEX.
`static SubLObject`	`do_other_index_key_validator(SubLObject v_term, SubLObject type)`
`static SubLObject`	`do_pragma_rule_index_key_validator(SubLObject rule, SubLObject direction)`
`static SubLObject`	`do_pred_arg2_rule_index_key_validator(SubLObject arg2, SubLObject sense, SubLObject direction)`
`static SubLObject`	`do_predicate_extent_index_key_validator(SubLObject predicate)` Return T iff PREDICATE is a valid key for DO-PREDICATE-EXTENT-INDEX.
`static SubLObject`	`do_predicate_rule_index_key_validator(SubLObject predicate, SubLObject sense, SubLObject direction)`
`static SubLObject`	`do_quoted_isa_rule_index_key_validator(SubLObject collection, SubLObject sense, SubLObject direction)`
`static SubLObject`	`do_term_index_assertion_match_p(SubLObject assertion, SubLObject final_index_spec)` The :other index is the only one that needs this post-hoc semantic filtering.
`static SubLObject`	`do_term_index_key_validator(SubLObject v_term, SubLObject type)`
`static SubLObject`	`final_index_iterator_filtered(SubLObject final_index_spec, SubLObject type_spec, SubLObject truth_spec, SubLObject direction_spec)` Gets the index of TERM, then follows each key in KEYS in succession.
`static SubLObject`	`function_extent_final_index_spec(SubLObject function)` Makes the single final-index-spec for FUNCTION.
`static SubLObject`	`function_rule_final_index_spec_iterator_doneP(SubLObject state)`
`static SubLObject`	`function_rule_final_index_spec_iterator_state_direction_keys(SubLObject state)` The remaining directions left to iterate over
`static SubLObject`	`function_rule_final_index_spec_iterator_state_mt_keys(SubLObject state)` The remaining mts left to iterate over
`static SubLObject`	`function_rule_final_index_spec_iterator_state_note(SubLObject state)` A note containing information about the state of the keys, used to control code flow
`static SubLObject`	`gaf_arg_current_relevant_keylist(SubLObject state)` If STATE's current keylist is valid and relevant, returns it.
`static SubLObject`	`gaf_arg_final_index_spec_iterator_doneP(SubLObject state)`
`static SubLObject`	`gaf_arg_final_index_spec_iterator_next_mt_key(SubLObject state)`
`static SubLObject`	`gaf_arg_final_index_spec_iterator_next(SubLObject state)`
`static SubLObject`	`gaf_arg_final_index_spec_iterator_quiesce_one_step(SubLObject state)` STATE is assumed to be invalid or irrelevant.
`static SubLObject`	`gaf_arg_final_index_spec_iterator_quiesce(SubLObject state)` Iterates over the keys in STATE until it ends up with its current keylist (@see gaf-arg-current-keylist) being valid and relevant, with validity and relevance being determined by @xref gaf-arg-current-relevant-keylist.
`static SubLObject`	`gaf_arg_final_index_spec_iterator_refill_mt_keys(SubLObject state)` refill the mt-keys by popping a predicate but don't actually pop the predicate if it's fresh, just note that it's unfresh now
`static SubLObject`	`gaf_arg_final_index_spec_iterator_refill_predicate_keys(SubLObject state)` refill the predicate-keys by popping an argnum but don't actually pop the argnum if it's fresh, just note that it's unfresh now
`static SubLObject`	`gaf_arg_final_index_spec_iterator_state_argnum_keys(SubLObject state)` The remaining argnums to iterate over
`static SubLObject`	`gaf_arg_final_index_spec_iterator_state_mt_keys(SubLObject state)` The remaining mts left to iterate over
`static SubLObject`	`gaf_arg_final_index_spec_iterator_state_note(SubLObject state)` A note containing information about the state of the keys, used to control code flow
`static SubLObject`	`gaf_arg_final_index_spec_iterator_state_predicate_keys(SubLObject state)` The remaining predicates left to iterate over
`static SubLObject`	`gaf_arg_final_index_spec_iterator_state_predicate(SubLObject state)` The input predicate
`static SubLObject`	`gaf_arg_final_index_spec_iterator_state_term(SubLObject state)` The input term
`static SubLObject`	`gaf_arg_keylist_to_final_index_spec(SubLObject v_term, SubLObject keylist)`
`static SubLObject`	`gaf_matches_simple_argnum_specP(SubLObject gaf, SubLObject v_term, SubLObject argnum_spec)`
`static SubLObject`	`gaf_syntactically_matches_simple_gaf_final_index_specP(SubLObject gaf, SubLObject v_term, SubLObject gaf_final_index_spec)`
`static SubLObject`	`genls_rule_index_asent_match_p(SubLObject asent, SubLObject collection)`
`static SubLObject`	`genls_rule_index_asent_p(SubLObject asent)`
`static SubLObject`	`init_kb_mapping_macros_file()`
`static SubLObject`	`initialize_decontextualized_ist_predicate_rule_final_index_spec_iterator_state(SubLObject predicate, SubLObject sense, SubLObject direction)`
`static SubLObject`	`initialize_function_rule_final_index_spec_iterator_state(SubLObject func, SubLObject direction)`
`static SubLObject`	`initialize_gaf_arg_final_index_spec_iterator_state(SubLObject v_term, SubLObject argnum, SubLObject predicate)`
`static SubLObject`	`initialize_nart_arg_final_index_spec_iterator_state(SubLObject v_term, SubLObject argnum, SubLObject function)`
`static SubLObject`	`initialize_pred_arg2_rule_final_index_spec_iterator_state(SubLObject pred, SubLObject top_level_key, SubLObject arg2, SubLObject sense, SubLObject direction)`
`static SubLObject`	`initialize_predicate_extent_final_index_spec_iterator_state(SubLObject predicate)`
`static SubLObject`	`initialize_predicate_rule_final_index_spec_iterator_state(SubLObject predicate, SubLObject sense, SubLObject direction)`
`void`	`initializeVariables()` Initializes all global variables and private internal variables for constants defined in the file.
`static SubLObject`	`key_pred_arg2_rule_index(SubLObject pred, SubLObject arg2, SubLObject sense, SubLObject mt)`
`static SubLObject`	`mt_final_index_spec(SubLObject mt)` Makes the single final-index-spec for MT.
`static SubLObject`	`mt_index_assertion_match_p(SubLObject assertion, SubLObject mt)`
`static SubLObject`	`nart_arg_final_index_spec_iterator_doneP(SubLObject state)`
`static SubLObject`	`nart_arg_final_index_spec_iterator_state_argnum_keys(SubLObject state)` The remaining argnums to iterate over
`static SubLObject`	`nart_arg_final_index_spec_iterator_state_function_keys(SubLObject state)` The remaining functions left to iterate over
`static SubLObject`	`nart_arg_final_index_spec_iterator_state_note(SubLObject state)` A note containing information about the state of the keys, used to control code flow
`static SubLObject`	`new_assertion_simple_final_index_spec(SubLObject v_term, SubLObject assertion_func)` Returns a 'simple final index spec' -- a constraint object used to filter assertions.
`static SubLObject`	`new_decontextualized_ist_predicate_rule_final_index_spec_iterator(SubLObject predicate, SubLObject sense, SubLObject direction)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`new_exception_rule_final_index_spec_iterator(SubLObject rule, SubLObject direction)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`new_final_index_iterator(SubLObject final_index_spec, SubLObject type, SubLObject truth, SubLObject direction)` If FINAL-INDEX-SPEC is simple, then get the syntactically filtered list from the other side, then wrap it with a filter iterator to do the semantic filtering on this side.
`static SubLObject`	`new_function_rule_final_index_spec_iterator(SubLObject function, SubLObject direction)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`new_gaf_arg_final_index_spec_iterator(SubLObject v_term, SubLObject argnum, SubLObject predicate)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`new_gaf_simple_final_index_spec(SubLObject v_term, SubLObject argnum_spec, SubLObject predicate_spec, SubLObject mt_spec)` Returns a 'gaf simple final index spec' -- a constraint object used to filter gafs.
`static SubLObject`	`new_genl_mt_rule_final_index_spec_iterator(SubLObject genl_mt, SubLObject sense, SubLObject direction)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`new_genls_rule_final_index_spec_iterator(SubLObject collection, SubLObject sense, SubLObject direction)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`new_isa_rule_final_index_spec_iterator(SubLObject collection, SubLObject sense, SubLObject direction)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`new_nart_arg_final_index_spec_iterator(SubLObject v_term, SubLObject argnum, SubLObject function)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`new_nart_simple_final_index_spec(SubLObject v_term, SubLObject argnum_spec, SubLObject functor_spec)` Returns a 'nart simple final index spec' -- a constraint object used to filter narts.
`static SubLObject`	`new_pragma_rule_final_index_spec_iterator(SubLObject rule, SubLObject direction)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`new_predicate_extent_final_index_spec_iterator(SubLObject predicate)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`new_predicate_rule_final_index_spec_iterator(SubLObject predicate, SubLObject sense, SubLObject direction)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`new_quoted_isa_rule_final_index_spec_iterator(SubLObject collection, SubLObject sense, SubLObject direction)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`new_rule_simple_final_index_spec(SubLObject v_term, SubLObject sense_spec, SubLObject asent_func)` Returns a 'rule simple final index spec' -- a constraint object used to filter rules.
`static SubLObject`	`new_term_final_index_spec_iterator(SubLObject v_term, SubLObject type)` Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e.
`static SubLObject`	`other_complex_final_index_spec_p(SubLObject object)`
`static SubLObject`	`other_final_index_spec_p(SubLObject final_index_spec)` The other index is the only one that needs to do post-hoc semantic filtering.
`static SubLObject`	`other_final_index_spec(SubLObject v_term)` Makes the single final-index-spec for TERM.
`static SubLObject`	`other_index_assertion_match_p(SubLObject assertion, SubLObject v_term)`
`static SubLObject`	`other_simple_final_index_spec_p(SubLObject object)`
`static SubLObject`	`pragma_rule_index_asent_match_p(SubLObject asent, SubLObject rule)`
`static SubLObject`	`pragma_rule_index_asent_p(SubLObject asent)`
`static SubLObject`	`pred_arg2_rule_current_relevant_keylist(SubLObject state)` If STATE's current keylist is valid and relevant, returns it.
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_doneP(SubLObject state)`
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_next_direction_key(SubLObject state)`
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_next(SubLObject state)`
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_quiesce_one_step(SubLObject state)` STATE is assumed to be invalid or irrelevant.
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_quiesce(SubLObject state)` Iterates over the keys in STATE until it ends up with its current keylist (@see pred-arg2-rule-current-keylist) being valid and relevant, with validity and relevance being determined by @xref pred-arg2-rule-current-relevant-keylist.
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_refill_direction_keys(SubLObject state)` refill the direction-keys by popping an mt but don't actually pop the mt if it's fresh, just note that it's unfresh now
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_refill_mt_keys(SubLObject state)` refill the mt-keys by popping a sense but don't actually pop the sense if it's fresh, just note that it's unfresh now
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_state_arg2(SubLObject state)` The input arg2
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_state_direction_keys(SubLObject state)` The remaining directions left to iterate over
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_state_direction(SubLObject state)` The input direction
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_state_mt_keys(SubLObject state)` The remaining mts left to iterate over
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_state_note(SubLObject state)` A note containing information about the state of the keys, used to control code flow
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_state_pred(SubLObject state)` The input pred
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_state_sense_keys(SubLObject state)` The remaining senses to iterate over
`static SubLObject`	`pred_arg2_rule_final_index_spec_iterator_state_top_level_key(SubLObject state)` The top-level key to the final index, used for subclassing
`static SubLObject`	`pred_arg2_rule_keylist_to_final_index_spec(SubLObject pred, SubLObject top_level_key, SubLObject keylist)`
`static SubLObject`	`predicate_extent_current_relevant_keylist(SubLObject state)` If STATE's current keylist is valid and relevant, returns it.
`static SubLObject`	`predicate_extent_final_index_spec_iterator_doneP(SubLObject state)`
`static SubLObject`	`predicate_extent_final_index_spec_iterator_next_mt_key(SubLObject state)`
`static SubLObject`	`predicate_extent_final_index_spec_iterator_next(SubLObject state)`
`static SubLObject`	`predicate_extent_final_index_spec_iterator_quiesce(SubLObject state)` Iterates over the keys in STATE until it ends up with its current keylist (@see predicate-extent-current-keylist) being valid and relevant, with validity and relevance being determined by @xref predicate-extent-current-relevant-keylist.
`static SubLObject`	`predicate_extent_final_index_spec_iterator_state_mt_keys(SubLObject state)` The remaining mts left to iterate over
`static SubLObject`	`predicate_extent_final_index_spec_iterator_state_predicate(SubLObject state)` The input predicate
`static SubLObject`	`predicate_extent_keylist_to_final_index_spec(SubLObject v_term, SubLObject keylist)`
`static SubLObject`	`predicate_rule_current_relevant_keylist(SubLObject state)` If STATE's current keylist is valid and relevant, returns it.
`static SubLObject`	`predicate_rule_final_index_spec_iterator_doneP(SubLObject state)`
`static SubLObject`	`predicate_rule_final_index_spec_iterator_next_direction_key(SubLObject state)`
`static SubLObject`	`predicate_rule_final_index_spec_iterator_next(SubLObject state)`
`static SubLObject`	`predicate_rule_final_index_spec_iterator_quiesce_one_step(SubLObject state)` STATE is assumed to be invalid or irrelevant.
`static SubLObject`	`predicate_rule_final_index_spec_iterator_quiesce(SubLObject state)` Iterates over the keys in STATE until it ends up with its current keylist (@see predicate-rule-current-keylist) being valid and relevant, with validity and relevance being determined by @xref predicate-rule-current-relevant-keylist.
`static SubLObject`	`predicate_rule_final_index_spec_iterator_refill_direction_keys(SubLObject state)` refill the direction-keys by popping an mt but don't actually pop the mt if it's fresh, just note that it's unfresh now
`static SubLObject`	`predicate_rule_final_index_spec_iterator_refill_mt_keys(SubLObject state)` refill the mt-keys by popping a sense but don't actually pop the sense if it's fresh, just note that it's unfresh now
`static SubLObject`	`predicate_rule_final_index_spec_iterator_state_direction_keys(SubLObject state)` The remaining directions left to iterate over
`static SubLObject`	`predicate_rule_final_index_spec_iterator_state_direction(SubLObject state)` The input direction
`static SubLObject`	`predicate_rule_final_index_spec_iterator_state_mt_keys(SubLObject state)` The remaining mts left to iterate over
`static SubLObject`	`predicate_rule_final_index_spec_iterator_state_note(SubLObject state)` A note containing information about the state of the keys, used to control code flow
`static SubLObject`	`predicate_rule_final_index_spec_iterator_state_predicate(SubLObject state)` The input predicate
`static SubLObject`	`predicate_rule_final_index_spec_iterator_state_sense_keys(SubLObject state)` The remaining senses to iterate over
`static SubLObject`	`predicate_rule_index_asent_match_p(SubLObject asent, SubLObject predicate)`
`static SubLObject`	`predicate_rule_index_asent_p(SubLObject asent)`
`static SubLObject`	`predicate_rule_keylist_to_final_index_spec(SubLObject pred, SubLObject keylist)`
`static SubLObject`	`rule_syntactically_matches_simple_rule_final_index_spec_intP(SubLObject rule, SubLObject sense, SubLObject v_term, SubLObject asent_func)`
`static SubLObject`	`rule_syntactically_matches_simple_rule_final_index_specP(SubLObject rule, SubLObject v_term, SubLObject rule_final_index_spec)`
`void`	`runTopLevelForms()` Runs all top-level forms in order.
`static SubLObject`	`set_decontextualized_ist_predicate_rule_final_index_spec_iterator_state_direction_keys(SubLObject state, SubLObject new_keys)`
`static SubLObject`	`set_decontextualized_ist_predicate_rule_final_index_spec_iterator_state_note(SubLObject state, SubLObject note)`
`static SubLObject`	`set_gaf_arg_final_index_spec_iterator_state_argnum_keys(SubLObject state, SubLObject new_keys)`
`static SubLObject`	`set_gaf_arg_final_index_spec_iterator_state_mt_keys(SubLObject state, SubLObject new_keys)`
`static SubLObject`	`set_gaf_arg_final_index_spec_iterator_state_note(SubLObject state, SubLObject note)`
`static SubLObject`	`set_gaf_arg_final_index_spec_iterator_state_predicate_keys(SubLObject state, SubLObject new_keys)`
`static SubLObject`	`set_pred_arg2_rule_final_index_spec_iterator_state_direction_keys(SubLObject state, SubLObject new_keys)`
`static SubLObject`	`set_pred_arg2_rule_final_index_spec_iterator_state_mt_keys(SubLObject state, SubLObject new_keys)`
`static SubLObject`	`set_pred_arg2_rule_final_index_spec_iterator_state_note(SubLObject state, SubLObject note)`
`static SubLObject`	`set_pred_arg2_rule_final_index_spec_iterator_state_sense_keys(SubLObject state, SubLObject new_keys)`
`static SubLObject`	`set_predicate_extent_final_index_spec_iterator_state_mt_keys(SubLObject state, SubLObject new_keys)`
`static SubLObject`	`set_predicate_rule_final_index_spec_iterator_state_direction_keys(SubLObject state, SubLObject new_keys)`
`static SubLObject`	`set_predicate_rule_final_index_spec_iterator_state_mt_keys(SubLObject state, SubLObject new_keys)`
`static SubLObject`	`set_predicate_rule_final_index_spec_iterator_state_note(SubLObject state, SubLObject note)`
`static SubLObject`	`set_predicate_rule_final_index_spec_iterator_state_sense_keys(SubLObject state, SubLObject new_keys)`
`static SubLObject`	`setup_kb_mapping_macros_file()`
`static SubLObject`	`simple_final_index_spec_p(SubLObject final_index_spec)`
`static SubLObject`	`simple_final_index_spec_term(SubLObject final_index_spec)`
`static SubLObject`	`simple_term_assertion_list_filtered_internal(SubLObject simple_final_index_spec, SubLObject type, SubLObject truth, SubLObject direction)`
`static SubLObject`	`simple_term_assertion_list_filtered(SubLObject simple_final_index_spec, SubLObject type, SubLObject truth, SubLObject direction)`

Methods inherited from class com.cyc.tool.subl.util.SubLTranslatedFile
`extractFunctionNamed`

Methods inherited from class com.cyc.tool.subl.util.SubLTrampolineFile
`checkType, enforceType, extractBinaryFunc, extractCount, extractEnd, extractEndUsingSize, extractPackage, extractStart, extractUnaryFunc, main`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

me

public static final SubLFile me

myName

public static final java.lang.String myName

See Also:: Constant Field Values

$list0

public static final SubLList $list0

$sym1$PWHEN

public static final SubLSymbol $sym1$PWHEN

$sym2$RELEVANT_PRED_

public static final SubLSymbol $sym2$RELEVANT_PRED_

$list3

public static final SubLList $list3

$sym4$RELEVANT_MT_

public static final SubLSymbol $sym4$RELEVANT_MT_

$list5

public static final SubLList $list5

$sym6$PROGN

public static final SubLSymbol $sym6$PROGN

$sym7$TRUTH_RELEVANT_P

public static final SubLSymbol $sym7$TRUTH_RELEVANT_P

$sym8$PWHEN_TRUTH_RELEVANT

public static final SubLSymbol $sym8$PWHEN_TRUTH_RELEVANT

$list9

public static final SubLList $list9

$sym10$ASSERTION_HAS_TRUTH

public static final SubLSymbol $sym10$ASSERTION_HAS_TRUTH

$sym11$COR

public static final SubLSymbol $sym11$COR

$sym12$NULL

public static final SubLSymbol $sym12$NULL

$list13

public static final SubLList $list13

$sym14$ASSERTION_HAS_DIRECTION_SPEC

public static final SubLSymbol $sym14$ASSERTION_HAS_DIRECTION_SPEC

$list15

public static final SubLList $list15

$list16

public static final SubLList $list16

$kw17$ALLOW_OTHER_KEYS

public static final SubLSymbol $kw17$ALLOW_OTHER_KEYS

$kw18$TRUTH

public static final SubLSymbol $kw18$TRUTH

$kw19$DIRECTION

public static final SubLSymbol $kw19$DIRECTION

$kw20$DONE

public static final SubLSymbol $kw20$DONE

$sym21$DO_LIST

public static final SubLSymbol $sym21$DO_LIST

$sym22$PWHEN_ASSERTION_HAS_TRUTH

public static final SubLSymbol $sym22$PWHEN_ASSERTION_HAS_TRUTH

$sym23$PWHEN_ASSERTION_HAS_DIRECTION_SPEC

public static final SubLSymbol $sym23$PWHEN_ASSERTION_HAS_DIRECTION_SPEC

$list24

public static final SubLList $list24

$sym25$DO_ASSERTION_LIST

public static final SubLSymbol $sym25$DO_ASSERTION_LIST

$sym26$DO_SIMPLE_INDEX_TERM_ASSERTION_LIST

public static final SubLSymbol $sym26$DO_SIMPLE_INDEX_TERM_ASSERTION_LIST

$list27

public static final SubLList $list27

$kw28$GAF

public static final SubLSymbol $kw28$GAF

$sym29$GAF_ASSERTION_

public static final SubLSymbol $sym29$GAF_ASSERTION_

$kw30$RULE

public static final SubLSymbol $kw30$RULE

$sym31$RULE_ASSERTION_

public static final SubLSymbol $sym31$RULE_ASSERTION_

$sym32$ASSERTION_HAS_TYPE

public static final SubLSymbol $sym32$ASSERTION_HAS_TYPE

$list33

public static final SubLList $list33

$list34

public static final SubLList $list34

$kw35$PROGRESS_MESSAGE

public static final SubLSymbol $kw35$PROGRESS_MESSAGE

$sym36$UNTIL_MAPPING_FINISHED

public static final SubLSymbol $sym36$UNTIL_MAPPING_FINISHED

$sym37$SOME_ASSERTIONS_INTERNAL

public static final SubLSymbol $sym37$SOME_ASSERTIONS_INTERNAL

$list38

public static final SubLList $list38

$sym39$SOME_ASSERTIONS

public static final SubLSymbol $sym39$SOME_ASSERTIONS

$list40

public static final SubLList $list40

$list41

public static final SubLList $list41

$sym42$DO_ASSERTIONS

public static final SubLSymbol $sym42$DO_ASSERTIONS

$sym43$DO_FINAL_INDEX_FROM_SPEC

public static final SubLSymbol $sym43$DO_FINAL_INDEX_FROM_SPEC

$list44

public static final SubLList $list44

$list45

public static final SubLList $list45

$sym46$FINAL_INDEX_ITERATOR

public static final SubLSymbol $sym46$FINAL_INDEX_ITERATOR

$sym47$CLET

public static final SubLSymbol $sym47$CLET

$sym48$CUNWIND_PROTECT

public static final SubLSymbol $sym48$CUNWIND_PROTECT

$sym49$CSETQ

public static final SubLSymbol $sym49$CSETQ

$sym50$NEW_FINAL_INDEX_ITERATOR

public static final SubLSymbol $sym50$NEW_FINAL_INDEX_ITERATOR

$sym51$DO_ITERATOR_WITHOUT_VALUES_INTERNAL

public static final SubLSymbol $sym51$DO_ITERATOR_WITHOUT_VALUES_INTERNAL

$sym52$DESTROY_FINAL_INDEX_ITERATOR

public static final SubLSymbol $sym52$DESTROY_FINAL_INDEX_ITERATOR

$list53

public static final SubLList $list53

$list54

public static final SubLList $list54

$kw55$INDEX

public static final SubLSymbol $kw55$INDEX

$kw56$PREDICATE

public static final SubLSymbol $kw56$PREDICATE

$sym57$PRED_VAR

public static final SubLSymbol $sym57$PRED_VAR

$sym58$FINAL_INDEX_SPEC

public static final SubLSymbol $sym58$FINAL_INDEX_SPEC

$sym59$DO_GAF_ARG_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym59$DO_GAF_ARG_INDEX_KEY_VALIDATOR

$sym60$NEW_GAF_ARG_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym60$NEW_GAF_ARG_FINAL_INDEX_SPEC_ITERATOR

$sym61$DO_GAF_ARG_INDEX

public static final SubLSymbol $sym61$DO_GAF_ARG_INDEX

$str62$Iterate_over_an_index_of_gaf_asse

public static final SubLString $str62$Iterate_over_an_index_of_gaf_asse

$list63

public static final SubLList $list63

$sym64$ASSERTION

public static final SubLSymbol $sym64$ASSERTION

$sym65$GAF_ARG

public static final SubLSymbol $sym65$GAF_ARG

$kw66$ANY

public static final SubLSymbol $kw66$ANY

$sym67$GAF_ARG_FINAL_INDEX_SPEC_ITERATOR_DONE_

public static final SubLSymbol $sym67$GAF_ARG_FINAL_INDEX_SPEC_ITERATOR_DONE_

$sym68$GAF_ARG_FINAL_INDEX_SPEC_ITERATOR_NEXT

public static final SubLSymbol $sym68$GAF_ARG_FINAL_INDEX_SPEC_ITERATOR_NEXT

$kw69$ARGNUM_KEYS_ARE_FRESH

public static final SubLSymbol $kw69$ARGNUM_KEYS_ARE_FRESH

$kw70$GAF_ARG

public static final SubLSymbol $kw70$GAF_ARG

$kw71$PREDICATE_KEYS_ARE_FRESH

public static final SubLSymbol $kw71$PREDICATE_KEYS_ARE_FRESH

$list72

public static final SubLList $list72

$sym73$PRED_VAR

public static final SubLSymbol $sym73$PRED_VAR

$sym74$FINAL_INDEX_SPEC

public static final SubLSymbol $sym74$FINAL_INDEX_SPEC

$sym75$DO_PREDICATE_EXTENT_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym75$DO_PREDICATE_EXTENT_INDEX_KEY_VALIDATOR

$sym76$NEW_PREDICATE_EXTENT_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym76$NEW_PREDICATE_EXTENT_FINAL_INDEX_SPEC_ITERATOR

$sym77$DO_PREDICATE_EXTENT_INDEX

public static final SubLSymbol $sym77$DO_PREDICATE_EXTENT_INDEX

$sym78$PREDICATE_EXTENT_FINAL_INDEX_SPEC_ITERATOR_DONE_

public static final SubLSymbol $sym78$PREDICATE_EXTENT_FINAL_INDEX_SPEC_ITERATOR_DONE_

$sym79$PREDICATE_EXTENT_FINAL_INDEX_SPEC_ITERATOR_NEXT

public static final SubLSymbol $sym79$PREDICATE_EXTENT_FINAL_INDEX_SPEC_ITERATOR_NEXT

$kw80$PREDICATE_EXTENT

public static final SubLSymbol $kw80$PREDICATE_EXTENT

$list81

public static final SubLList $list81

$list82

public static final SubLList $list82

$kw83$FUNCTION

public static final SubLSymbol $kw83$FUNCTION

$sym84$FINAL_INDEX_SPEC

public static final SubLSymbol $sym84$FINAL_INDEX_SPEC

$sym85$DO_NART_ARG_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym85$DO_NART_ARG_INDEX_KEY_VALIDATOR

$sym86$NEW_NART_ARG_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym86$NEW_NART_ARG_FINAL_INDEX_SPEC_ITERATOR

$sym87$DO_NART_ARG_INDEX

public static final SubLSymbol $sym87$DO_NART_ARG_INDEX

$sym88$NART_ARG_FINAL_INDEX_SPEC_ITERATOR_DONE_

public static final SubLSymbol $sym88$NART_ARG_FINAL_INDEX_SPEC_ITERATOR_DONE_

$sym89$NART_ARG_FINAL_INDEX_SPEC_ITERATOR_NEXT

public static final SubLSymbol $sym89$NART_ARG_FINAL_INDEX_SPEC_ITERATOR_NEXT

$kw90$NART_ARG

public static final SubLSymbol $kw90$NART_ARG

$str91$nart_arg_keys_should_never_be_irr

public static final SubLString $str91$nart_arg_keys_should_never_be_irr

$kw92$FUNCTION_KEYS_ARE_FRESH

public static final SubLSymbol $kw92$FUNCTION_KEYS_ARE_FRESH

$list93

public static final SubLList $list93

$sym94$FINAL_INDEX_SPEC

public static final SubLSymbol $sym94$FINAL_INDEX_SPEC

$sym95$DO_FUNCTION_EXTENT_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym95$DO_FUNCTION_EXTENT_INDEX_KEY_VALIDATOR

$sym96$FUNCTION_EXTENT_FINAL_INDEX_SPEC

public static final SubLSymbol $sym96$FUNCTION_EXTENT_FINAL_INDEX_SPEC

$sym97$DO_FUNCTION_EXTENT_INDEX

public static final SubLSymbol $sym97$DO_FUNCTION_EXTENT_INDEX

$list98

public static final SubLList $list98

$list99

public static final SubLList $list99

$sym100$TOU

public static final SubLSymbol $sym100$TOU

$sym101$GAF_ARG1

public static final SubLSymbol $sym101$GAF_ARG1

$list102

public static final SubLList $list102

$const103$termOfUnit

public static final SubLObject $const103$termOfUnit

$list104

public static final SubLList $list104

$list105

public static final SubLList $list105

$list106

public static final SubLList $list106

$sym107$DO_PREDICATE_RULE_INDEX

public static final SubLSymbol $sym107$DO_PREDICATE_RULE_INDEX

$kw108$SENSE

public static final SubLSymbol $kw108$SENSE

$kw109$POS

public static final SubLSymbol $kw109$POS

$kw110$NEG

public static final SubLSymbol $kw110$NEG

$list111

public static final SubLList $list111

$list112

public static final SubLList $list112

$sym113$FINAL_INDEX_SPEC

public static final SubLSymbol $sym113$FINAL_INDEX_SPEC

$sym114$DO_PREDICATE_RULE_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym114$DO_PREDICATE_RULE_INDEX_KEY_VALIDATOR

$sym115$NEW_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym115$NEW_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR

$sym116$PREDICATE_RULE_INDEX_ASENT_MATCH_P

public static final SubLSymbol $sym116$PREDICATE_RULE_INDEX_ASENT_MATCH_P

$sym117$PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_

public static final SubLSymbol $sym117$PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_

$sym118$PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT

public static final SubLSymbol $sym118$PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT

$kw119$SENSE_KEYS_ARE_FRESH

public static final SubLSymbol $kw119$SENSE_KEYS_ARE_FRESH

$kw120$PREDICATE_RULE

public static final SubLSymbol $kw120$PREDICATE_RULE

$str121$predicate_rule_iterator_quiescens

public static final SubLString $str121$predicate_rule_iterator_quiescens

$kw122$MT_KEYS_ARE_FRESH

public static final SubLSymbol $kw122$MT_KEYS_ARE_FRESH

$sym123$FINAL_INDEX_SPEC

public static final SubLSymbol $sym123$FINAL_INDEX_SPEC

$sym124$DO_DECONTEXTUALIZED_IST_PREDICATE_RULE_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym124$DO_DECONTEXTUALIZED_IST_PREDICATE_RULE_INDEX_KEY_VALIDATOR

$sym125$NEW_DECONTEXTUALIZED_IST_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym125$NEW_DECONTEXTUALIZED_IST_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR

$sym126$DO_DECONTEXTUALIZED_IST_PREDICATE_RULE_INDEX

public static final SubLSymbol $sym126$DO_DECONTEXTUALIZED_IST_PREDICATE_RULE_INDEX

$sym127$DECONTEXTUALIZED_IST_PREDICATE_RULE_INDEX_ASENT_MATCH_P

public static final SubLSymbol $sym127$DECONTEXTUALIZED_IST_PREDICATE_RULE_INDEX_ASENT_MATCH_P

$sym128$DECONTEXTUALIZED_IST_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_DON

public static final SubLSymbol $sym128$DECONTEXTUALIZED_IST_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_DON

$sym129$DECONTEXTUALIZED_IST_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_NEX

public static final SubLSymbol $sym129$DECONTEXTUALIZED_IST_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_NEX

$kw130$DECONTEXTUALIZED_IST_PREDICATE_RULE

public static final SubLSymbol $kw130$DECONTEXTUALIZED_IST_PREDICATE_RULE

$str131$ist_predicate_rule_iterator_quies

public static final SubLString $str131$ist_predicate_rule_iterator_quies

$list132

public static final SubLList $list132

$sym133$FINAL_INDEX_SPEC

public static final SubLSymbol $sym133$FINAL_INDEX_SPEC

$sym134$DO_ISA_RULE_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym134$DO_ISA_RULE_INDEX_KEY_VALIDATOR

$sym135$NEW_ISA_RULE_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym135$NEW_ISA_RULE_FINAL_INDEX_SPEC_ITERATOR

$sym136$DO_ISA_RULE_INDEX

public static final SubLSymbol $sym136$DO_ISA_RULE_INDEX

$sym137$ISA_RULE_INDEX_ASENT_MATCH_P

public static final SubLSymbol $sym137$ISA_RULE_INDEX_ASENT_MATCH_P

$const138$isa

public static final SubLObject $const138$isa

$kw139$ISA_RULE

public static final SubLSymbol $kw139$ISA_RULE

$sym140$PRED_ARG2_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_

public static final SubLSymbol $sym140$PRED_ARG2_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_

$sym141$PRED_ARG2_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT

public static final SubLSymbol $sym141$PRED_ARG2_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT

$sym142$FINAL_INDEX_SPEC

public static final SubLSymbol $sym142$FINAL_INDEX_SPEC

$sym143$DO_QUOTED_ISA_RULE_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym143$DO_QUOTED_ISA_RULE_INDEX_KEY_VALIDATOR

$sym144$NEW_QUOTED_ISA_RULE_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym144$NEW_QUOTED_ISA_RULE_FINAL_INDEX_SPEC_ITERATOR

$sym145$DO_QUOTED_ISA_RULE_INDEX

public static final SubLSymbol $sym145$DO_QUOTED_ISA_RULE_INDEX

$sym146$QUOTED_ISA_RULE_INDEX_ASENT_MATCH_P

public static final SubLSymbol $sym146$QUOTED_ISA_RULE_INDEX_ASENT_MATCH_P

$const147$quotedIsa

public static final SubLObject $const147$quotedIsa

$kw148$QUOTED_ISA_RULE

public static final SubLSymbol $kw148$QUOTED_ISA_RULE

$sym149$FINAL_INDEX_SPEC

public static final SubLSymbol $sym149$FINAL_INDEX_SPEC

$sym150$DO_GENLS_RULE_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym150$DO_GENLS_RULE_INDEX_KEY_VALIDATOR

$sym151$NEW_GENLS_RULE_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym151$NEW_GENLS_RULE_FINAL_INDEX_SPEC_ITERATOR

$sym152$DO_GENLS_RULE_INDEX

public static final SubLSymbol $sym152$DO_GENLS_RULE_INDEX

$sym153$GENLS_RULE_INDEX_ASENT_MATCH_P

public static final SubLSymbol $sym153$GENLS_RULE_INDEX_ASENT_MATCH_P

$const154$genls

public static final SubLObject $const154$genls

$kw155$GENLS_RULE

public static final SubLSymbol $kw155$GENLS_RULE

$list156

public static final SubLList $list156

$sym157$FINAL_INDEX_SPEC

public static final SubLSymbol $sym157$FINAL_INDEX_SPEC

$sym158$DO_GENL_MT_RULE_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym158$DO_GENL_MT_RULE_INDEX_KEY_VALIDATOR

$sym159$NEW_GENL_MT_RULE_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym159$NEW_GENL_MT_RULE_FINAL_INDEX_SPEC_ITERATOR

$sym160$DO_GENL_MT_RULE_INDEX

public static final SubLSymbol $sym160$DO_GENL_MT_RULE_INDEX

$sym161$GENL_MT_RULE_INDEX_ASENT_MATCH_P

public static final SubLSymbol $sym161$GENL_MT_RULE_INDEX_ASENT_MATCH_P

$const162$genlMt

public static final SubLObject $const162$genlMt

$kw163$GENL_MT_RULE

public static final SubLSymbol $kw163$GENL_MT_RULE

$str164$pred_arg2_rule_iterator_quiescens

public static final SubLString $str164$pred_arg2_rule_iterator_quiescens

$str165$unexpected_pred_in_pred_arg2_inde

public static final SubLString $str165$unexpected_pred_in_pred_arg2_inde

$list166

public static final SubLList $list166

$sym167$FINAL_INDEX_SPEC

public static final SubLSymbol $sym167$FINAL_INDEX_SPEC

$sym168$DO_FUNCTION_RULE_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym168$DO_FUNCTION_RULE_INDEX_KEY_VALIDATOR

$sym169$NEW_FUNCTION_RULE_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym169$NEW_FUNCTION_RULE_FINAL_INDEX_SPEC_ITERATOR

$sym170$DO_FUNCTION_RULE_INDEX

public static final SubLSymbol $sym170$DO_FUNCTION_RULE_INDEX

$sym171$FUNCTION_RULE_INDEX_ASENT_MATCH_P

public static final SubLSymbol $sym171$FUNCTION_RULE_INDEX_ASENT_MATCH_P

$sym172$FUNCTION_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_

public static final SubLSymbol $sym172$FUNCTION_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_

$sym173$FUNCTION_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT

public static final SubLSymbol $sym173$FUNCTION_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT

$kw174$FUNCTION_RULE

public static final SubLSymbol $kw174$FUNCTION_RULE

$str175$function_rule_iterator_quiescense

public static final SubLString $str175$function_rule_iterator_quiescense

$list176

public static final SubLList $list176

$sym177$FINAL_INDEX_SPEC

public static final SubLSymbol $sym177$FINAL_INDEX_SPEC

$sym178$DO_EXCEPTION_RULE_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym178$DO_EXCEPTION_RULE_INDEX_KEY_VALIDATOR

$sym179$NEW_EXCEPTION_RULE_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym179$NEW_EXCEPTION_RULE_FINAL_INDEX_SPEC_ITERATOR

$sym180$DO_EXCEPTION_RULE_INDEX

public static final SubLSymbol $sym180$DO_EXCEPTION_RULE_INDEX

$sym181$EXCEPTION_RULE_INDEX_ASENT_MATCH_P

public static final SubLSymbol $sym181$EXCEPTION_RULE_INDEX_ASENT_MATCH_P

$sym182$EXCEPTION_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_

public static final SubLSymbol $sym182$EXCEPTION_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_

$sym183$EXCEPTION_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT

public static final SubLSymbol $sym183$EXCEPTION_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT

$kw184$EXCEPTION_RULE

public static final SubLSymbol $kw184$EXCEPTION_RULE

$str185$exception_rule_iterator_quiescens

public static final SubLString $str185$exception_rule_iterator_quiescens

$sym186$FINAL_INDEX_SPEC

public static final SubLSymbol $sym186$FINAL_INDEX_SPEC

$sym187$DO_PRAGMA_RULE_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym187$DO_PRAGMA_RULE_INDEX_KEY_VALIDATOR

$sym188$NEW_PRAGMA_RULE_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym188$NEW_PRAGMA_RULE_FINAL_INDEX_SPEC_ITERATOR

$sym189$DO_PRAGMA_RULE_INDEX

public static final SubLSymbol $sym189$DO_PRAGMA_RULE_INDEX

$sym190$PRAGMA_RULE_INDEX_ASENT_MATCH_P

public static final SubLSymbol $sym190$PRAGMA_RULE_INDEX_ASENT_MATCH_P

$sym191$PRAGMA_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_

public static final SubLSymbol $sym191$PRAGMA_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_

$sym192$PRAGMA_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT

public static final SubLSymbol $sym192$PRAGMA_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT

$kw193$PRAGMA_RULE

public static final SubLSymbol $kw193$PRAGMA_RULE

$str194$pragma_rule_iterator_quiescense_f

public static final SubLString $str194$pragma_rule_iterator_quiescense_f

$list195

public static final SubLList $list195

$sym196$FINAL_INDEX_SPEC

public static final SubLSymbol $sym196$FINAL_INDEX_SPEC

$sym197$DO_UNBOUND_PREDICATE_RULE_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym197$DO_UNBOUND_PREDICATE_RULE_INDEX_KEY_VALIDATOR

$sym198$NEW_UNBOUND_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym198$NEW_UNBOUND_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR

$sym199$DO_UNBOUND_PREDICATE_RULE_INDEX

public static final SubLSymbol $sym199$DO_UNBOUND_PREDICATE_RULE_INDEX

$sym200$UNBOUND_PREDICATE_RULE_INDEX_ASENT_MATCH_P

public static final SubLSymbol $sym200$UNBOUND_PREDICATE_RULE_INDEX_ASENT_MATCH_P

$sym201$UNBOUND_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_

public static final SubLSymbol $sym201$UNBOUND_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_DONE_

$sym202$UNBOUND_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT

public static final SubLSymbol $sym202$UNBOUND_PREDICATE_RULE_FINAL_INDEX_SPEC_ITERATOR_NEXT

$str203$unbound_predicate_rule_iterator_q

public static final SubLString $str203$unbound_predicate_rule_iterator_q

$list204

public static final SubLList $list204

$list205

public static final SubLList $list205

$kw206$TYPE

public static final SubLSymbol $kw206$TYPE

$sym207$FINAL_INDEX_SPEC

public static final SubLSymbol $sym207$FINAL_INDEX_SPEC

$sym208$DO_MT_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym208$DO_MT_INDEX_KEY_VALIDATOR

$sym209$MT_FINAL_INDEX_SPEC

public static final SubLSymbol $sym209$MT_FINAL_INDEX_SPEC

$sym210$DO_MT_INDEX

public static final SubLSymbol $sym210$DO_MT_INDEX

$sym211$MT_INDEX_ASSERTION_MATCH_P

public static final SubLSymbol $sym211$MT_INDEX_ASSERTION_MATCH_P

$list212

public static final SubLList $list212

$list213

public static final SubLList $list213

$sym214$FINAL_INDEX_SPEC

public static final SubLSymbol $sym214$FINAL_INDEX_SPEC

$sym215$DO_OTHER_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym215$DO_OTHER_INDEX_KEY_VALIDATOR

$sym216$OTHER_FINAL_INDEX_SPEC

public static final SubLSymbol $sym216$OTHER_FINAL_INDEX_SPEC

$sym217$DO_OTHER_INDEX_ASSERTION_MATCH_P

public static final SubLSymbol $sym217$DO_OTHER_INDEX_ASSERTION_MATCH_P

$sym218$DO_OTHER_INDEX

public static final SubLSymbol $sym218$DO_OTHER_INDEX

$sym219$OTHER_INDEX_ASSERTION_MATCH_P

public static final SubLSymbol $sym219$OTHER_INDEX_ASSERTION_MATCH_P

$list220

public static final SubLList $list220

$sym221$OTHER_FINAL_INDEX_SPEC_P

public static final SubLSymbol $sym221$OTHER_FINAL_INDEX_SPEC_P

$sym222$DO_TERM_INDEX

public static final SubLSymbol $sym222$DO_TERM_INDEX

$kw223$SIMPLE

public static final SubLSymbol $kw223$SIMPLE

$kw224$OTHER

public static final SubLSymbol $kw224$OTHER

$sym225$FINAL_INDEX_SPEC

public static final SubLSymbol $sym225$FINAL_INDEX_SPEC

$sym226$DO_TERM_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym226$DO_TERM_INDEX_KEY_VALIDATOR

$sym227$NEW_TERM_FINAL_INDEX_SPEC_ITERATOR

public static final SubLSymbol $sym227$NEW_TERM_FINAL_INDEX_SPEC_ITERATOR

$sym228$DO_TERM_INDEX_ASSERTION_MATCH_P

public static final SubLSymbol $sym228$DO_TERM_INDEX_ASSERTION_MATCH_P

$str229$Iterate_over_all_assertions_index

public static final SubLString $str229$Iterate_over_all_assertions_index

$list230

public static final SubLList $list230

$list231

public static final SubLList $list231

$sym232$DO_BROAD_MT_INDEX_KEY_VALIDATOR

public static final SubLSymbol $sym232$DO_BROAD_MT_INDEX_KEY_VALIDATOR

$str233$do_broad_mt_index

public static final SubLString $str233$do_broad_mt_index

$sym234$DO_BROAD_MT_INDEX_MATCH_P

public static final SubLSymbol $sym234$DO_BROAD_MT_INDEX_MATCH_P

$sym235$DO_BROAD_MT_INDEX

public static final SubLSymbol $sym235$DO_BROAD_MT_INDEX

$sym236$PCASE

public static final SubLSymbol $sym236$PCASE

$sym237$DO_MT_CONTENTS_METHOD

public static final SubLSymbol $sym237$DO_MT_CONTENTS_METHOD

$kw238$MT

public static final SubLSymbol $kw238$MT

$kw239$BROAD_MT

public static final SubLSymbol $kw239$BROAD_MT

$list240

public static final SubLList $list240

$sym241$DO_MT_CONTENTS

public static final SubLSymbol $sym241$DO_MT_CONTENTS

$sym242$HLMT_P

public static final SubLSymbol $sym242$HLMT_P

$list243

public static final SubLList $list243

$list244

public static final SubLList $list244

$sym245$GATHER_OVERLAP_INDEX

public static final SubLSymbol $sym245$GATHER_OVERLAP_INDEX

$list246

public static final SubLList $list246

$list247

public static final SubLList $list247

$kw248$METHODS

public static final SubLSymbol $kw248$METHODS

$sym249$DO_GAF_LOOKUP_INDEX

public static final SubLSymbol $sym249$DO_GAF_LOOKUP_INDEX

$sym250$BEST_GAF_LOOKUP_INDEX

public static final SubLSymbol $sym250$BEST_GAF_LOOKUP_INDEX

$list251

public static final SubLList $list251

$sym252$L_INDEX

public static final SubLSymbol $sym252$L_INDEX

$sym253$METHOD

public static final SubLSymbol $sym253$METHOD

$sym254$DO_GLI_EXTRACT_METHOD

public static final SubLSymbol $sym254$DO_GLI_EXTRACT_METHOD

$sym255$DO_GLI_VIA_GAF_ARG

public static final SubLSymbol $sym255$DO_GLI_VIA_GAF_ARG

$sym256$DO_GLI_VIA_PREDICATE_EXTENT

public static final SubLSymbol $sym256$DO_GLI_VIA_PREDICATE_EXTENT

$kw257$OVERLAP

public static final SubLSymbol $kw257$OVERLAP

$sym258$DO_GLI_VIA_OVERLAP

public static final SubLSymbol $sym258$DO_GLI_VIA_OVERLAP

$sym259$OTHERWISE

public static final SubLSymbol $sym259$OTHERWISE

$sym260$DO_GLI_METHOD_ERROR

public static final SubLSymbol $sym260$DO_GLI_METHOD_ERROR

$kw261$INDEX_TYPE

public static final SubLSymbol $kw261$INDEX_TYPE

$str262$Skip_iteration

public static final SubLString $str262$Skip_iteration

$str263$Unsupported_method__S_in__S_in_DO

public static final SubLString $str263$Unsupported_method__S_in__S_in_DO

$sym264$TERM

public static final SubLSymbol $sym264$TERM

$sym265$ARGNUM

public static final SubLSymbol $sym265$ARGNUM

$sym266$PREDICATE

public static final SubLSymbol $sym266$PREDICATE

$sym267$CMULTIPLE_VALUE_BIND

public static final SubLSymbol $sym267$CMULTIPLE_VALUE_BIND

$sym268$DO_GLI_VGA_EXTRACT_KEYS

public static final SubLSymbol $sym268$DO_GLI_VGA_EXTRACT_KEYS

$sym269$PIF

public static final SubLSymbol $sym269$PIF

$kw270$TERM

public static final SubLSymbol $kw270$TERM

$kw271$ARGNUM

public static final SubLSymbol $kw271$ARGNUM

$sym272$DO_GLI_VPE_EXTRACT_KEY

public static final SubLSymbol $sym272$DO_GLI_VPE_EXTRACT_KEY

$sym273$DO_OVERLAP_INDEX

public static final SubLSymbol $sym273$DO_OVERLAP_INDEX

$sym274$DO_GLI_VO_EXTRACT_KEY

public static final SubLSymbol $sym274$DO_GLI_VO_EXTRACT_KEY

$kw275$TERMS

public static final SubLSymbol $kw275$TERMS

$list276

public static final SubLList $list276

$list277

public static final SubLList $list277

$sym278$DO_NAT_LOOKUP_INDEX

public static final SubLSymbol $sym278$DO_NAT_LOOKUP_INDEX

$sym279$BEST_NAT_LOOKUP_INDEX

public static final SubLSymbol $sym279$BEST_NAT_LOOKUP_INDEX

$list280

public static final SubLList $list280

$sym281$L_INDEX

public static final SubLSymbol $sym281$L_INDEX

$sym282$METHOD

public static final SubLSymbol $sym282$METHOD

$sym283$DO_NLI_EXTRACT_METHOD

public static final SubLSymbol $sym283$DO_NLI_EXTRACT_METHOD

$sym284$DO_NLI_VIA_NART_ARG

public static final SubLSymbol $sym284$DO_NLI_VIA_NART_ARG

$kw285$FUNCTION_EXTENT

public static final SubLSymbol $kw285$FUNCTION_EXTENT

$sym286$DO_NLI_VIA_FUNCTION_EXTENT

public static final SubLSymbol $sym286$DO_NLI_VIA_FUNCTION_EXTENT

$sym287$DO_NLI_VIA_OVERLAP

public static final SubLSymbol $sym287$DO_NLI_VIA_OVERLAP

$sym288$DO_NLI_METHOD_ERROR

public static final SubLSymbol $sym288$DO_NLI_METHOD_ERROR

$str289$Unsupported_method__S_in__S_in_DO

public static final SubLString $str289$Unsupported_method__S_in__S_in_DO

$sym290$TERM

public static final SubLSymbol $sym290$TERM

$sym291$ARGNUM

public static final SubLSymbol $sym291$ARGNUM

$sym292$FUNCTOR

public static final SubLSymbol $sym292$FUNCTOR

$sym293$DO_NLI_VNA_EXTRACT_KEYS

public static final SubLSymbol $sym293$DO_NLI_VNA_EXTRACT_KEYS

$kw294$FUNCTOR

public static final SubLSymbol $kw294$FUNCTOR

$sym295$DO_NLI_VFE_EXTRACT_KEY

public static final SubLSymbol $sym295$DO_NLI_VFE_EXTRACT_KEY

$sym296$DO_NLI_VO_EXTRACT_KEY

public static final SubLSymbol $sym296$DO_NLI_VO_EXTRACT_KEY

$sym297$ASSERTION_SEMANTICALLY_MATCHES_SIMPLE_FINAL_INDEX_SPEC_

public static final SubLSymbol $sym297$ASSERTION_SEMANTICALLY_MATCHES_SIMPLE_FINAL_INDEX_SPEC_

$sym298$FINAL_INDEX_ITERATOR_FILTERED

public static final SubLSymbol $sym298$FINAL_INDEX_ITERATOR_FILTERED

$sym299$QUOTE

public static final SubLSymbol $sym299$QUOTE

$list300

public static final SubLList $list300

$str301$Unexpected_non_simple_index__s

public static final SubLString $str301$Unexpected_non_simple_index__s

$list302

public static final SubLList $list302

$kw303$NART

public static final SubLSymbol $kw303$NART

$list304

public static final SubLList $list304

$str305$unexpected_type__s_in_simple_fina

public static final SubLString $str305$unexpected_type__s_in_simple_fina

$list306

public static final SubLList $list306

$sym307$FINAL_INDEX_P

public static final SubLSymbol $sym307$FINAL_INDEX_P

$sym308$ASSERTION_MATCHES_TYPE_TRUTH_AND_DIRECTION_

public static final SubLSymbol $sym308$ASSERTION_MATCHES_TYPE_TRUTH_AND_DIRECTION_

$sym309$SIMPLE_TERM_ASSERTION_LIST_FILTERED

public static final SubLSymbol $sym309$SIMPLE_TERM_ASSERTION_LIST_FILTERED

$sym310$_SIMPLE_TERM_ASSERTION_LIST_FILTERED_CACHING_STATE_

public static final SubLSymbol $sym310$_SIMPLE_TERM_ASSERTION_LIST_FILTERED_CACHING_STATE_

$int311$512

public static final SubLInteger $int311$512

$sym312$CLEAR_SIMPLE_TERM_ASSERTION_LIST_FILTERED

public static final SubLSymbol $sym312$CLEAR_SIMPLE_TERM_ASSERTION_LIST_FILTERED

$kw313$_MEMOIZED_ITEM_NOT_FOUND_

public static final SubLSymbol $kw313$_MEMOIZED_ITEM_NOT_FOUND_

$list314

public static final SubLList $list314

$list315

public static final SubLList $list315

$sym316$EL_FORMULA_P

public static final SubLSymbol $sym316$EL_FORMULA_P

$list317

public static final SubLList $list317

$list318

public static final SubLList $list318

$const319$abnormal

public static final SubLObject $const319$abnormal

$const320$meetsPragmaticRequirement

public static final SubLObject $const320$meetsPragmaticRequirement

$const321$ist

public static final SubLObject $const321$ist

Method Detail

do_gaf_arg_index_key_validator

public static final SubLObject do_gaf_arg_index_key_validator(SubLObject v_term,
                                                              SubLObject argnum,
                                                              SubLObject predicate)

Return T iff TERM, ARGNUM and PREDICATE are valid keys for DO-GAF-ARG-INDEX.

new_gaf_arg_final_index_spec_iterator

public static final SubLObject new_gaf_arg_final_index_spec_iterator(SubLObject v_term,
                                                                     SubLObject argnum,
                                                                     SubLObject predicate)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

initialize_gaf_arg_final_index_spec_iterator_state

public static final SubLObject initialize_gaf_arg_final_index_spec_iterator_state(SubLObject v_term,
                                                                                  SubLObject argnum,
                                                                                  SubLObject predicate)

gaf_arg_final_index_spec_iterator_state_term

public static final SubLObject gaf_arg_final_index_spec_iterator_state_term(SubLObject state)

The input term

gaf_arg_final_index_spec_iterator_state_predicate

public static final SubLObject gaf_arg_final_index_spec_iterator_state_predicate(SubLObject state)

The input predicate

gaf_arg_final_index_spec_iterator_state_note

public static final SubLObject gaf_arg_final_index_spec_iterator_state_note(SubLObject state)

A note containing information about the state of the keys, used to control code flow

gaf_arg_final_index_spec_iterator_state_argnum_keys

public static final SubLObject gaf_arg_final_index_spec_iterator_state_argnum_keys(SubLObject state)

The remaining argnums to iterate over

gaf_arg_final_index_spec_iterator_state_predicate_keys

public static final SubLObject gaf_arg_final_index_spec_iterator_state_predicate_keys(SubLObject state)

The remaining predicates left to iterate over

gaf_arg_final_index_spec_iterator_state_mt_keys

public static final SubLObject gaf_arg_final_index_spec_iterator_state_mt_keys(SubLObject state)

The remaining mts left to iterate over

set_gaf_arg_final_index_spec_iterator_state_note

public static final SubLObject set_gaf_arg_final_index_spec_iterator_state_note(SubLObject state,
                                                                                SubLObject note)

set_gaf_arg_final_index_spec_iterator_state_argnum_keys

public static final SubLObject set_gaf_arg_final_index_spec_iterator_state_argnum_keys(SubLObject state,
                                                                                       SubLObject new_keys)

set_gaf_arg_final_index_spec_iterator_state_predicate_keys

public static final SubLObject set_gaf_arg_final_index_spec_iterator_state_predicate_keys(SubLObject state,
                                                                                          SubLObject new_keys)

set_gaf_arg_final_index_spec_iterator_state_mt_keys

public static final SubLObject set_gaf_arg_final_index_spec_iterator_state_mt_keys(SubLObject state,
                                                                                   SubLObject new_keys)

gaf_arg_final_index_spec_iterator_doneP

public static final SubLObject gaf_arg_final_index_spec_iterator_doneP(SubLObject state)

gaf_arg_final_index_spec_iterator_next

public static final SubLObject gaf_arg_final_index_spec_iterator_next(SubLObject state)

gaf_arg_final_index_spec_iterator_quiesce

public static final SubLObject gaf_arg_final_index_spec_iterator_quiesce(SubLObject state)

Iterates over the keys in STATE until it ends up with its current keylist (@see gaf-arg-current-keylist) being valid and relevant, with validity and relevance being determined by @xref gaf-arg-current-relevant-keylist. It may not need to iterate over any keys in STATE, in which case STATE is left unchanged.

Returns:: 0 listp; the relevant final-index-spec thus formed, if any

gaf_arg_keylist_to_final_index_spec

public static final SubLObject gaf_arg_keylist_to_final_index_spec(SubLObject v_term,
                                                                   SubLObject keylist)

gaf_arg_current_relevant_keylist

public static final SubLObject gaf_arg_current_relevant_keylist(SubLObject state)

If STATE's current keylist is valid and relevant, returns it. Otherwise returns NIL. Valid means that none of its current keys are null. Relevant means that all of its current keys (mt and predicate) are deemed relevant (relevance is established from outside)

See Also:: gaf-arg-current-keylist

gaf_arg_final_index_spec_iterator_quiesce_one_step

public static final SubLObject gaf_arg_final_index_spec_iterator_quiesce_one_step(SubLObject state)

STATE is assumed to be invalid or irrelevant. This function fixes one cause of invalidity or irrelevance. Invalidity is caused by having no more pending keys in a slot -- refill them. Irrelevance is caused by having the current mt key be irrelevant -- pop it.

Returns:: booleanp; whether we failed to quiesce because we ran out of keys

gaf_arg_final_index_spec_iterator_refill_predicate_keys

public static final SubLObject gaf_arg_final_index_spec_iterator_refill_predicate_keys(SubLObject state)

refill the predicate-keys by popping an argnum but don't actually pop the argnum if it's fresh, just note that it's unfresh now

gaf_arg_final_index_spec_iterator_refill_mt_keys

public static final SubLObject gaf_arg_final_index_spec_iterator_refill_mt_keys(SubLObject state)

refill the mt-keys by popping a predicate but don't actually pop the predicate if it's fresh, just note that it's unfresh now

gaf_arg_final_index_spec_iterator_next_mt_key

public static final SubLObject gaf_arg_final_index_spec_iterator_next_mt_key(SubLObject state)

do_predicate_extent_index_key_validator

public static final SubLObject do_predicate_extent_index_key_validator(SubLObject predicate)

Return T iff PREDICATE is a valid key for DO-PREDICATE-EXTENT-INDEX.

new_predicate_extent_final_index_spec_iterator

public static final SubLObject new_predicate_extent_final_index_spec_iterator(SubLObject predicate)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

initialize_predicate_extent_final_index_spec_iterator_state

public static final SubLObject initialize_predicate_extent_final_index_spec_iterator_state(SubLObject predicate)

predicate_extent_final_index_spec_iterator_state_predicate

public static final SubLObject predicate_extent_final_index_spec_iterator_state_predicate(SubLObject state)

The input predicate

predicate_extent_final_index_spec_iterator_state_mt_keys

public static final SubLObject predicate_extent_final_index_spec_iterator_state_mt_keys(SubLObject state)

The remaining mts left to iterate over

set_predicate_extent_final_index_spec_iterator_state_mt_keys

public static final SubLObject set_predicate_extent_final_index_spec_iterator_state_mt_keys(SubLObject state,
                                                                                            SubLObject new_keys)

predicate_extent_final_index_spec_iterator_doneP

public static final SubLObject predicate_extent_final_index_spec_iterator_doneP(SubLObject state)

predicate_extent_final_index_spec_iterator_next

public static final SubLObject predicate_extent_final_index_spec_iterator_next(SubLObject state)

predicate_extent_final_index_spec_iterator_quiesce

public static final SubLObject predicate_extent_final_index_spec_iterator_quiesce(SubLObject state)

Iterates over the keys in STATE until it ends up with its current keylist (@see predicate-extent-current-keylist) being valid and relevant, with validity and relevance being determined by @xref predicate-extent-current-relevant-keylist. It may not need to iterate over any keys in STATE, in which case STATE is left unchanged.

Returns:: 0 listp; the relevant final-index-spec thus formed, if any

predicate_extent_keylist_to_final_index_spec

public static final SubLObject predicate_extent_keylist_to_final_index_spec(SubLObject v_term,
                                                                            SubLObject keylist)

predicate_extent_current_relevant_keylist

public static final SubLObject predicate_extent_current_relevant_keylist(SubLObject state)

If STATE's current keylist is valid and relevant, returns it. Otherwise returns NIL. Valid means that none of its current keys are null. Relevant means that its mt is deemed relevant (relevance is established from outside)

See Also:: predicate-extent-current-keylist

predicate_extent_final_index_spec_iterator_next_mt_key

public static final SubLObject predicate_extent_final_index_spec_iterator_next_mt_key(SubLObject state)

do_nart_arg_index_key_validator

public static final SubLObject do_nart_arg_index_key_validator(SubLObject v_term,
                                                               SubLObject index,
                                                               SubLObject function)

Return T iff TERM, INDEX and FUNCTION are valid keys for DO-NART-ARG-INDEX.

new_nart_arg_final_index_spec_iterator

public static final SubLObject new_nart_arg_final_index_spec_iterator(SubLObject v_term,
                                                                      SubLObject argnum,
                                                                      SubLObject function)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

initialize_nart_arg_final_index_spec_iterator_state

public static final SubLObject initialize_nart_arg_final_index_spec_iterator_state(SubLObject v_term,
                                                                                   SubLObject argnum,
                                                                                   SubLObject function)

nart_arg_final_index_spec_iterator_state_note

public static final SubLObject nart_arg_final_index_spec_iterator_state_note(SubLObject state)

A note containing information about the state of the keys, used to control code flow

nart_arg_final_index_spec_iterator_state_argnum_keys

public static final SubLObject nart_arg_final_index_spec_iterator_state_argnum_keys(SubLObject state)

The remaining argnums to iterate over

nart_arg_final_index_spec_iterator_state_function_keys

public static final SubLObject nart_arg_final_index_spec_iterator_state_function_keys(SubLObject state)

The remaining functions left to iterate over

nart_arg_final_index_spec_iterator_doneP

public static final SubLObject nart_arg_final_index_spec_iterator_doneP(SubLObject state)

do_function_extent_index_key_validator

public static final SubLObject do_function_extent_index_key_validator(SubLObject function)

Return T iff FUNCTION is a valid key for DO-FUNCTION-EXTENT-INDEX.

function_extent_final_index_spec

public static final SubLObject function_extent_final_index_spec(SubLObject function)

Makes the single final-index-spec for FUNCTION. This is the only complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

do_predicate_rule_index_key_validator

public static final SubLObject do_predicate_rule_index_key_validator(SubLObject predicate,
                                                                     SubLObject sense,
                                                                     SubLObject direction)

new_predicate_rule_final_index_spec_iterator

public static final SubLObject new_predicate_rule_final_index_spec_iterator(SubLObject predicate,
                                                                            SubLObject sense,
                                                                            SubLObject direction)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

initialize_predicate_rule_final_index_spec_iterator_state

public static final SubLObject initialize_predicate_rule_final_index_spec_iterator_state(SubLObject predicate,
                                                                                         SubLObject sense,
                                                                                         SubLObject direction)

predicate_rule_final_index_spec_iterator_state_predicate

public static final SubLObject predicate_rule_final_index_spec_iterator_state_predicate(SubLObject state)

The input predicate

predicate_rule_final_index_spec_iterator_state_direction

public static final SubLObject predicate_rule_final_index_spec_iterator_state_direction(SubLObject state)

The input direction

predicate_rule_final_index_spec_iterator_state_note

public static final SubLObject predicate_rule_final_index_spec_iterator_state_note(SubLObject state)

A note containing information about the state of the keys, used to control code flow

predicate_rule_final_index_spec_iterator_state_sense_keys

public static final SubLObject predicate_rule_final_index_spec_iterator_state_sense_keys(SubLObject state)

The remaining senses to iterate over

predicate_rule_final_index_spec_iterator_state_mt_keys

public static final SubLObject predicate_rule_final_index_spec_iterator_state_mt_keys(SubLObject state)

The remaining mts left to iterate over

predicate_rule_final_index_spec_iterator_state_direction_keys

public static final SubLObject predicate_rule_final_index_spec_iterator_state_direction_keys(SubLObject state)

The remaining directions left to iterate over

set_predicate_rule_final_index_spec_iterator_state_note

public static final SubLObject set_predicate_rule_final_index_spec_iterator_state_note(SubLObject state,
                                                                                       SubLObject note)

set_predicate_rule_final_index_spec_iterator_state_sense_keys

public static final SubLObject set_predicate_rule_final_index_spec_iterator_state_sense_keys(SubLObject state,
                                                                                             SubLObject new_keys)

set_predicate_rule_final_index_spec_iterator_state_mt_keys

public static final SubLObject set_predicate_rule_final_index_spec_iterator_state_mt_keys(SubLObject state,
                                                                                          SubLObject new_keys)

set_predicate_rule_final_index_spec_iterator_state_direction_keys

public static final SubLObject set_predicate_rule_final_index_spec_iterator_state_direction_keys(SubLObject state,
                                                                                                 SubLObject new_keys)

predicate_rule_final_index_spec_iterator_doneP

public static final SubLObject predicate_rule_final_index_spec_iterator_doneP(SubLObject state)

predicate_rule_final_index_spec_iterator_next

public static final SubLObject predicate_rule_final_index_spec_iterator_next(SubLObject state)

predicate_rule_final_index_spec_iterator_quiesce

public static final SubLObject predicate_rule_final_index_spec_iterator_quiesce(SubLObject state)

Iterates over the keys in STATE until it ends up with its current keylist (@see predicate-rule-current-keylist) being valid and relevant, with validity and relevance being determined by @xref predicate-rule-current-relevant-keylist. It may not need to iterate over any keys in STATE, in which case STATE is left unchanged.

Returns:: 0 listp; the relevant final-index-spec thus formed, if any

predicate_rule_keylist_to_final_index_spec

public static final SubLObject predicate_rule_keylist_to_final_index_spec(SubLObject pred,
                                                                          SubLObject keylist)

predicate_rule_current_relevant_keylist

public static final SubLObject predicate_rule_current_relevant_keylist(SubLObject state)

See Also:: predicate-rule-current-keylist

predicate_rule_final_index_spec_iterator_quiesce_one_step

public static final SubLObject predicate_rule_final_index_spec_iterator_quiesce_one_step(SubLObject state)

Returns:: booleanp; whether we failed to quiesce because we ran out of keys

predicate_rule_final_index_spec_iterator_refill_mt_keys

public static final SubLObject predicate_rule_final_index_spec_iterator_refill_mt_keys(SubLObject state)

refill the mt-keys by popping a sense but don't actually pop the sense if it's fresh, just note that it's unfresh now

predicate_rule_final_index_spec_iterator_refill_direction_keys

public static final SubLObject predicate_rule_final_index_spec_iterator_refill_direction_keys(SubLObject state)

refill the direction-keys by popping an mt but don't actually pop the mt if it's fresh, just note that it's unfresh now

predicate_rule_final_index_spec_iterator_next_direction_key

public static final SubLObject predicate_rule_final_index_spec_iterator_next_direction_key(SubLObject state)

do_decontextualized_ist_predicate_rule_index_key_validator

public static final SubLObject do_decontextualized_ist_predicate_rule_index_key_validator(SubLObject predicate,
                                                                                          SubLObject sense,
                                                                                          SubLObject direction)

new_decontextualized_ist_predicate_rule_final_index_spec_iterator

public static final SubLObject new_decontextualized_ist_predicate_rule_final_index_spec_iterator(SubLObject predicate,
                                                                                                 SubLObject sense,
                                                                                                 SubLObject direction)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

initialize_decontextualized_ist_predicate_rule_final_index_spec_iterator_state

public static final SubLObject initialize_decontextualized_ist_predicate_rule_final_index_spec_iterator_state(SubLObject predicate,
                                                                                                              SubLObject sense,
                                                                                                              SubLObject direction)

decontextualized_ist_predicate_rule_final_index_spec_iterator_state_predicate

public static final SubLObject decontextualized_ist_predicate_rule_final_index_spec_iterator_state_predicate(SubLObject state)

The input predicate

decontextualized_ist_predicate_rule_final_index_spec_iterator_state_direction

public static final SubLObject decontextualized_ist_predicate_rule_final_index_spec_iterator_state_direction(SubLObject state)

The input direction

decontextualized_ist_predicate_rule_final_index_spec_iterator_state_note

public static final SubLObject decontextualized_ist_predicate_rule_final_index_spec_iterator_state_note(SubLObject state)

A note containing information about the state of the keys, used to control code flow

decontextualized_ist_predicate_rule_final_index_spec_iterator_state_sense_keys

public static final SubLObject decontextualized_ist_predicate_rule_final_index_spec_iterator_state_sense_keys(SubLObject state)

The remaining senses to iterate over

decontextualized_ist_predicate_rule_final_index_spec_iterator_state_direction_keys

public static final SubLObject decontextualized_ist_predicate_rule_final_index_spec_iterator_state_direction_keys(SubLObject state)

The remaining directions left to iterate over

set_decontextualized_ist_predicate_rule_final_index_spec_iterator_state_note

public static final SubLObject set_decontextualized_ist_predicate_rule_final_index_spec_iterator_state_note(SubLObject state,
                                                                                                            SubLObject note)

set_decontextualized_ist_predicate_rule_final_index_spec_iterator_state_direction_keys

public static final SubLObject set_decontextualized_ist_predicate_rule_final_index_spec_iterator_state_direction_keys(SubLObject state,
                                                                                                                      SubLObject new_keys)

decontextualized_ist_predicate_rule_final_index_spec_iterator_doneP

public static final SubLObject decontextualized_ist_predicate_rule_final_index_spec_iterator_doneP(SubLObject state)

decontextualized_ist_predicate_rule_final_index_spec_iterator_next

public static final SubLObject decontextualized_ist_predicate_rule_final_index_spec_iterator_next(SubLObject state)

decontextualized_ist_predicate_rule_final_index_spec_iterator_quiesce

public static final SubLObject decontextualized_ist_predicate_rule_final_index_spec_iterator_quiesce(SubLObject state)

Iterates over the keys in STATE until it ends up with its current keylist (@see decontextualized-ist-predicate-rule-current-keylist) being valid and relevant, with validity and relevance being determined by @xref decontextualized-ist-predicate-rule-current-relevant-keylist. It may not need to iterate over any keys in STATE, in which case STATE is left unchanged.

Returns:: 0 listp; the relevant final-index-spec thus formed, if any

decontextualized_ist_predicate_rule_keylist_to_final_index_spec

public static final SubLObject decontextualized_ist_predicate_rule_keylist_to_final_index_spec(SubLObject pred,
                                                                                               SubLObject keylist)

decontextualized_ist_predicate_rule_current_relevant_keylist

public static final SubLObject decontextualized_ist_predicate_rule_current_relevant_keylist(SubLObject state)

If STATE's current keylist is valid, returns it. Otherwise returns NIL. Valid means that none of its current keys are null.

See Also:: decontextualized-ist-predicate-rule-current-keylist

decontextualized_ist_predicate_rule_final_index_spec_iterator_quiesce_one_step

public static final SubLObject decontextualized_ist_predicate_rule_final_index_spec_iterator_quiesce_one_step(SubLObject state)

STATE is assumed to be invalid. This function fixes one cause of invalidity. Invalidity is caused by having no more pending keys in a slot -- refill them.

Returns:: booleanp; whether we failed to quiesce because we ran out of keys

decontextualized_ist_predicate_rule_final_index_spec_iterator_refill_direction_keys

public static final SubLObject decontextualized_ist_predicate_rule_final_index_spec_iterator_refill_direction_keys(SubLObject state)

refill the direction-keys by popping a sense but don't actually pop the sense if it's fresh, just note that it's unfresh now

decontextualized_ist_predicate_rule_final_index_spec_iterator_next_direction_key

public static final SubLObject decontextualized_ist_predicate_rule_final_index_spec_iterator_next_direction_key(SubLObject state)

do_isa_rule_index_key_validator

public static final SubLObject do_isa_rule_index_key_validator(SubLObject collection,
                                                               SubLObject sense,
                                                               SubLObject direction)

new_isa_rule_final_index_spec_iterator

public static final SubLObject new_isa_rule_final_index_spec_iterator(SubLObject collection,
                                                                      SubLObject sense,
                                                                      SubLObject direction)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

do_quoted_isa_rule_index_key_validator

public static final SubLObject do_quoted_isa_rule_index_key_validator(SubLObject collection,
                                                                      SubLObject sense,
                                                                      SubLObject direction)

new_quoted_isa_rule_final_index_spec_iterator

public static final SubLObject new_quoted_isa_rule_final_index_spec_iterator(SubLObject collection,
                                                                             SubLObject sense,
                                                                             SubLObject direction)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

do_genls_rule_index_key_validator

public static final SubLObject do_genls_rule_index_key_validator(SubLObject collection,
                                                                 SubLObject sense,
                                                                 SubLObject direction)

new_genls_rule_final_index_spec_iterator

public static final SubLObject new_genls_rule_final_index_spec_iterator(SubLObject collection,
                                                                        SubLObject sense,
                                                                        SubLObject direction)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

do_genl_mt_rule_index_key_validator

public static final SubLObject do_genl_mt_rule_index_key_validator(SubLObject genl_mt,
                                                                   SubLObject sense,
                                                                   SubLObject direction)

new_genl_mt_rule_final_index_spec_iterator

public static final SubLObject new_genl_mt_rule_final_index_spec_iterator(SubLObject genl_mt,
                                                                          SubLObject sense,
                                                                          SubLObject direction)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

do_pred_arg2_rule_index_key_validator

public static final SubLObject do_pred_arg2_rule_index_key_validator(SubLObject arg2,
                                                                     SubLObject sense,
                                                                     SubLObject direction)

initialize_pred_arg2_rule_final_index_spec_iterator_state

public static final SubLObject initialize_pred_arg2_rule_final_index_spec_iterator_state(SubLObject pred,
                                                                                         SubLObject top_level_key,
                                                                                         SubLObject arg2,
                                                                                         SubLObject sense,
                                                                                         SubLObject direction)

pred_arg2_rule_final_index_spec_iterator_state_arg2

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_state_arg2(SubLObject state)

The input arg2

pred_arg2_rule_final_index_spec_iterator_state_direction

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_state_direction(SubLObject state)

The input direction

pred_arg2_rule_final_index_spec_iterator_state_note

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_state_note(SubLObject state)

A note containing information about the state of the keys, used to control code flow

pred_arg2_rule_final_index_spec_iterator_state_sense_keys

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_state_sense_keys(SubLObject state)

The remaining senses to iterate over

pred_arg2_rule_final_index_spec_iterator_state_mt_keys

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_state_mt_keys(SubLObject state)

The remaining mts left to iterate over

pred_arg2_rule_final_index_spec_iterator_state_direction_keys

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_state_direction_keys(SubLObject state)

The remaining directions left to iterate over

pred_arg2_rule_final_index_spec_iterator_state_pred

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_state_pred(SubLObject state)

The input pred

pred_arg2_rule_final_index_spec_iterator_state_top_level_key

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_state_top_level_key(SubLObject state)

The top-level key to the final index, used for subclassing

set_pred_arg2_rule_final_index_spec_iterator_state_note

public static final SubLObject set_pred_arg2_rule_final_index_spec_iterator_state_note(SubLObject state,
                                                                                       SubLObject note)

set_pred_arg2_rule_final_index_spec_iterator_state_sense_keys

public static final SubLObject set_pred_arg2_rule_final_index_spec_iterator_state_sense_keys(SubLObject state,
                                                                                             SubLObject new_keys)

set_pred_arg2_rule_final_index_spec_iterator_state_mt_keys

public static final SubLObject set_pred_arg2_rule_final_index_spec_iterator_state_mt_keys(SubLObject state,
                                                                                          SubLObject new_keys)

set_pred_arg2_rule_final_index_spec_iterator_state_direction_keys

public static final SubLObject set_pred_arg2_rule_final_index_spec_iterator_state_direction_keys(SubLObject state,
                                                                                                 SubLObject new_keys)

pred_arg2_rule_final_index_spec_iterator_doneP

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_doneP(SubLObject state)

pred_arg2_rule_final_index_spec_iterator_next

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_next(SubLObject state)

pred_arg2_rule_final_index_spec_iterator_quiesce

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_quiesce(SubLObject state)

Iterates over the keys in STATE until it ends up with its current keylist (@see pred-arg2-rule-current-keylist) being valid and relevant, with validity and relevance being determined by @xref pred-arg2-rule-current-relevant-keylist. It may not need to iterate over any keys in STATE, in which case STATE is left unchanged.

Returns:: 0 listp; the relevant final-index-spec thus formed, if any

pred_arg2_rule_keylist_to_final_index_spec

public static final SubLObject pred_arg2_rule_keylist_to_final_index_spec(SubLObject pred,
                                                                          SubLObject top_level_key,
                                                                          SubLObject keylist)

pred_arg2_rule_current_relevant_keylist

public static final SubLObject pred_arg2_rule_current_relevant_keylist(SubLObject state)

See Also:: pred-arg2-rule-current-keylist

pred_arg2_rule_final_index_spec_iterator_quiesce_one_step

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_quiesce_one_step(SubLObject state)

Returns:: booleanp; whether we failed to quiesce because we ran out of keys

pred_arg2_rule_final_index_spec_iterator_refill_mt_keys

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_refill_mt_keys(SubLObject state)

refill the mt-keys by popping a sense but don't actually pop the sense if it's fresh, just note that it's unfresh now

pred_arg2_rule_final_index_spec_iterator_refill_direction_keys

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_refill_direction_keys(SubLObject state)

refill the direction-keys by popping an mt but don't actually pop the mt if it's fresh, just note that it's unfresh now

pred_arg2_rule_final_index_spec_iterator_next_direction_key

public static final SubLObject pred_arg2_rule_final_index_spec_iterator_next_direction_key(SubLObject state)

key_pred_arg2_rule_index

public static final SubLObject key_pred_arg2_rule_index(SubLObject pred,
                                                        SubLObject arg2,
                                                        SubLObject sense,
                                                        SubLObject mt)

do_function_rule_index_key_validator

public static final SubLObject do_function_rule_index_key_validator(SubLObject function,
                                                                    SubLObject direction)

new_function_rule_final_index_spec_iterator

public static final SubLObject new_function_rule_final_index_spec_iterator(SubLObject function,
                                                                           SubLObject direction)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

initialize_function_rule_final_index_spec_iterator_state

public static final SubLObject initialize_function_rule_final_index_spec_iterator_state(SubLObject func,
                                                                                        SubLObject direction)

function_rule_final_index_spec_iterator_state_note

public static final SubLObject function_rule_final_index_spec_iterator_state_note(SubLObject state)

A note containing information about the state of the keys, used to control code flow

function_rule_final_index_spec_iterator_state_mt_keys

public static final SubLObject function_rule_final_index_spec_iterator_state_mt_keys(SubLObject state)

The remaining mts left to iterate over

function_rule_final_index_spec_iterator_state_direction_keys

public static final SubLObject function_rule_final_index_spec_iterator_state_direction_keys(SubLObject state)

The remaining directions left to iterate over

function_rule_final_index_spec_iterator_doneP

public static final SubLObject function_rule_final_index_spec_iterator_doneP(SubLObject state)

do_exception_rule_index_key_validator

public static final SubLObject do_exception_rule_index_key_validator(SubLObject rule,
                                                                     SubLObject direction)

new_exception_rule_final_index_spec_iterator

public static final SubLObject new_exception_rule_final_index_spec_iterator(SubLObject rule,
                                                                            SubLObject direction)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

do_pragma_rule_index_key_validator

public static final SubLObject do_pragma_rule_index_key_validator(SubLObject rule,
                                                                  SubLObject direction)

new_pragma_rule_final_index_spec_iterator

public static final SubLObject new_pragma_rule_final_index_spec_iterator(SubLObject rule,
                                                                         SubLObject direction)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

do_mt_index_key_validator

public static final SubLObject do_mt_index_key_validator(SubLObject mt,
                                                         SubLObject type)

mt_final_index_spec

public static final SubLObject mt_final_index_spec(SubLObject mt)

Makes the single final-index-spec for MT. This is the only complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

do_other_index_key_validator

public static final SubLObject do_other_index_key_validator(SubLObject v_term,
                                                            SubLObject type)

other_final_index_spec

public static final SubLObject other_final_index_spec(SubLObject v_term)

Makes the single final-index-spec for TERM. This is the only complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

other_final_index_spec_p

public static final SubLObject other_final_index_spec_p(SubLObject final_index_spec)

The other index is the only one that needs to do post-hoc semantic filtering. It's not only redundant for other indexes, it's INCORRECT in the case of the mt-index. The mt-index needs to NOT do post-hoc semantic filtering, but the other index requires it. Therefore, we need to gate it based on whether these assertions came from the other index.

other_simple_final_index_spec_p

public static final SubLObject other_simple_final_index_spec_p(SubLObject object)

other_complex_final_index_spec_p

public static final SubLObject other_complex_final_index_spec_p(SubLObject object)

other_index_assertion_match_p

public static final SubLObject other_index_assertion_match_p(SubLObject assertion,
                                                             SubLObject v_term)

do_term_index_key_validator

public static final SubLObject do_term_index_key_validator(SubLObject v_term,
                                                           SubLObject type)

new_term_final_index_spec_iterator

public static final SubLObject new_term_final_index_spec_iterator(SubLObject v_term,
                                                                  SubLObject type)

Makes an iterator which spits out final-index-specs, each of which is a complete path (i.e. a list of keys) leading down to a final index (a list) of assertions.

do_term_index_assertion_match_p

public static final SubLObject do_term_index_assertion_match_p(SubLObject assertion,
                                                               SubLObject final_index_spec)

The :other index is the only one that needs this post-hoc semantic filtering.

do_gli_extract_method

public static final SubLObject do_gli_extract_method(SubLObject lookup_index)

do_gli_vga_extract_keys

public static final SubLObject do_gli_vga_extract_keys(SubLObject lookup_index)

do_gli_vpe_extract_key

public static final SubLObject do_gli_vpe_extract_key(SubLObject lookup_index)

simple_final_index_spec_p

public static final SubLObject simple_final_index_spec_p(SubLObject final_index_spec)

simple_final_index_spec_term

public static final SubLObject simple_final_index_spec_term(SubLObject final_index_spec)

new_final_index_iterator

public static final SubLObject new_final_index_iterator(SubLObject final_index_spec,
                                                        SubLObject type,
                                                        SubLObject truth,
                                                        SubLObject direction)

If FINAL-INDEX-SPEC is simple, then get the syntactically filtered list from the other side, then wrap it with a filter iterator to do the semantic filtering on this side. If FINAL-INDEX-SPEC is complex, then get the list from the other side. This list is already filtered by type, truth, and direction, and the keys in FINAL-INDEX-SPEC have already been filtered by mt and predicate relevance, so we don't need a filter.

assertion_semantically_matches_simple_final_index_specP

public static final SubLObject assertion_semantically_matches_simple_final_index_specP(SubLObject assertion,
                                                                                       SubLObject simple_final_index_spec)

Assumes that ASSERTION syntactically matches SIMPLE-FINAL-INDEX-SPEC

destroy_final_index_iterator

public static final SubLObject destroy_final_index_iterator(SubLObject final_index_iterator)

final_index_iterator_filtered

public static final SubLObject final_index_iterator_filtered(SubLObject final_index_spec,
                                                             SubLObject type_spec,
                                                             SubLObject truth_spec,
                                                             SubLObject direction_spec)

Gets the index of TERM, then follows each key in KEYS in succession. It must end up at NIL or a final index or it will signal an error. Then it turns the final index into an iterator and filters it by TYPE-SPEC, TRUTH-SPEC and DIRECTION-SPEC.

new_gaf_simple_final_index_spec

public static final SubLObject new_gaf_simple_final_index_spec(SubLObject v_term,
                                                               SubLObject argnum_spec,
                                                               SubLObject predicate_spec,
                                                               SubLObject mt_spec)

Returns a 'gaf simple final index spec' -- a constraint object used to filter gafs.

Parameters:: TERM; - the simply indexed term from which to get the unfiltered list of gafs.; ARGNUM-SPEC; - @see gaf-matches-simple-argnum-spec?; PREDICATE-SPEC - nil or predicate-p; the predicate of the gaf; MT-SPEC - nil or hlmt-p; the mt of the gaf

new_nart_simple_final_index_spec

public static final SubLObject new_nart_simple_final_index_spec(SubLObject v_term,
                                                                SubLObject argnum_spec,
                                                                SubLObject functor_spec)

Returns a 'nart simple final index spec' -- a constraint object used to filter narts.

Parameters:: TERM; - the simply indexed term from which to get the unfiltered list of narts.; ARGNUM-SPEC; - @see tou-syntactically-matches-simple-nart-final-index-spec?; FUNCTOR-SPEC - nil or functor-p; the functor of the nart

new_rule_simple_final_index_spec

public static final SubLObject new_rule_simple_final_index_spec(SubLObject v_term,
                                                                SubLObject sense_spec,
                                                                SubLObject asent_func)

Returns a 'rule simple final index spec' -- a constraint object used to filter rules.

Parameters:: TERM; - the simply indexed term from which to get the unfiltered list of rules.; SENSE-SPEC - nil or sense-p; the sense of the literal we're looking for; ASENT-FUNC; - we will (funcall ASENT-FUNC ASENT TERM) for each ASENT with sense SENSE-SPEC, and the rule is admitted iff there is such a literal.

new_assertion_simple_final_index_spec

public static final SubLObject new_assertion_simple_final_index_spec(SubLObject v_term,
                                                                     SubLObject assertion_func)

Returns a 'simple final index spec' -- a constraint object used to filter assertions.

Parameters:: ASSERTION-FUNC; - we will (funcall ASSERTION-FUNC ASSERTION TERM), and the assertion is admitted iff it returns true.

clear_simple_term_assertion_list_filtered

public static final SubLObject clear_simple_term_assertion_list_filtered()

simple_term_assertion_list_filtered_internal

public static final SubLObject simple_term_assertion_list_filtered_internal(SubLObject simple_final_index_spec,
                                                                            SubLObject type,
                                                                            SubLObject truth,
                                                                            SubLObject direction)

Returns:: listp; the list of all assertions referencing the TERM in FINAL-INDEX-SPEC which match TYPE, TRUTH, DIRECTION, and the syntactic constraints expressed in FINAL-INDEX-SPEC.

simple_term_assertion_list_filtered

public static final SubLObject simple_term_assertion_list_filtered(SubLObject simple_final_index_spec,
                                                                   SubLObject type,
                                                                   SubLObject truth,
                                                                   SubLObject direction)

assertion_syntactically_matches_simple_final_index_specP

public static final SubLObject assertion_syntactically_matches_simple_final_index_specP(SubLObject assertion,
                                                                                        SubLObject simple_final_index_spec)

assertion_matches_syntactic_indexing_typeP

public static final SubLObject assertion_matches_syntactic_indexing_typeP(SubLObject assertion,
                                                                          SubLObject type)

gaf_syntactically_matches_simple_gaf_final_index_specP

public static final SubLObject gaf_syntactically_matches_simple_gaf_final_index_specP(SubLObject gaf,
                                                                                      SubLObject v_term,
                                                                                      SubLObject gaf_final_index_spec)

gaf_matches_simple_argnum_specP

public static final SubLObject gaf_matches_simple_argnum_specP(SubLObject gaf,
                                                               SubLObject v_term,
                                                               SubLObject argnum_spec)

Parameters:: ARGNUM-SPEC - a specification for how TERM must appear in some argument position of GAF. NIL means that it doesn't matter. an integer N means that TERM must appear as the Nth argument in GAF. :any means that TERM must appear as a top-level argument in GAF. (N M) means that TERM must appear as the Mth argument in the formula that is the Nth argument of GAF. (N :any) means that TERM must appear as a top-level argument in the formula that is the Nth argument of GAF.

rule_syntactically_matches_simple_rule_final_index_specP

public static final SubLObject rule_syntactically_matches_simple_rule_final_index_specP(SubLObject rule,
                                                                                        SubLObject v_term,
                                                                                        SubLObject rule_final_index_spec)

Parameters:: RULE-FINAL-INDEX-SPEC; - a (SENSE ASENT-FUNC) pair.
Returns:: booleanp; whether RULE has a SENSE-lit ASENT such that (funcall ASENT-FUNC ASENT TERM) holds.

rule_syntactically_matches_simple_rule_final_index_spec_intP

public static final SubLObject rule_syntactically_matches_simple_rule_final_index_spec_intP(SubLObject rule,
                                                                                            SubLObject sense,
                                                                                            SubLObject v_term,
                                                                                            SubLObject asent_func)

asent_syntactically_matches_simple_rule_final_index_specP

public static final SubLObject asent_syntactically_matches_simple_rule_final_index_specP(SubLObject asent,
                                                                                         SubLObject v_term,
                                                                                         SubLObject asent_func)

assertion_syntactically_matches_simple_assertion_final_index_specP

public static final SubLObject assertion_syntactically_matches_simple_assertion_final_index_specP(SubLObject assertion,
                                                                                                  SubLObject v_term,
                                                                                                  SubLObject assertion_final_index_spec)

predicate_rule_index_asent_match_p

public static final SubLObject predicate_rule_index_asent_match_p(SubLObject asent,
                                                                  SubLObject predicate)

predicate_rule_index_asent_p

public static final SubLObject predicate_rule_index_asent_p(SubLObject asent)

decontextualized_ist_predicate_rule_index_asent_match_p

public static final SubLObject decontextualized_ist_predicate_rule_index_asent_match_p(SubLObject asent,
                                                                                       SubLObject predicate)

genls_rule_index_asent_match_p

public static final SubLObject genls_rule_index_asent_match_p(SubLObject asent,
                                                              SubLObject collection)

genls_rule_index_asent_p

public static final SubLObject genls_rule_index_asent_p(SubLObject asent)

pragma_rule_index_asent_match_p

public static final SubLObject pragma_rule_index_asent_match_p(SubLObject asent,
                                                               SubLObject rule)

pragma_rule_index_asent_p

public static final SubLObject pragma_rule_index_asent_p(SubLObject asent)

mt_index_assertion_match_p

public static final SubLObject mt_index_assertion_match_p(SubLObject assertion,
                                                          SubLObject mt)

declare_kb_mapping_macros_file

public static final SubLObject declare_kb_mapping_macros_file()

init_kb_mapping_macros_file

public static final SubLObject init_kb_mapping_macros_file()

setup_kb_mapping_macros_file

public static final SubLObject setup_kb_mapping_macros_file()

declareFunctions

public void declareFunctions()

Description copied from interface: SubLFile

Declares the mapping between functions and symbols for all named functions defined in the file. Like CRTL define.

initializeVariables

public void initializeVariables()

Description copied from interface: SubLFile

Initializes all global variables and private internal variables for constants defined in the file. Like CRTL init.

runTopLevelForms

public void runTopLevelForms()

Description copied from interface: SubLFile

Runs all top-level forms in order. Like CRTL setup.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.cyc.cycjava.cycl Class kb_mapping_macros

me

myName

$list0

$sym1$PWHEN

$sym2$RELEVANT_PRED_

$list3

$sym4$RELEVANT_MT_

$list5

$sym6$PROGN

$sym7$TRUTH_RELEVANT_P

$sym8$PWHEN_TRUTH_RELEVANT

$list9

$sym10$ASSERTION_HAS_TRUTH

$sym11$COR

$sym12$NULL

$list13

$sym14$ASSERTION_HAS_DIRECTION_SPEC

$list15

$list16

$kw17$ALLOW_OTHER_KEYS

$kw18$TRUTH

$kw19$DIRECTION

$kw20$DONE

$sym21$DO_LIST

$sym22$PWHEN_ASSERTION_HAS_TRUTH

$sym23$PWHEN_ASSERTION_HAS_DIRECTION_SPEC

$list24

$sym25$DO_ASSERTION_LIST

$sym26$DO_SIMPLE_INDEX_TERM_ASSERTION_LIST

$list27

$kw28$GAF

$sym29$GAF_ASSERTION_

$kw30$RULE

$sym31$RULE_ASSERTION_

$sym32$ASSERTION_HAS_TYPE

$list33

$list34

$kw35$PROGRESS_MESSAGE

$sym36$UNTIL_MAPPING_FINISHED

$sym37$SOME_ASSERTIONS_INTERNAL

$list38

$sym39$SOME_ASSERTIONS

$list40

$list41

$sym42$DO_ASSERTIONS

$sym43$DO_FINAL_INDEX_FROM_SPEC

$list44

$list45

$sym46$FINAL_INDEX_ITERATOR

$sym47$CLET

$sym48$CUNWIND_PROTECT

$sym49$CSETQ

$sym50$NEW_FINAL_INDEX_ITERATOR

$sym51$DO_ITERATOR_WITHOUT_VALUES_INTERNAL

$sym52$DESTROY_FINAL_INDEX_ITERATOR

$list53

$list54

$kw55$INDEX

$kw56$PREDICATE

$sym57$PRED_VAR

$sym58$FINAL_INDEX_SPEC

$sym59$DO_GAF_ARG_INDEX_KEY_VALIDATOR

$sym60$NEW_GAF_ARG_FINAL_INDEX_SPEC_ITERATOR

$sym61$DO_GAF_ARG_INDEX

$str62$Iterate_over_an_index_of_gaf_asse

$list63

$sym64$ASSERTION

$sym65$GAF_ARG

$kw66$ANY

$sym67$GAF_ARG_FINAL_INDEX_SPEC_ITERATOR_DONE_

$sym68$GAF_ARG_FINAL_INDEX_SPEC_ITERATOR_NEXT

$kw69$ARGNUM_KEYS_ARE_FRESH

$kw70$GAF_ARG

$kw71$PREDICATE_KEYS_ARE_FRESH

$list72

$sym73$PRED_VAR

$sym74$FINAL_INDEX_SPEC

$sym75$DO_PREDICATE_EXTENT_INDEX_KEY_VALIDATOR

$sym76$NEW_PREDICATE_EXTENT_FINAL_INDEX_SPEC_ITERATOR

com.cyc.cycjava.cycl
Class kb_mapping_macros