# # KEHOME/src/symbol.icn # # Nov/4/2005 # Dec/27/2006 fix bug: interpret_symbol() arglist # Dec/29/2006 fix generator definition # Jan/24/2007 treat (...) like quote - paren # Feb/3/2007 treat <...> like quote - angle - multi=line comment # Feb/5/2007 allow bselist for [...] and {...} # Feb/5/2007 match_token() triggers grammar hint # Feb/8/2007 m_xml_version() m_rdf_namespace # Feb/12/2007 new relation syntax: subject rel verb object, ... ; # Feb/14/2007 verb verb verb; for verb properties # Feb/16/2007 TypeComment # Feb/25/2007 subject HAS vplist # Mar/9/2007 producer includes proposition # Mar/10/2007 wordproposition # Mar/18/2007 m_value() BSE # Mar/21/2007 subject,object,nvobject ::= m_ANGLE() # Mar/28/2007 grammar hint for verb, propositionlist # Apr/1/2007 fix bug: m_rdf_namespace() # Apr/1/2007 do </rdf:RDF> # # Jul/28/2008 restored version 7.3, May 31, 2008 # Jul/28/2008 no special meaning for words in HO and REL # Jul/28/2008 ido interaction # Jul/28/2008 use "ho" and "nrel" as context prefix # Jul/29/2008 use CurrentGroupName to check if in group # Jul/29/2008 use CurrentGroupName to check if in group # Jul/29/2008 if propositionlist # Jul/29/2008 html_comment # Aug/1/2008 new immplementation begin/end group # Aug/17/2008 fix slash, group_statement # Aug/24/2008 use VERBhint to avoid conflict with global VERB # Aug/24/2008 use dval to catch interpret_symbol() failure # Aug/25/2008 fix nested & null nrel_phrase # Aug/26/2008 pipeline syntax # Aug/30/2008 parse_file(): unparse(fd) # Aug/31/2008 KFORMAT==("nrel"|"list") allow null phrase # Sep/1/2008 BSE(L,B,S,E) m_BSE(S,B,L,E) # Sep/1/2008 m_bracket() includes m_nvphrase_list() global VERBhint global PS # prompt string used by prompt() in myio.icn # global varibles for Merr global yystate # parser state global yytoken # parser token global errors # current no of errors = KERROR global fName # current file name = FNAME global statestk # state stack global yychar # token list global yylineno # current lineno global yytext # input string global yylinenotab # for per file counts global yyfnametab # for per file counts #=============================# # pattern matching: # # TOKEN list -> SYMBOL list # #=============================# # NOTE: new grammar uses tokens # "w" word # "x" extended word which includes +-*: record SYMBOL ( stype, # string svalue # list (or string ???) ) record m_BSE ( mbse_separator, mbse_begin, mbse_list, mbse_end ) #=========# # methods # #=========# # token_htag(tokenlist) # token_hend(tokenlist) # token_harg(tokenlist) # get_svalue(symbol) # get_stype(symbol) # is_null_symbol(x) # find_stype(pattern,symbol) # get_symbol(tokenlist) # tsize(symbol) # map_symbol(tsym,tok,finish) # parse_file(fd,ps,option) # parse_line(line) # insert_context() # delete_context(symbol) # unparse(symbol) # unparse.icn # interpret_symbol(symbol,stype) # sentence.icn # interpret_line(line,kformat,dollar) # symbol.icn # parse_list(line,sep) # parse_quantifier(line,sep) # parse_value(line) # parse_nv(line) # parse_nrel(line,option) # parse_relation(line,sep) # parse_hierarchy(line,sep) #--------------------------------------------# #--------------------------------------------# # TOKEN list procedure insert_context() #========================= # called by parse_file() in symbol.icn # insert context markers for easy # parsing of begin-end groups local inside,start static WW,XX initial { WW := [TOKEN("W","ho")] # hierarchy XX := [TOKEN("X","nrel")] # relation } start := [] if (*CurrentGroupName > 0) | (KFORMAT == ("ho"|"hounit"|"nrel")) then case KFORMAT of { default: { } ("ho"|"hounit"): { start := WW } ("nrel"): { start := XX } } # end case KFORMAT return start end # SYMBOL list procedure delete_context(symbol) # <<== obsolete #=============================== # called by do_mkrproposition() in symbol.icn # GROUP("group",GROUP(stype,svalue)) # GROUP("begin",[...]) # GROUP("gs",["X",...]) | GROUP("gs",["W",...]) # GROUP("end",["X",...]) | GROUP("gs",["W",...]) # problem with proposition name # productGroup("productGROUP",[propname,"::",GROUP()]) ??? local t,stype,svalue,sym local gtype,gvalue static info,ierror initial { info := "INFO: delete_context: " ierror := "Internal ERROR: delete_context: " } case t := type(symbol) of { "SYMBOL": { stype := symbol.stype svalue := symbol.svalue case stype of { default: { return SYMBOL(stype,delete_context(svalue)) } } } "GROUP": { #writes_type_all(symbol,info||"symbol") gtype := symbol.gtype gvalue := symbol.gvalue case gtype of { "group": { return GROUP(gtype,delete_context(gvalue)) } "begin": { return symbol } ("gs"|"end"): { if unparse(gvalue[1]) == ("W"|"X") then # context token return GROUP(gtype,gvalue[2:0]) } } } "PHRASE": { #writes_type_all(symbol,info||"PHRASE") return symbol } "NVPHRASE": { #writes_type_all(symbol,info||"NVPHRASE") return symbol } "VOPHRASE": { #writes_type_all(symbol,info||"VOPHRASE") return symbol } "AAPHRASE": { #writes_type_all(symbol,info||"AAPHRASE") return symbol } "HOUNIT": { #writes_type_all(symbol,info||"HOUNIT") return symbol } "RELUNIT": { #writes_type_all(symbol,info||"RELUNIT") return symbol } "BSE": { return symbol } "m_BSE": { return mbse2bse(symbol) } "list": { sym := [] every put(sym,delete_context(!symbol)) return symbol } "string": { if symbol == "X" then writes_type_all(symbol,info||"string") return symbol } default: { writes_type_all(symbol,info||"default") return symbol } } # end case t end #--------------------------------------------# procedure is_null_symbol(x) #========================== if type(x)=="SYMBOL" & x.stype=="null" then { return x } else { fail } end #===================================================================# #===================================================================# # KFORMAT == "ku" # SYMBOL(stype,svalue) #===================================================================# # SYMBOL procedure m_proplist() #===================== # proplist ::= # proposition # proposition proplist static PROPLIST initial { PROPLIST := TOKEN("w","propositionlist") } yystate := "m_proplist" suspend \ SYMBOL("prop",[m_proposition()]) | SYMBOL("proplist",[m_proposition()] ||| [m_proplist()] ) | SYMBOL("grammar hint",match_token(PROPLIST)) end # SYMBOL procedure m_proposition() #======================== # proposition ::= # xml_version # xml_doctype # rdf_namespace # rdf_end # html_statement # context brace ; # context ; # sentence # does NOT include brace # compound_sentence # includes brace "and" "or" "not" # qword; # "true"|"false"|"&null"|"proposition" # brace ::= # { proplist } static PROP initial { PROP := TOKEN("w","proposition") } yystate := "m_proposition" suspend \ m_xml_version() | # <?xml n=v n=v?> m_xml_doctype() | # <!t n v> m_rdf_namespace() | # <rdf:RDF n=v ... > m_rdf_end() | # </rdf:RDF> m_html_statement() | # <t n=v /> SYMBOL("context sentence",[m_context(),m_pipeline(),=";"]) | SYMBOL("context",[m_context(),=";"]) | SYMBOL("compound sentence",m_compound_sentence()) | SYMBOL("sentence",m_sentence()) | SYMBOL("grammar hint",[match_token(PROP),=";"]) | SYMBOL("wordproposition",[m_qword(),=";"]) end # list procedure m_context() #==================== # context ::= # at nvobject yystate := "m_context" suspend \ [[="A"],m_nvobject()] end # list procedure m_pipeline() #===================== # pipeline ::= brace # brace | pipeline yystate := "m_pipeline" suspend \ [m_brace()] | [m_brace()] ||| [="|"] ||| m_pipeline() end # list procedure m_compound_sentence() #============================== # for now: treat "|" like ";" # NOTE: sentence ::= clause ; # conjunction ::= and | or # compound_sentence ::= # brace ; # "not" brace ; # brace conjunction compound_sentence # "not" brace conjunction compound_sentence # brace ::= # { proplist } yystate := "m_compound_sentence" suspend \ [m_brace(),=";"] | [m_brace(),="|"] | [m_notbrace(),=";"] | [m_notbrace(),="|"] | [m_brace(),m_conjunction()] ||| m_compound_sentence() | [m_notbrace(),m_conjunction()] ||| m_compound_sentence() end # SYMBOL procedure m_conjunction() #======================== # NOTE: relverb includes "J" # conjunction ::= # "and", "or" # "j" # # "&" # "&" # "|" # "|" # pipeline # "iff" # "J" # "implies" # "J" # "like" # "J" # NSM yystate := "m_conjunction" suspend \ SYMBOL("conjunction",[="&"]) | SYMBOL("conjunction",[="|"]) | SYMBOL("conjunction",[="j"]) | SYMBOL("conjunction",[="J"]) | SYMBOL("conjunction",[="~J"]) end # SYMBOL procedure m_sentence() #===================== # includes terminating semicolon (or ">" for HTML) # does NOT include brace # sentence ::= # SENTENCE # TOKEN("w","sentence") # html_statement # simple commands # kustatement # question # command # assignment # production # product := producer # control statement # control statement ::= # conditional # iteration # exit # group # group_begin # group_statement # ... # group_end static SENTENCE initial { SENTENCE := TOKEN("w","sentence") } yystate := "m_sentence" suspend \ #####m_html_statement() | # < HTML format control > SYMBOL("production", [m_product(),m_prodop(),m_producer()]) | # product := producer SYMBOL("assignment",m_assignment()) | # set variable = value m_conditional() | # if then else fi m_iteration() | # every while until SYMBOL("exit",m_exit()) | # exit break SYMBOL("command",m_command()) | # do with out od from to done #SYMBOL("production",m_production()) | # product := sentence #SYMBOL("question",m_question()) | # embedded "?" SYMBOL("statement",m_kustatement()) | # subject ... SYMBOL("grammar hint",match_token(SENTENCE)) | SYMBOL("begin",m_group_begin()) | # begin gtype gname ; SYMBOL("end",m_group_end()) # end gtype gname ; end #----------------------------------------------# # group # hierarchy,relation # triple,mcf,rdf,owl,... ##### Aug/10/2005 ##### back to my original strategy ##### process each group_statement immediately ###### list #####procedure m_group() ######================== #####yystate := "m_group" #####suspend \ ##### m_ho_group() | ##### m_nrel_group() | ##### m_owl_group() | ##### m_other_group() # must be last! ##### #m_group_begin() | ##### #m_group_end() #####end # list procedure m_group() #================== yystate := "m_group" suspend \ m_group_begin() | m_group_end() | m_group_statement() end # list procedure m_other_group() #======================== yystate := "m_other_group" suspend \ [ m_group_begin(), # begin gtype gname; m_gslist(), # group statement list m_group_end() # end gtype gname; ] end # GROUP procedure m_group_begin() #======================== # group_begin ::= # begin gtype gname ; # parsed with kformat=ku yystate := "m_group_begin" suspend \ GROUP("begin",[="Y",m_gtype(),m_phrase(),=";"]) end # GROUP procedure m_group_end() #====================== # Note: ";" is parsed at this level # group_end ::= # end gtype gname ; # parsed with kformat= ho|nrel|... yystate := "m_group_end" suspend \ GROUP("end",[="Z",m_gtype(),m_phrase(),=";"]) | # no context GROUP("end",[="W",="Z",m_gtype(),m_phrase(),=";"]) | # ho cnntext GROUP("end",[="X",="Z",m_gtype(),m_phrase(),=";"]) # nrel context end # string procedure m_gtype() #================== yystate := "m_gtype" suspend \ ="g" | # triple,mcf,... ="o" | # owl,rdf,,... ="h" | # hierarchy,unithierarchy,lattice ="r" | # relation ="w" # other word end # list procedure m_gslist() #=================== # gslist ::= # group_statement # group_statement gslist yystate := "m_gslist" suspend \ [m_group_statement()] | [m_group_statement()] ||| m_gslist() end # GROUP procedure m_group_statement() #============================ # group_statement ::= # m_html_statement() | # < HTML format control > # subject ; # allow null and nested list in relation yystate := "m_group_statement" suspend \ GROUP("ho", [m_ho_statement()]) | # no context GROUP("nrel",[m_nrel_statement()]) # no context end # list procedure m_owl_group() #======================== yystate := "m_owl_group" suspend \ [ m_owl_begin(), # begin gtype gname; m_ho_list(), # group statement list m_group_end() # end gtype gname; ] end # GROUP procedure m_owl_begin() #======================== # group_begin ::= # begin owl gname ; # parsed with kformat=ku yystate := "m_owl_begin" suspend \ GROUP("begin",[="Y",="o",m_phrase(),=";"]) end #===================================================================# #===================================================================# # hierarchy # KFORMAT == "ho" # SYMBOL("ho",svalue) #===================================================================# #===================================================================# ###### HOUNIT #####procedure m_hostatement(sep) ######=========================== ###### hostatement ::= ###### phraselist ; ###### In both cases, the first word indicates ###### hlevel by how many "/" or "\" it contains. ###### Note that it may contain zero. #####suspend \ ##### HOUNIT(m_subject(),=";") #####end # list procedure m_ho_group() #======================== yystate := "m_ho_group" suspend \ [ m_ho_begin(), # begin gtype gname; m_ho_list(), # group statement list m_group_end() # end gtype gname; ] end # GROUP procedure m_ho_begin() #======================== # group_begin ::= # begin hierarchy gname ; # parsed with kformat=ku yystate := "m_ho_begin" suspend \ GROUP("begin",[="Y",="h",m_phrase(),=";"]) end # list procedure m_ho_list() #==================== # ho_list ::= # ho_statement # ho_statement ho_list yystate := "m_ho_list" suspend \ [m_ho_statement()] | [m_ho_statement()] ||| m_ho_list() end # list procedure m_ho_statement() #========================= # ho_statement ::= # slash ho_phrase ; # ho_phrase ; yystate := "m_ho_statement" suspend \ ([m_slash(),m_ho_phrase(),=";"]) | ([m_ho_phrase(),=";"]) end # list procedure m_ho_phraselist() #========================== # used for relations # like phraselist, but null phrase permitted # ho_phraselist ::= # ho_phrase # ho_phrase , ho_phraselist static sep initial sep := RELSEPARATOR # "," yystate := "m_ho_phraselist" suspend \ ([m_ho_phrase()]) | ([m_ho_phrase(),=sep] ||| m_ho_phraselist()) end # PHRASE procedure m_ho_phrase() #======================= yystate := "m_ho_phrase" suspend \ PHRASE(m_hophrase()) end # list procedure m_hophrase() #===================== # hophrase ::= # howord # howord hophrase yystate := "m_hophrase" suspend \ ([m_howord()]) | ([m_howord()] ||| m_hophrase()) end # string procedure m_howord() #=================== # allow everything except "," and ";" # don't allow "[" "]" because of relword/howord confusion # but check in sentence.icn for # "end" ("Z") # "exit" ("z") # "break" ("z") static hoWordChar initial hoWordChar := &cset -- WhiteSpace -- ',;[]' -- '/\\' yystate := "m_howord" suspend \ tab(any(hoWordChar)) # word is single token end # string procedure m_slash() #================== yystate := "m_slash" suspend \ tab(any('/')) | tab(any('\\')) end #===================================================================# #===================================================================# # relation # KFORMAT == "nrel" # SYMBOL("nrel",svalue) #===================================================================# #===================================================================# ###### list #####procedure m_relstatement() ######========================= ###### relstatement ::= ###### phraselist ; #####static sep #####suspend \ ##### RELUNIT(m_subject(),=";") #####end ###### list #####procedure m_nreltuple() ######======================= ###### tuple ::= ###### rplist ###### rplist ; nreltuple #####static sep #####initial sep := ";" #####suspend \ ##### ([m_rplist(),=sep]) | ##### ([m_rplist(),=sep] ||| m_nreltuple()) #####end ###### list #####procedure m_rplist() ######=================== ###### comma-separated list of nrelphrase ###### rplist ::= ###### RELPHRASE ###### RELPHRASE , rplist #####static sep #####initial sep := "," #####suspend \ ##### [m_RELPHRASE()] | ##### [m_RELPHRASE(),=sep] ||| m_rplist() #####end ###### PHRASE #####procedure m_RELPHRASE() ######====================== #####suspend \ ##### PHRASE(m_nrelphrase()) #####end # list procedure m_nrel_group() #======================== yystate := "m_nrel_group" suspend \ [ m_nrel_begin(), # begin gtype gname; m_nrel_list(), # nrel tuple list m_group_end() # end gtype gname; ] end # GROUP procedure m_nrel_begin() #======================== # group_begin ::= # begin relation gname ; # parsed with kformat=ku yystate := "m_nrel_begin" suspend \ GROUP("begin",[="Y",="r",m_phrase(),=";"]) end # list procedure m_nrel_list() #===================== # gslist ::= # nrel_statement # nrel_statement nrel_list yystate := "m_nrel_list" suspend \ [m_nrel_statement()] | [m_nrel_statement()] ||| m_nrel_list() end # list procedure m_nrel_statement() #========================== # nrel_statement ::= # html_statement # nrel_phraselist ; yystate := "m_nrel_statement" suspend \ #####m_tml_statement() | ([m_nrel_phraselist(),=";"]) end # list procedure m_nrel_phraselist() #=========================== # used for relations # like phraselist, but null phrase & nested phrase permitted # nrel_phraselist ::= # nrel_phrase # nrel_phrase , nrel_phraselist static sep initial sep := RELSEPARATOR # "," yystate := "m_nrel_phraselist" suspend \ [m_nrel_phrase()] | ([m_nrel_phrase()] ||| [=sep] ||| m_nrel_phraselist()) end # BSE or PHRASE or list procedure m_nrel_phrase() #======================== # null phrase & nested phraselist permitted # nrel_phrase ::= # phrase # bracket # nested phraselist [nrelphrase, ...] # null # null phrase yystate := "m_nrel_phrase" suspend \ m_phrase() | # ordinary phrase m_bracket() | # nested phrase PHRASE([""]) # null phrase end # list procedure m_nrelphrase(B) #======================= # nrelphrase ::= # nrelword # nrelword nrelphrase yystate := "m_nrelphrase" suspend \ ([m_nrelword()]) | ([m_nrelword()] ||| m_nrelphrase()) end # string procedure m_nrelword() #==================== # allow everything except "," ";" "[" "]" # but check in sentence.icn for # "end" ("Z") # "exit" ("z") # "break" ("z") static nrelWordChar initial nrelWordChar := &cset -- WhiteSpace -- ',;[]' yystate := "m_nrelword" suspend \ tab(any(nrelWordChar)) # word is single token end #----------------------------------------------# #----------------------------------------------# #----------------------------------------------# # list procedure m_exit() #================= # exit; # exit KE # break; # exit every,while,until,when yystate := "m_exit" suspend \ [="z",=";"] end # SYMBOL procedure m_conditional() #======================== # conditional ::= # "if" proplist "then" proplist "else" proplist "fi;" # "if" proplist "then" proplist "fi;" # "if" proplist "else" proplist "fi;" # "if" proplist "fi;" # "either" brace "or" brace "or" ...; # "all" brace "and" brace "and" ...; yystate := "m_conditional" suspend \ SYMBOL("itef",[m_IF(),m_FI()]) end # SYMBOL procedure m_IF() #=============== yystate := "m_IF" suspend \ SYMBOL("if",[="I",m_proplist()]) #### SYMBOL("eitheror",[="Q",m_brace(),="j",m_brace(),=";"]) | #### SYMBOL("alland", [="Q",m_brace(),="j",m_brace(),=";"]) end # SYMBOL procedure m_FI() #=============== yystate := "m_FI" suspend \ SYMBOL("fi",[="F",=";"]) | SYMBOL("thenelse",[="T",m_proplist(),="E",m_proplist(),="F",=";"]) | SYMBOL("then",[="T",m_proplist(),="F",=";"]) | SYMBOL("else",[="E",m_proplist(),="F",=";"]) end # SYMBOL procedure m_iteration() #====================== # iteration ::= # "every" generator "{" proplist "};" # "while" proposition "{" proplist "};" # "until" proposition "{" proplist "};" # "when" proposition "{" proplist "};" <== NOT implemented # "forAll" generator "(" proplist "};" <== NOT implemented # "forSome" generator "(" proplist "};" <== NOT implemented # NOTE: generator ::= sentence yystate := "m_iteration" suspend \ SYMBOL("every",[ ="I",m_proposition(), m_brace(),=";" ]) | SYMBOL("every",[ ="G",m_generator(),m_brace(),=";" ]) end # SYMBOL procedure m_generator() #====================== # generator ::= # variable genverb object; # proposition format # variable pplist; # qualified variable # pplist ::= # from initial to final # is integer from ... to ... # of gdbmtable # is index of array yystate := "m_generator" suspend \ SYMBOL("generator",[m_subject(),m_pplist(),=";"]) | SYMBOL("generator",[m_subject(),m_genverb(),m_object(),=";"]) end #------------------------------------------------------------------- # list procedure m_assignment() #======================= # "set nvobject" literally means "ke has nvobject" # assignment ::= # set nvobject # vset nvobject # all views # unset nvobject # return nvobject yystate := "m_assignment" suspend \ SYMBOL("assign",[="S",m_nvobject(),=";"]) end # string procedure m_nvop() #================= # for get_symbol() # nvop ::= # = | += | -= | *= yystate := "m_nvop" suspend \ ="=" end # SYMBOL or string procedure m_value() #================== # value ::= # angle <htxt> RDF-style comment # phrase includes quotes # bracket set hfocus = [concept, ...] # brace x has meaning = { proplist } for method,relation # ? set parameter = ? <= NO - in qword yystate := "m_value" suspend \ #####m_html_statement() | SYMBOL("angle",m_ANGLE()) | m_bracket() | m_brace() | m_phrase() end # string procedure m_kedo() #================= # kedo ::= # "do" # ke do command pplist done # "!" # sh do command pplist done yystate := "m_kedo" suspend \ ="D" | ="!" end # SYMBOL procedure m_command() #==================== # command ::= # do cmdlist done; # do cmdlist pplist done; # do diverb pplist done; # isd,isi # vdo exec od {proposition list} done; # do ::= # do # current view # vdo # all views # ! # sh command # # "do command ... done;" # literally means "ke do command ... done;" # # NOTE: # relation,hierarchy blocks are # control structures not commands yystate := "m_command" suspend \ #SYMBOL("Dcd",[m_do(),m_brace(),m_done()]) | #SYMBOL("Dcd",[m_do(),m_proplist(),m_done()]) | SYMBOL("Dcd",[m_do(),m_nvobject(),m_done()]) | SYMBOL("Dcpd",[m_do(),[="i"],m_pplist(),m_done()]) | SYMBOL("Dcpd",[m_do(),m_nvobject(),m_pplist(),m_done()]) end # SYMBOL procedure m_kustatement() #======================== # Feb/25/2007 # subject HAS verbphrase list; # Mar/28/2003 consider using nvobject for all objects # (old objects will be nvnulllist) # kustatement ::= # subject exists; # existence # subject is object; # identity # subject is object pplist; # definition # subject nrel nvobject; # n-ary relation # subject trel nvobject; # ternary relation # subject brel nvobject; # binary relation # subject urel nvobject; # unary relation # subject has nvobject; # attribute # subject do nvobject done; # action # subject do nvobject pplist done; # action # subject rel relverb object, ... ; # binary relation # subject relverb object; # binary relation # subject haspart partlist; # part # partlist isapart object; # part # verb verb verb; # verb properties # relverb ::= # isa isa* isa**n iss iss* isu isu* # isc isc* isc**n isg isg* isp isp* # isd isi # nrel trel brel urel # "L" # causes because # "R" # isapart haspart # "H" # ... # pplist ::= # NULL # pp # pp pplist # pp ::= # prep nvlist # prep {proposition list} # prep ::= # of # with # out # od # from # to yystate := "m_kustatement" suspend \ #SYMBOL("sHvp", [m_subject(),m_HASverb(),m_vplist(),=";"]) | SYMBOL("sHvp", [m_subject(),m_HASverb(),m_verbphrase(),=";"]) | #SYMBOL("sHvp", [m_subject(),m_HASverb(),m_relobjlist(),=";"])| SYMBOL("se", [m_subject(),="e",=";"]) | SYMBOL("sIop", [m_subject(),m_isverb(), m_object(),m_pplist(),=";"]) | SYMBOL("sIo", [m_subject(),m_isverb(), m_object(),=";"]) | SYMBOL("sHap", [m_subject(),m_hasverb(),m_nvobject(),m_pplist(),=";"])| SYMBOL("sHa", [m_subject(),m_hasverb(),m_nvobject(),=";"]) | #SYMBOL("spo", [m_partlist(),m_partverb(),m_partlist(),=";"]) | SYMBOL("sDapd",[m_subject(),m_doverb(), m_nvobject(),m_pplist(),m_done()]) | SYMBOL("sDad", [m_subject(),m_doverb(), m_nvobject(),m_done()]) | ##SYMBOL("sLRo", [m_subject(),m_rel(),m_voobject(),=";"]) | SYMBOL("sLo", [m_subject(),m_rel(),m_relobjlist(),=";"]) | SYMBOL("sRo", [m_subject(),m_relverb(),m_nvobject(),=";"]) | SYMBOL("vvv", [m_verb(),m_verb(),m_verb(),=";"]) | SYMBOL("vvv", [m_verb(),m_verb(),m_phrase(),=";"]) | SYMBOL("vvv", [m_phrase(),m_verb(),m_verb(),=";"]) end # list procedure m_vplist() #====================== yystate := "m_vplist" suspend \ [m_verbphrase()] | [m_verbphrase(),=","] ||| m_vplist() end # SYMBOL procedure m_verbphrase() #======================= yystate := "m_verbphrase" suspend \ #SYMBOL("verbphrase",[m_relverb(),m_relobject()]) | SYMBOL("Iop", [m_isverb(),m_object(),m_pplist(),=";"]) | SYMBOL("Io", [m_isverb(),m_object(),=";"]) | SYMBOL("Hap", [m_hasverb(),m_nvobject(),m_pplist(),=";"]) | SYMBOL("Ha", [m_hasverb(),m_nvobject(),=";"]) | #SYMBOL("po", [m_partverb(),m_partlist(),=";"]) | SYMBOL("Dapd", [m_doverb(),m_nvobject(),m_pplist(),m_done()]) | SYMBOL("Dad", [m_doverb(),m_nvobject(),m_done()]) | ##SYMBOL("LRo",[m_rel(),m_voobject(),=";"]) | SYMBOL("Lo", [m_rel(),m_relobjlist(),=";"]) | SYMBOL("Ro", [m_relverb(),m_nvobject(),=";"]) end # string procedure m_rel() #================ # m_rel ::= rel # urel | brel | trel | nrel # <= delete ??? yystate := "m_rel" suspend \ ="L" end # list procedure m_relobjlist() #====================== yystate := "m_relobjlist" suspend \ [m_relobject()] | [m_relobject(),=","] ||| m_relobjlist() end # SYMBOL procedure m_relobject() #===================== # relobject ::= nvphrase # vophrase yystate := "m_relobject" suspend \ m_vophrase() | m_nvphrase() end # VOPHRASE procedure m_vophrase() #===================== yystate := "m_vophrase" suspend \ new_vophrase([m_relverb(), m_phrase()]) | new_vophrase([m_relverb(), m_relverb()]) end # SYMBOL procedure m_question() #===================== # question ::= # assignment qassignment (internal "?") # command qcommand (internal "?") # statement qstatement (internal "?") # if statement fi; qstm # statement "?" qstm <<<=== OBSOLETE !!! yystate := "m_question" suspend \ SYMBOL("qstm",[m_kustatement(),m_qmark()]) end #=================================================================== #=================================================================== #=================================================================== # basic stuff: # pvalue # only excludes is,has,do,... # qword # includes quote # nvphrase, nvlist # prepphrase, pplist # partphrase, partlist # htmlword, html_phrase, html_command, html_group # # qword isa string # nvphrase isa SYMBOL; nvlist isa list # prepphrase isa SYMBOL; PPLIST isa list; pplist isa SYMBOL # partphrase isa SYMBOL; partlist isa list # htmlword isa string # HTMLPHRASE isa list; html_phrase isa list ################ Mar/6/2003 new simple phrase definition ################### # list procedure m_phraselist(sep) #========================== # phraselist ::= # phrase # phrase , phraselist /sep := ListSeparator # default "," set by init_word() in token.icn yystate := "m_phraselist" suspend \ ([m_phrase()]) | ([m_phrase(),=sep] ||| m_phraselist()) end # PHRASE procedure m_phrase() #=================== # phrase ::= # lphrase # "" # <<== do NOT like this # use lphrase not sphrase # NOTE: sphrase isa string (token.icn) # lphrase isa list (symbol.icn) yystate := "m_lphase" suspend \ PHRASE(m_lphrase()) # | # blank-separated words # PHRASE(="") # null string (for relations) end # list procedure m_lphrase() #==================== # do NOT use pword # allow and,or,not # phrase ::= # qword # qword lphrase # yystate := "m_lphrase" suspend \ ([m_qword()]) | ([m_qword()] ||| m_lphrase()) end ################ Mar/6/2003 new simple phrase definition ################### ################ Aug/13/2005 begin variable arrays ################### # list procedure m_aaphrase() #===================== # name[char][i] syntax for concept characteristics # (associative array notation) yystate := "m_aaphrase" suspend \ [AAPHRASE(m_phrase(),m_index_list())] end # list procedure m_arrayval() #===================== # con[char][i] := arrayval; # arrayval ::= # phrase ; yystate := "m_arrayval" suspend \ ###SYMBOL("arrayval", [m_bracket(),=";"]) | # con[char] := [phraselist] [m_phrase(),=";"] # con[char][i] := phrase end # list procedure m_arrayref() #===================== # value := con[char][i]; # arrayref ::= # aaphrase ; yystate := "m_arrayref" suspend \ #SYMBOL("arrayref",[m_phrase(),m_index(),=";"]) [m_aaphrase(),=";"] end # list procedure m_arrayset() #===================== # con[char][i] := value; # arrayset ::= # aaphrase yystate := "m_arrayset" suspend \ #SYMBOL("arrayset",[m_phrase(),m_index()]) [m_aaphrase()] end # SYMBOL procedure m_variable() #===================== # variable ::= # name # name[i] # aaphrase yystate := "m_variable" suspend \ #SYMBOL("arrayref",[m_qword(),m_index()]) | #SYMBOL("variable",m_qword()) SYMBOL("variable",m_aaphrase()) | SYMBOL("variable",m_phrase()) end # list procedure m_index_list() #======================= # index_list ::= # index # index index_list yystate := "m_index_list" suspend \ [m_index()] | [m_index()] ||| m_index_list() end # SYMBOL procedure m_index() #================== # index ::= [char] # serious problem: BSE "unparses" index -- when,how ??? # I need to go back and try BSE again # problem seems to be -- must wrap list around record when parsing yystate := "m_index" suspend \ SYMBOL("index",[="[",m_phraselist(),="]"]) | SYMBOL("index",[="[[",m_phraselist(),="]]"]) ###SYMBOL("index",m_bracket()) ###SYMBOL("index",m_BSE(",",="[",m_phraselist(),="]")) end ################ Aug/13/2005 end variable arrays ################### # list procedure m_nvlist() #=================== # nvlist ::= # nvphrase # nvphrase sep nvlist static sep initial sep := "," yystate := "m_nvlist" suspend \ ( [m_nvphrase()] ) | ( [m_nvphrase()] ||| [=sep] ||| m_nvlist() ) end # list procedure m_nvphrase_list() #========================== # sep ::= " " yystate := "m_nvphrase_list" suspend \ [m_nvphrase()] | [m_nvphrase()] ||| m_nvphrase_list() end # NVPHRASE procedure m_nvphrase() #===================== # nvphrase ::= # variable nvop value # variable yystate := "m_nvphrase" suspend \ NVPHRASE("nv",[m_phrase(),m_nvop(),m_value()]) | NVPHRASE("nvnull",[m_phrase()]) end #------------------------------------------------------------------- #------------------------------------------------------------------- # word phrase # string procedure m_qword() #================== # excludes most MKR special words (is,has,do, ...) # # qword ::= # e exists # C rdfs:Class # p rdf:Property # $ dollar variable <== not separator # / hierarchy <== not separator # . dot variable <== not separator # ? form-based question <== not separator # Q quantifier (check semantics later) # w includes quotes # x includes +-*: # A at <== OK only required at beginning of proposition # g group: hierarchy, relation, etc. # S set,vset,unset # s t v space,time,view # h r m hierarchy,relation,method # u unit # paren ( ... ) # angle <...> # hlist qword HTML command # + - * arithmetic operator # & | ~ logical operator (not used for logic) # j and,or # N not,non yystate := "m_qword" suspend \ ="C" | # rdfs:Class ="p" | # rdf:Property #m_dollarword() | # includes embedded separator form ${w} ="$" | # not separator ="/" | # not separator, but distinguish use in HTML #="." | # not separator ="+" | # arithmetic operator ="-" | # arithmetic operator ="*" | # arithmetic operator ="&" | # logical operator ="|" | # logical operator ="~" | # logical operator #m_PAREN() | # not separator (...) #m_ANGLE() | # <...> ="Q" | # quantifiers: a,some,the,any,all,either, no ="j" | # conjunctions: and,or ="N" | # complements: not,non ="?" | # question variable ="w" | # ordinary words (includes quotes "..." and '...') ="x" | # extended words (includes +-*:) #="A" | # at ="g" | # group type: ntuple,mcf,rdf,... ="o" | # group type: owl,rdf,... #="S" | # set,vset,unset,return #="h" | # HTML command ="e" | # exists ="s" | # space ="t" | # time ="v" | # view ="h" | # hierarchy,unithierarchy,lattice ="r" | # relation ="B" | # BinaryRelation ="m" | # method ="u" # unit end # string procedure m_dollarword() #======================= yystate := "m_dollarword" suspend \ ="$"||m_qword() | ="$"||="{"||m_qword()||"}"||m_qword() | ="$"||="{"||m_qword()||"}" end # string procedure m_dword() #================== yystate := "m_dword" suspend \ m_qword() | m_dollarword() end procedure m_pword() #================== # exclude all MKR special words static pvalue initial pvalue := &cset -- SEPARATOR -- 'iR' -- # is,isa,iss,isu,isd,... 'HpS' -- # has,haspart,nrel,set,unset,return 'Dd' -- # do,done 'AP' -- # at,out,of,with,od,from,to 'ITEF' -- # if,then,else,fi 'G' -- # every,when,while 'C' -- # causes 'YZ' -- # begin,end 'z' # exit,break yystate := "m_pword" suspend \ any(pvalue) end #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- # preposition phrase # SYMBOL procedure m_pplist() #=================== # important to use SYMBOL for blank-separated list # pplist ::= # prepphrase # prepphrase pplist yystate := "m_pplist" suspend \ SYMBOL("pplist",m_PPLIST()) end # list procedure m_PPLIST() #=================== # important to use SYMBOL for blank-separated list # pplist ::= # prepphrase # prepphrase pplist yystate := "m_PPLIST" suspend \ ( [m_prepphrase()] ) | ( [m_prepphrase()] ||| m_PPLIST() ) end # SYMBOL procedure m_prepphrase() #======================= # NOTE: "at" nvlist is context, not prepphrase # NOTE: allow prep {proposition list} # e.g.: they do say od {...} done # e.g.: do delete od {sentence} done # prepphrase ::= # prep {proplist} # prep nvobject # prep ::= "of" | "with" | "out" | "od" | "from" | "to" # "in" yystate := "m_prepphrase" suspend \ SYMBOL("pp",[[="P"],m_brace()]) | SYMBOL("pp",[[="P"],m_nvobject()]) end #------------------------------------------------------------------- # part phrase # list procedure m_partlist() #===================== # partlist ::= # partphrase # partphrase sep partlist static sep initial sep := "," yystate := "m_partlist" suspend \ #####( [m_partphrase()] ) | #####( [m_partphrase(),=sep]||| m_partlist() ) m_nvobject() end # SYMBOL procedure m_partphrase() #======================= # partphrase ::= # qphrase # qphrase prep qphrase yystate := "m_partphrase" suspend \ SYMBOL("partpp",[m_phrase(),="P",m_phrase()]) | SYMBOL("part", [m_phrase()]) end ###### string #####procedure m_PARTPHRASE() ######======================= ###### important to use SYMBOL for blank-separated phrase ###### insert blank between words ###### requires special treatment in map_symbol() count ###### partphrase ::= ###### qphrase ###### qphrase prep qphrase #####static psep #####initial psep := dequote(PSEPARATOR) # blank #####suspend \ ##### (m_QPHRASE()||psep||="P"||psep||m_QPHRASE()) | ##### (m_QPHRASE()) #####end #=================================================================== #=================================================================== #=================================================================== # basic stuff: # bracket, brace, angle, paren # # bracket: [phrase, ...] # brace: {proposition; ...} # angle: <HTML command> # paren: (anything) # SYMBOL procedure m_bracket() #==================== # bracket ::= # [ phraselist ] # [ nvphrase_list ] # [ ] static sep,size initial { sep := "," size := 0 } yystate := "m_bracket" suspend \ #SYMBOL("bracket",[ ="[", m_phraselist(), ="]"]) #SYMBOL("bracket",m_BSE(",",="[",m_phraselist(),="]")) m_BSE(",",="[",m_phraselist(),="]") | m_BSE(",",="[",m_nvphrase_list(),="]") | m_BSE(",",="[",[],="]") end # SYMBOL procedure m_brace() #================== # brace ::= # { proplist } # { } yystate := "m_brace" suspend \ #SYMBOL("brace",[ ="{", m_proplist(), ="}" ]) #SYMBOL("brace",m_BSE(" ",="{",m_proplist(),="}")) m_BSE(" ",="{",[m_proplist()],="}") | m_BSE(" ",="{",[],="}") end # SYMBOL procedure m_notbrace() #===================== # notbrace ::= "not" brace yystate := "m_notbrace" suspend \ SYMBOL("notbrace",[="N",m_brace()]) end # SYMBOL procedure m_ANGLE() #================== # angle ::= # < htxt > # RDF-style comment # < phraselist > # < html_phrase > yystate := "m_ANGLE" suspend \ SYMBOL("angle",[="<",m_HTXT(),=">"]) | ###m_BSE(" ",[="<",m_HTXT(),=">"]) | (="a") | (="<>") | m_BSE(" ",="<",[m_htxt()],=">") | m_BSE(" ",="<",[],=">") #SYMBOL("angle",[="<",m_htxt(),=">"]) | #SYMBOL("angle",m_html_statement()) ###SYMBOL("angle",[="<",m_phraselist(),=">"]) | ###SYMBOL("angle",[="<",m_HTMLPHRASE(),=">"]) | # m_html_phrase() ??? ###SYMBOL("angle",[="<",[],=">"]) end ##### SYMBOL ####procedure m_paren() #####================== ##### paren ::= ( phraselist ) ####yystate := "m_paren" ####suspend \ #### SYMBOL("paren",[="(",m_phraselist(),=")"]) ####end #=================================================================== #=================================================================== #=================================================================== # basic stuff: # subject, verb, object # SYMBOL # list procedure m_production() #======================= # production ::= # product := producer yystate := "m_production" suspend \ [m_product(),m_prodop(),m_producer()] end # SYMBOL procedure m_product() #==================== # product ::= # arrayset # phrase # phrase pplist # permit x of y yystate := "m_product" suspend \ SYMBOL("product",SYMBOL("arrayset",m_arrayset())) | SYMBOL("product",SYMBOL("phrase",m_phrase())) | SYMBOL("product",SYMBOL("phrase_pplist",[m_phrase(),m_pplist()])) end # string procedure m_prodop() #=================== # for get_symbol() # prodop ::= # := # +:= # -:= # *:= yystate := "m_prodop" suspend \ ="+V" | ="-V" | ="*V" | ="V" end # SYMBOL procedure m_producer() #===================== # also used for named propositions # NOTE: includes ";" # producer ::= # sentence # aaphrase # phrase # proposition (for named proposition) # context (for named proposition) yystate := "m_producer" suspend \ SYMBOL("producer",SYMBOL("sentence",[m_sentence()])) | SYMBOL("producer",SYMBOL("context",[m_context(),=";"])) | SYMBOL("producer",SYMBOL("arrayref",[m_arrayref()])) | SYMBOL("producer",SYMBOL("arrayval",[m_arrayval()])) | SYMBOL("producer",SYMBOL("proposition",[m_proposition()])) end # SYMBOL procedure m_subject() #==================== # brackets permitted # verb etc. permitted # subject ::= # phrase pplist # phraselist # includes and,or,not # bselist # [phraselist] or {propositionlist} # bracket # [phraselist] # brace # {propositionlist} # angle # <anything> # partlist # includes preposition # variable static sep initial sep := "" yystate := "m_subject" suspend \ SYMBOL("subject",m_bracket()) | SYMBOL("subject",m_brace()) | SYMBOL("subject",m_ANGLE()) | SYMBOL("subject",m_phraselist()) | SYMBOL("subject",SYMBOL("phrase_pplist",[m_phrase(),m_pplist()])) | SYMBOL("subject",[m_variable()]) | SYMBOL("subject",[m_relverb()]) | # cyc verb SYMBOL("subject",[="G"]) | # cyc forall SYMBOL("subject",[="Q"]) # cyc Quantifier end # string procedure m_qmark() #================== yystate := "m_qmark" suspend \ ="?" end ###### string #####procedure m_cmdname() ######==================== ###### cmdname ::= ###### wplist ###### isverb #####suspend \ ##### SYMBOL("cmdname",m_wplist()) | # stype = "w" ##### m_isverb() # stype = "is" # isd, isi #####end # SYMBOL procedure m_object() #=================== # brackets permitted # object ::= # bracket # [phraselist] # brace # {propositionlist} # angle # <anything> # phraselist # variable static sep initial sep := "," yystate := "m_object" suspend \ SYMBOL("object",m_bracket()) | SYMBOL("object",m_brace()) | SYMBOL("object",m_ANGLE()) | SYMBOL("object",m_phraselist()) | SYMBOL("object",[m_variable()]) | SYMBOL("object",[m_relverb()]) | # cyc verb SYMBOL("object",[="G"]) | # cyc forall SYMBOL("subject",[="Q"]) # cyc Quantifier end # SYMBOL procedure m_nvobject() #===================== # brackets permitted # nvobject ::= # nvlist # bracket # [nvlist] # brace # {propositionlist} # angle # <anything> static sep initial sep := "," yystate := "m_nvobject" suspend \ SYMBOL("nvobject",m_bracket())| SYMBOL("nvobject",m_brace()) | SYMBOL("nvobject",m_ANGLE()) | SYMBOL("nvobject",m_nvlist()) end ###### list #####procedure m_genobject() ######====================== ###### genobject ::= ###### phraselist ###### bracket # <== includes empty list inside brackets #####suspend \ ##### m_phraselist() | ##### m_bracket() #####end ###### list procedure m_cmdobject() #====================== # cmdobject ::= # phraselist yystate := "m_cmdobject" suspend \ m_phraselist() end # SYMBOL procedure m_verb() #================= #####static VERBhint initial { VERBhint := TOKEN("R","verb") } yystate := "m_verb" suspend \ m_isverb() | m_doverb() | m_hasverb() | m_HASverb() | m_relverb() | m_hop() | SYMBOL("grammar hint",match_token(VERBhint)) end # SYMBOL procedure m_isverb() #=================== # isverb ::= # is | isa | isu # isd | isi # not isverb yystate := "m_isverb" suspend \ SYMBOL("verb",="Ni") | SYMBOL("verb",="i") end # SYMBOL procedure m_hasverb() #==================== # hasverb ::= # "has" | "haspart" | "nrel"|"trel"|"brel"|"urel" # not hasverb yystate := "m_hasverb" suspend \ SYMBOL("verb",="NH") | SYMBOL("verb",="H") end # SYMBOL procedure m_HASverb() #==================== # hasverb ::= "HAS" yystate := "m_HASverb" suspend \ SYMBOL("verb",="l") end # SYMBOL procedure m_doverb() #=================== # doverb ::= # "do" | "can" | "hdo" | "vdo" | "ido" # x do action pplist done # not doverb # "!" # sh do command pplist done yystate := "m_doverb" suspend \ SYMBOL("verb",="ND") | SYMBOL("verb",="D") | SYMBOL("verb",="!") end # SYMBOL procedure m_relverb() #==================== # relverb ::= # hop # "not" hop # binaryrelation # "causes" # conj # ? #####static VERBhint initial { VERBhint := TOKEN("R","verb") } yystate := "m_relverb" suspend \ SYMBOL("verb",="N"||m_hop()) | SYMBOL("verb",m_hop()) | SYMBOL("verb",="B") | SYMBOL("verb",="C") | SYMBOL("verb",="J") | SYMBOL("verb",="j") | SYMBOL("verb",="~J") | SYMBOL("verb",m_qmark()) | SYMBOL("grammar hint",match_token(VERBhint)) end # SYMBOL procedure m_genverb() #==================== # subject genverb object # verb ::= "isa"|"isu" | "ismem"|"isalt" | "nrel"|"trel"|"brel"|"urel" #####static VERBhint initial { VERBhint := TOKEN("R","verb") } yystate := "m_genverb" suspend \ SYMBOL("verb",="i") | SYMBOL("verb",="R") | SYMBOL("verb",="H") | # nrel SYMBOL("grammar hint",match_token(VERBhint)) end ###### SYMBOL #####procedure m_partverb() ######===================== ###### partverb ::= haspart | isapart #####suspend \ ##### SYMBOL("verb",="H") #####end #------------------------------------------------------------------- # string procedure m_hop() #================ # hierarchy verbs # hop ::= # "RG" e.g. "is either","is all","is any" <<== NO !!! # "RQ" e.g. "is a","is some","is the","is no" <<== NO !!! # "lw" e.g. "isa**n" # "l?" e.g. "isa**?" # "R" e.g. "isa*","isa+", "isc", ... # "R" e.g. "ismem","isall", ... # "R" e.g. "isalt","isany", ... # "i" e.g. "is","isd","isi","isa","isu" yystate := "m_hop" suspend \ ="R" | ="lw" | ="l?" | ="i" end #------------------------------------------------------------------- # string procedure m_do() #=============== # NO optional ";" before "do" # do ::= # do # action # can # "power" to do action # hdo # hierarchy walk # vdo # all views # ido # interaction # ! # sh command # out product do yystate := "m_do" suspend \ ="D" | ="!" | m_pplist() || m_do() end # string procedure m_done() #================= # NO optional ";" before "done" yystate := "m_done" suspend \ ="d;" end # string procedure m_then() #================= # NO optional ";" before "then" yystate := "m_then" suspend \ ="T" end # string procedure m_else() #================= # NO optional ";" before "else" yystate := "m_else" suspend \ ="E" end # string procedure m_fi() #================= # NO optional ";" before "fi" yystate := "m_fi" suspend \ ="F;" end #===================================================================# #===================================================================# # HTML command # html_command ::= <htag harg> | <htag> # html_group ::= htxt </htag> #===================================================================# #===================================================================# # new simple code # SYMBOL procedure m_xml_version() #======================== # <?xml version="1.0" encoding="UTF-8"?> yystate := "m_xml_version" suspend \ SYMBOL("xml_version",[ ="<?", ="w=",m_qword(), ="w=",m_qword(), ="?>"]) end # SYMBOL procedure m_rdf_namespace() #========================== # <rdf:RDF n=v ... > yystate := "m_rdf_namespace" suspend \ SYMBOL("rdf_namespace",[ ="<w", m_harg(), =">"]) end # SYMBOL procedure m_rdf_end() #==================== # </rdf:RDF> # NOTE: / is not SEPARATOR yystate := "m_rdf_end" suspend \ SYMBOL("rdf_end",[="<",="/",="w",=">"]) end ###### list #####procedure m_namespace_list() ######=========================== #####yystate := "m_namespace_list" #####suspend \ ##### [m_namespace()] | ##### [m_namespace()] ||| m_namespace_list() #####end ##### ###### NVPHRASE #####procedure m_namespace() ######====================== #####yystate := "m_namespace" #####suspend \ ##### NVPHRASE("nv",[="w",="=",m_qword()]) #####end # SYMBOL procedure m_xml_doctype() #======================== # <!DOCTYPE name [ entity_list ]> yystate := "m_xml_doctype" suspend \ SYMBOL("DOCTYPE",[="<",="M",m_qword(), ="[",m_xml_entity_list(),="]", ###m_BSE(" ",="[",m_xml_entity_list(),="]"), =">"]) end # list procedure m_xml_entity_list() #============================ yystate := "m_xml_entity_list" suspend \ [m_xml_entity()] | [m_xml_entity()] ||| m_xml_entity_list() end # SYMBOL procedure m_xml_entity() #======================= # <!ENTITY name uri> yystate := "m_xml_entity" suspend \ SYMBOL("ENTITY",[="<",="M",m_qword(),m_qword(),=">"]) end ###### SYMBOL #####procedure m_htmlone() ######==================== ###### one line only -- MKR format control ###### htmlone ::= ###### html_command ###### html_group ###### html_text html_command #####suspend \ ##### SYMBOL("htmlone",m_html_command()) | ##### SYMBOL("htmlone",m_html_group()) | ##### SYMBOL("htmlone",[m_html_text(),m_html_command()]) #####end # SYMBOL procedure m_html_statement() #========================== # first: low-level parse # then: check for completion (is_html_complete()) # html_statement ::= # html_simple # html_compound # html_text # html_comment # components # html_command # html_end # html_list # htxt # assignment # set kformat=ku; yystate := "m_html_statement" suspend \ SYMBOL("html_comment",m_html_comment()) | #  SYMBOL("html_statement",m_html_simple()) | # <t n=v /} SYMBOL("html_statement",m_html_text()) | # <t n=v> text </t> SYMBOL("html_statement",m_html_compound()) #| # <t n=v> <> ... </t> # intermediate stage HTML processing #SYMBOL("html_statement",m_html_command()) | # <t n=v> #SYMBOL("html_statement",m_html_end()) #| # </t> #SYMBOL("html_statement",m_html_tgroup()) #| # text </t> ##SYMBOL("html_statement",m_html_group()) #| # text </t> ##SYMBOL("assignment",m_assignment()) end # SYMBOL procedure m_html_comment() #========================= # html_comment ::= #  yystate := "m_html_comment" suspend \ SYMBOL("html_comment",[=""]) end # SYMBOL procedure m_html_simple() #======================== # "/" not in htmlword # Note: blank required before "/" ??? yystate := "m_html_simple" suspend \ SYMBOL("html_simple",[="<",m_htag(),m_harg(),="/>"]) | SYMBOL("html_simple",[="<",m_htag(),="/>"]) end # SYMBOL procedure m_html_compound() #========================== # html_compound ::= # html_command html_list html_end # html_command html_end (equiv. to html_simple) yystate := "m_html_compound" suspend \ SYMBOL("html_compound",[m_html_command(),m_html_list(),m_html_end()]) | SYMBOL("html_compound",[m_html_command(),[],m_html_end()]) end # SYMBOL procedure m_html_text() #====================== # html_text ::= # html_command htxt html_end # html_command html_end (equiv. to html_simple) yystate := "m_html_text" suspend \ SYMBOL("html_text",[m_html_command(),m_htxt(),m_html_end()]) | SYMBOL("html_null",[m_html_command(),m_html_end()]) end # SYMBOL procedure m_html_command() #========================= # "/" not in htmlword # html_command ::= # < htag > # < htag harg > yystate := "m_html_command" suspend \ SYMBOL("html_command",[="<",m_htag(),m_harg(),=">"]) | SYMBOL("html_command",[="<",m_htag(),=">"]) end # SYMBOL procedure m_html_end() #===================== # "/" not in htmlword yystate := "m_html_end" suspend \ ###SYMBOL("html_end",[="<",m_htag(),=">"]) SYMBOL("html_end",[="</",m_htag(),=">"]) end # list procedure m_html_list() #====================== # html_list ::= # html_statement # html_statement html_list yystate := m_html_list suspend \ [m_html_statement()] | [m_html_statement()] ||| m_html_list() end #--------------------------------------------# # new code # for some reason -- no longer true # nvphrase_list works # html_nvlist does not work # SYMBOL procedure m_harg() #================= # blank separated nvphrase list yystate := "m_harg" suspend \ SYMBOL("harg",m_html_nvlist()) #####SYMBOL("harg",m_html_nvlist()) end # SYMBOL procedure m_htxt() #================= # htxt ::= html_phrase static htmlTextChar initial htmlTextChar := &cset -- '<>' yystate := "m_htxt" suspend \ SYMBOL("htxt",[tab(many(htmlTextChar))]) end # list procedure m_HTXT() #================= # htxt ::= html_phrase # possible limit on lenth of tab(many()) ??? static htmlTextChar initial htmlTextChar := &cset -- '<>' yystate := "m_HTXT" suspend \ [m_htxt()] | [m_htxt()] ||| m_HTXT() end # SYMBOL procedure m_htag() #================= yystate := "m_htag" suspend \ SYMBOL("htag",m_htmlword()) end # string procedure m_htmlword() #===================== # "/" not in htmlword static htmlWordChar initial htmlWordChar := &letters yystate := "m_htmlword" suspend \ tab(any(htmlWordChar)) # single token end # list procedure m_html_nvlist() #======================== # blank-separated nvphrase list yystate := "m_html_nvlist" suspend \ [m_html_nvphrase()] | [m_html_nvphrase()] ||| m_html_nvlist() end # NVPHRASE procedure m_html_nvphrase() #======================== yystate := "m_html_nvphrase" suspend \ NVPHRASE("nv",[m_htmlword(),="=",m_htmlword()]) end #--------------------------------------------# #--------------------------------------------# # old code # based on ">" trigger for invoking get_symbol() #####procedure m_html_body() ######====================== ###### html_body ::= ###### htxt ###### html_list #####yystate := m_html_body #####suspend \ ##### SYMBOL("html_text",m_htxt()) | ##### SYMBOL("html_list",m_html_list()) #####end ###### SYMBOL #####procedure m_htag() ######================= #####yystate := "m_htag" #####suspend \ ##### SYMBOL("htag",m_htmlword()) ##### #####SYMBOL("htag",m_qword()) #####end ###### SYMBOL #####procedure m_hend() ######================= #####yystate := "m_hend" #####suspend \ ##### SYMBOL("hend",="/"||m_htmlword()) ##### #####SYMBOL("hend",m_qword()) #####end ###### PHRASE #####procedure m_htmlphrase() ######======================= ###### htmlWordChar ::= &cset -- '<=>' # -- "/" #####yystate := "m_htmlphrase" #####suspend \ ##### PHRASE(string2charlist(tab(many(htmlWordChar)))) # many tokens ##### ##PHRASE([tab(many(htmlWordChar))]) # many tokens #####end ###### list #####procedure m_HTMLPHRASE() ######======================= ###### html_phrase ::= ###### htmltag ###### htmltag nvphraselist #####static sep #####initial sep := dequote(PSEPARATOR) # blank #####yystate := "m_HTMLPHRASE" #####suspend \ ##### ( [m_htag()] ) | ##### ( [m_htag()] ||| m_nvphrase_list() ) #####end ###### string #####procedure m_slashword() ######====================== ###### word beginning with "/" #####suspend \ ##### ="/"||m_htmlword() #####end ##### ###### string #####procedure m_wordslash() ######====================== ###### word ending with "/" #####suspend \ ##### m_htmlword()||="/" #####end ##### ###### SYMBOL #####procedure m_html_group() ######======================= ###### based on ">" trigger for invoking get_symbol() ###### NOTE: hend includes leading "/" ###### html_group ::= ###### htxt hend #####yystate := "m_html_group" #####suspend \ ##### #####SYMBOL("html_group",[m_htxt(),m_html_end()]) ##### SYMBOL("html_group",m_html_GROUP()) #####end ##### ###### list #####procedure m_html_GROUP() ######======================= ###### based on ">" trigger for invoking get_symbol() ###### NOTE: hend includes leading "/" ###### don't allow null htxt ###### html_group ::= ###### htxt hend #####yystate := "m_html_GROUP" #####suspend \ ##### SYMBOL("html_group",[m_htxt(),m_html_end()]) ##### #####[m_qword(),m_html_end()] | ##### #####[m_qword()] ||| m_html_GROUP() #####end ##### ###### SYMBOL #####procedure m_html_tgroup() ######======================== ###### html_group ::= ###### html_text </htag> #####static TextChar #####initial TextChar := &cset -- '<>' # -- '=' #####yystate := "m_html_tgroup" #####suspend \ ##### SYMBOL("html_tgroup", ##### #####[tab(many(htmlWordChar)),="<",="/",tab(any(htmlWordChar)),=">"]) ##### #####[tab(many(htmlWordChar)),="</",tab(any(htmlWordChar)),=">"]) ##### [m_htxt(),m_html_end()]) ##### #####[tab(many(TextChar)),="</",tab(any(TextChar)),=">"]) ##### #####[tab(many(TextChar)),="<",="/",tab(any(TextChar)),=">"]) ##### #####[tab(many(m_qword())),="</",tab(any(m_qword())),=">"]) ##### #####[tab(many(m_qword())),="</",tab(any(m_qword())),=">"]) #####end #===================================================================# #===================================================================# # XML stuff # <xtag xarg> xtxt </xtag> # <xtag xarg /> #===================================================================# #===================================================================# # SYMBOL procedure m_mcf() #================ # TAP mcf file # property: value static sep,mcfChar initial { sep := ":" mcfChar := &cset -- sep } yystate := "m_mcf" suspend \ #SYMBOL("mcf",[tab(many(mcfChar)),=sep,tab(0)]) #SYMBOL("mcf",[m_phrase(),=sep,m_phrase()]) #SYMBOL("mcf",[m_phrase(),m_phrase()]) SYMBOL("mcf",[m_phrase(),tab(0)]) end ###### SYMBOL #####procedure m_rdfsentence() ######======================== ###### rdfsentence ::= rdfstatement #####yystate := "m_rdfsentence" #####suspend \ ##### SYMBOL("rdfsentence",m_rdfstatement()) #####end ##### ###### list #####procedure m_rdfstatement() ######========================= ###### rdfstatement ::= list of rdfphrase ###### rdfphrase ###### rdfphrase rdfstatement #####yystate := "m_rdfstatement" #####suspend \ ##### ([m_rdfphrase()]) | ##### ([m_rdfphrase()]|||m_rdfstatement()) #####end ##### ###### SYMBOL #####procedure m_rdfphrase() ######====================== ###### rdf ::= ###### html_command ###### html_text #####yystate := "m_rdfphrase" #####suspend \ ##### SYMBOL("rdfphrase",m_html_group()) | ##### SYMBOL("rdfphrase",m_html_command()) ##### #####SYMBOL("rdfphrase",m_html_text()) #####end # SYMBOL procedure m_nt() #=============== # nt ::= # subject property value yystate := "m_nt" suspend \ SYMBOL("nt",[m_phrase(),m_phrase(),m_phrase()]) end #================================================================# #================================================================# #================================================================# # nested SYMBOL # SYMBOL procedure find_stype(pattern,symbol) #=================================== local sym,x yystate := "find_stype" case type(symbol) of { default: { fail } ("list"|"set"): { every sym := !symbol do if x := find_stype(pattern,sym) then return x } "SYMBOL": { if DEBUG=="STYPE" then write(mybug,"# INFO: find_stype: pattern <",pattern,"> stype <",symbol.stype,">") if symbol.stype == pattern then return symbol else return find_stype(pattern,symbol.svalue) } } end # string procedure get_stype(symbol) #========================== case type(symbol) of { default: { fail } "list": { return get_stype(symbol[1]) } "SYMBOL": { return symbol.stype } } end # list procedure get_svalue(symbol) #=========================== case type(symbol) of { default: { fail } "list": { return get_svalue(symbol[1]) } "SYMBOL": { return symbol.svalue } } end #===========================================================# #===========================================================# #===========================================================# # parsing # string procedure token_htag(tokenlist) #============================== # check for "</" local htag if token_value(tokenlist[1]) == ("<"|"</") then { htag := token_value(tokenlist[2]) } else { fail } return unparse(htag) end # string procedure token_hend(tokenlist) #============================== # check for "/>" local hend if token_value(tokenlist[-1]) == (">"|"/>") then { hend := token_value(tokenlist[-2]) } else { fail } return unparse(hend) end # SYMBOL("harg",nvlist) procedure token_harg(tokenlist) #============================== local htag local vlist,novlist,i,nvlist,nv,harg static info initial info := "INFO: token_harg: " vlist := token_value(tokenlist) ###writes_type_all(vlist,info||"vlist") if htag := token_htag(tokenlist) & vlist[-1] == (">"|"/>") then { novlist := vlist[3:-2] nvlist := [] every i := 1 to *novlist by 3 do { nv := NVPHRASE("nv",novlist[i:i+3]) put(nvlist,nv) } # end every i } else { fail } ###writes_type_all(nvlist,info||"nvlist") return harg := SYMBOL("harg",nvlist) end # string procedure parse_file(fd,ps,option) #================================= # ";" signals complete MKR proposition # ">" signals complete XML command local dval local t,lasttoken,lastword,kucomplete,gcomplete,htmlcomplete local stype local tline local token,line,newline local tokenlist,symbollist local wordlist local KHRV,VD,newps local head,tail local xval local docname,ename,uri,htag,harg,xqual,qual static sharp,psep static qcontinue,pscontinue static info,ierror,warning initial { info := "INFO: parse_file: " ierror := "Internal ERROR: parse_file: " warning := "WARNING: parse_file: " qcontinue := "\\n" pscontinue := "continue" sharp := repl("#",5) psep := PSEPARATOR # blank } /fd := FD | myin /ps := "ke" /option := "" PS := ps||"$ " yystate := "parse_file" #NEWcomplete("prop") if DEBUG=="PARSE" then { writes_type_all(image(fd),info||"input fd") } case t := type(fd) of { default: { writes_type(mylog,fd,warning||"unexpected type: fd") fd := unparse(fd) } ("string"|"integer"): { } "file": { head := sharp||" " tail := " KFORMAT <"||KFORMAT||"> "||sharp||"\n" #####writes_all([head,"parse_file ",image(fd),tail]) writes(mylog,head,"parse_file ",image(fd),tail) } } tokenlist := [] every token := get_token(fd,PS,option) do { case t := type(token) of { default: { writes_type(myerr,token,ierror||"unexpected type token") writes_type(mylog,token,ierror||"unexpected type token") fail } "TOKEN": { put(tokenlist,token) } "list": { if *token = 0 then { writes_type(myerr,token,ierror||"empty list token") writes_type(mylog,token,ierror||"empty list token") fail } tokenlist |||:= token } } # end case t lasttoken := tokenlist[-1] lastword := token_type(lasttoken) if DEBUG==("LASTWORD"|"PARSE") then { writes_type_all(lasttoken,info||"lasttoken") writes_type_all(lastword,info||"lastword") } NEWcomplete(lastword) # already done from get_token() ??? case lastword of { default: { PS := ps||"> " next } ("|"|";"): { # end of MKR proposition #writes_type_all(KFORMAT,info||"KFORMAT") case KFORMAT of { ("html"|"htm"|"xml"|"rdf"|"owl"): { # ";" used for "&", etc. PS := ps||">" next } default: { # "ku"|"cu"| "ho" | "nrel" | ... kucomplete := NEWcomplete("_count_") # token.icn if DEBUG==("COMPLETE"|"END") then { writes_type(mybug,kucomplete,info||"kucomplete") writes_type(mylog,kucomplete,info||"kucomplete") } #####if (*CurrentGroupName > 0) | # in group if (KFORMAT == ("ho"|"hounit"|"rel"|"nrel")) | # in group (kucomplete = 0) # proposition complete then { case option of { default: { dval := do_mkrproposition(fd,tokenlist) } "NKRV": { dval := do_mkrproposition(fd,tokenlist) } "ke": { dval := do_mkrproposition(fd,tokenlist) } "ksc": { dval := do_ksc(fd,tokenlist) } } # end case option ##tokenlist := insert_context() tokenlist := [] #NEWcomplete("_restart_") #NEWcomplete("_start_") PS := ps||"$ " } # end if kucomplete } # end default } # end case KFORMAT } # end ";" (">"|"["): { # possible end of HTML/XML statement # trigger point for DOCTYPE/ENTITY statement # trigger point for <?xml ... ?> statement # trigger point for <rdf:RDF ... > statement # trigger point for </rdf:RDF> statement # <htag harg /> # <htag harg /> hlist </htag> # <htag harg /> htxt </htag> if stype := html_stype(tokenlist) then { if DEBUG=="COMPLETION" then { writes_type_all(stype,info||"HTML stype") } case stype of { "?xml": { # <?xml version="1.0" encoding="UT-8"?> # do what ??? writes_all([TypeComment||info||"xml version <", unparse(tokenlist,psep),">\n"]) tokenlist := [] PS := ps||"$ " next } "rdf:RDF": { # <rdf:RDF .... > htag := unparse(tokenlist[2]) harg := list_unparse(tokenlist[3:-1]) harg := delete_separator(harg,";") rdfQnamelist := do_xmlns(htag,harg) # xml.icn tokenlist := [] PS := ps||"$ " next } "/rdf:RDF": { # </rdf:RDF> writes_all([TypeComment||info||"end rdf <", unparse(tokenlist,psep),">\n"]) tokenlist := [] PS := ps||"$ " next } "!DOCTYPE": { # <!DOCTYPE name [ docname := tokenlist[3].tvalue add_species(docname,"doctype") writes_all([TypeComment||info||"!DOCTYPE <", unparse(tokenlist,psep),">\n"]) tokenlist := [] PS := ps||"$ " next } "!ENTITY": { # <!ENTITY name uri> # harg ::= list of [xmlns:q,=,uri] ename := tokenlist[3].tvalue uri := tokenlist[4].tvalue htag := stype harg := [["xmlns:"||ename,"=",uri]] do_xmlns(htag,harg) # xml.icn add_unit(ename,docname) xqual := "&"||ename||";" qual := ename||":" insert(xml_word,xqual,qual) writes_all([TypeComment||info||"!ENTITY <", unparse(tokenlist,psep),">\n"]) tokenlist := [] PS := ps||"$ " next } "!--": { #  writes_all([TypeComment||info||"HTML comment <", unparse(tokenlist,psep),">\n"]) tokenlist := [] PS := ps||"$ " next } "]>": { # end of !DOCTYPE docname := "" tokenlist := [] PS := ps||"$ " next } "command": { next } default: { } # complete HTML statement } # end case stype case KFORMAT of { ("html"|"htm"|"xml"|"rdf"|"owl"): { if do_xmlcommand(fd,tokenlist,stype) then { PS := ps||"$ " } else { PS := ps||"> " } tokenlist := [] } # end "html" ... ("ku"|"ho"|"hounit"|"nrel"): { # RDF comment: x has y=<z>; writes_type(mylog,line,info||"RDF comment") ##tokenlist := insert_context() ##PS := ps||"$ " } # end "ku" ... default: { writes_type(mylog,line,info||"ignoring xml line") ##tokenlist := insert_context() ##PS := ps||"$ " } } # end case KFORMAT } else { # wait for complete HTML statement } # end if stype } # end ">" } # end case lastword KHRV := KFORMAT||HOSEPARATOR||RELSEPARATOR||NVSEPARATOR VD := VIEW||":"||DOTCONCEPT case option of { default:{ newps := ps||"<"||KHRV||">" } "KHRV": { newps := ps||"<"||KHRV||">" } "ke": { newps := ps||"<"||VD||">" } "ksc": { newps := ps||"<"||KHRV||">" } } # end case option } # end every token #writes_type(mylog,tokenlist,info||"leftover tokenlist") if *\tokenlist > 0 then { line := unparse(tokenlist,psep) if line == "&null" then {} else { writes_type_all(line,warning||"leftover tokens in line <",">\n") writes_type_all(tokenlist,info||"leftover tokenlist") NEWcomplete("_restart_") ##### case option of { ##### default: { do_mkrproposition(tokenlist) } ##### "NKRV": { do_mkrproposition(tokenlist) } ##### "ke": { do_mkrproposition(tokenlist) } ##### "ksc": { do_ksc(fd,tokenlist) } ##### } # end case option tokenlist := [] PS := ps||"$ " } # end if line == "&null" } # end if *tokenlist return image(fd) end # line procedure do_mkrproposition(fd,tokenlist) #======================================== local line,symbollist,dval static info,warning,psep initial { info := "INFO: do_mkrproposition: " warning := "WARNING: do_mkrproposition: " psep := PSEPARATOR # " " } yystate := "do_mkrproposition" line := unparse(tokenlist,psep) if DEBUG=="PROPOSITION" then { writes_type_all(line,info||"line") } symbollist := get_symbol(fd,tokenlist) # symbol.icn if DEBUG=="PROPOSITION" then { writes_type_all(symbollist,info||"symbollist") } ##symbollist := delete_context(symbollist) # symbol.icn if DEBUG=="PROPOSITION" then { writes_type_all(symbollist,info||"symbollist") } dval := interpret_symbol(symbollist) # sentence.icn if /dval then { if DEBUG == "INTERPRET_SYMBOL" then writes_type_all(dval,warning||"dval") } return dval end # line procedure do_xmlcommand(fd,tokenlist,stype) #======================================= # new strategy (Sep/16/2005) # don't call do_xmlcommand() # until we have a complete HTML statment local line,tline,symbollist local subject,htag static info,psep initial { info := "INFO: do_xmlcommand: " psep := PSEPARATOR # " " } line := unparse(tokenlist,psep) if DEBUG==("XML"|"RDF"|"OWL"|"PROPOSITION") then { writes_type_all(line,info||"xml line") tline := unparse(token_type(tokenlist),"") writes_type_all(tline,info||"token line") } symbollist := get_symbol(fd,tokenlist) # symbol.icn #### bug: interpret_symbol(fd,symbollist,stype) # sentence.icn interpret_symbol(symbollist,stype) # sentence.icn end # SYMBOL list procedure get_symbol(fd,tok) #=========================== local merrmode local t,efd local tline,tsymbol,symbol local m_symbol,tsym local KHRV,prog local line local ke_kformat,param_kformat local info,ierror,warning,error initial { statestk := list(1) } yystate := "get_symbol" KHRV := KFORMAT||HOSEPARATOR||RELSEPARATOR||NVSEPARATOR prog := "get_symbol("||KHRV||"): " info := "INFO: "||prog warning := "WARNING: "||prog ierror := "Internal ERROR: "||prog error := "ERROR: "||prog if DEBUG == ("SYMBOL"|"PARSE") then { writes_type_all(KFORMAT,info||"KFORMAT") writes_type_all(tok,info||"input token list tok") } case t := type(tok) of { default: { writes_type_all(tok,ierror||"unexpected type tok") #return [] fail } "list": { if *tok = 0 then { writes_type_all(tok,ierror||"empty list tok") #return [] fail } } # continue below "TOKEN": { tok := [tok] } # continue below } if *tok = 1 & tok[1].ttype==("X"|"W") then { return SYMBOL("error",tok[1].tvalue) } ke_kformat := unparse(get_char("attr","ke","kformat")) param_kformat := unparse(get_parameter("kformat")) if DEBUG=="KFORMAT" then { writes_all([TypeComment||info, "ke_kformat<"||ke_kformat||"> ", "param_kformat<"||param_kformat||"> ", "KFORMAT<"||KFORMAT||">"]) } case KFORMAT of { "mkr": { m_symbol := m_proplist } "ku": { m_symbol := m_proplist } "cu": { m_symbol := m_proplist } "ho": { m_symbol := m_group } "hounit":{ m_symbol := m_group } "nrel": { m_symbol := m_group } "nv": { m_symbol := m_nvphrase } "list": { m_symbol := m_nrel_phraselist } # allow null phrase "html": { m_symbol := m_html_statement } "htm": { m_symbol := m_html_statement } "xml": { m_symbol := m_html_statement } "rdf": { m_symbol := m_html_statement } # W3C RDF format "owl": { m_symbol := m_html_statement } # W3C RDF format "mtriple": { m_symbol := m_proplist } # Mtriple format "Mtriple": { m_symbol := m_proplist } # Mtriple format "mt": { m_symbol := m_proplist } # Mtriple format "rdfmt": { m_symbol := m_proplist } # Mtriple format "owlmt": { m_symbol := m_proplist } # Mtriple format "nt": { m_symbol := m_proplist } # W3C N-triple format "mcf": { m_symbol := m_proplist } # Stanford TAP MCF format #"": { m_symbol := m_proplist } default: { writes_type(myerr,KFORMAT,warning||"unknown kformat") writes_type(mylog,KFORMAT,warning||"unknown kformat") KFORMAT := "ku" m_symbol := m_proplist } } # end case KFORMAT # no special meaning for words in HO and REL if #####(*CurrentGroupName > 0) | (KFORMAT == ("ho"|"hounit"|"nrel")) then tok := horel_token(tok) # token.icn tline := "" tsymbol := [] symbol := [] every t := !tok do { tline ||:= t.ttype put(tsymbol,t.tvalue) put(symbol,[t.tvalue]) # each token a list (if no match below) } if DEBUG == ("TLINE"|"TOKEN"|"SYMBOL") then { writes_type_all(tline,info||"input tline") } #################################################### #&trace := 10 symbol := SYMBOL("error",symbol) if tline ? { ( tsym <- m_symbol() ) & pos(0) } then { symbol := map_symbol(tsym,tok,*tok) if DEBUG == ("TSYM"|"TOKEN"|"SYMBOL") then { writes_type_all(tsym,info||"parse result tsym") } } else { fName := yyfnametab[image(FD)] # myio.icn yylineno := yylinenotab[image(FD)] # myio.icn yytext := unparse(tok," ") # unparse.icn yystate := string(yystate) # name of matching program yychar := string(tline) # token list KERROR +:= 1 writes_type_all(yystate,error||"unexpected token pattern in state") writes_type_all(yychar,info||"tokenlist") writes_type_all(yytext,info||"input line") merrmode := getenv("merrmode") | "ke" if DEBUG=="MERR" then { writes_type_all(merrmode,info||"merrmode") } case merrmode of { "merr": { # setup using file "err.state" # make command: merrmode=merr merr ke yystate := forcequote(yystate) yychar := forcequote(yychar) efd := open("err.state","w") # Merr setup file write(efd,"(",yystate,";",yychar,")") # yyerror() uses &errout close(efd) } ("ke"|"ksc"): { # run-time using yyerror(s) } default: { } } statestk[1] := yystate yyerror("syntax error") # yyerror.icn (generated by Merr) case KFORMAT of { default: { # reset all completion counters NEWcomplete("_restart_") } ("html"|"htm"|"xml"|"rdf"|"owl"): { # flush Subject stack CNAME := popSubject() CNAMEstack := [] pushSubject(CNAME) } } } # end if tline ? { } #&trace := 0 #################################################### if KFORMAT==("nv") & # do htm,html as ku *symbol=1 & *symbol[1]=1 then { writes_type(mylog,symbol,ierror||"null symbol") put(symbol[1],"") # [[name],[""]] } if DEBUG == ("SYMBOL"|"PARSE") then { writes_type_all(symbol,info||"output symbol list") } return symbol end # SYMBOL or list or string procedure map_symbol(tsym,tok,finish) #==================================== # tsym ::= SYMBOL # tok ::= list of TOKEN local head,middle,tail local s,t,x,y,z,val local L,size,B,S,E local mL,dL static itoken, ntoken,ssize local sline,tline,wline local lookfor,found,ufound static info,ierror,warning,hint initial { info := "INFO: map_symbol: " ierror := "Internal ERROR: map_symbol: " warning := "WARNING: map_symbol: " hint := "grammar HINT: map_symbol: " itoken := 0 ntoken := 0 } if \finish then { # initialize ntoken := finish itoken := 0 if DEBUG == "MAP" then { writes_type(mybug,tsym,info||"tsym") writes_type(mybug,tok,info||"tsym") writes_type(mylog,tsym,info||"tsym") writes_type(mylog,tok,info||"tsym") } # check size if (ssize := tsize(tsym)) ~= (*tok) then { head := TypeComment||ierror||"token size mismatch: tsize(tsym) <" middle := "> *tok <" tail := ">\n" writes(myerr,head,ssize,middle,*tok,tail) writes(mylog,head,ssize,middle,*tok,tail) if DEBUG=="TOKEN" then { writes_type(myerr,tsym,info||"tsym") writes_type(myerr,tok,info||"tok") writes_type(mylog,tsym,info||"tsym") writes_type(mylog,tok,info||"tok") } else { sline := unparse(tsym) tline := token_type(tok) wline := token_value(tok) writes_type(myerr,sline,info||"symbol line") writes_type(myerr,tline,info||"token line") writes_type(myerr,wline,info||"word line") writes_type(mylog,sline,info||"symbol line") writes_type(mylog,tline,info||"token line") writes_type(mylog,wline,info||"word line") } } } case t := type(tsym) of { "TOKEN": { # match_token() output - match tvalue itoken +:= 1 lookfor := tsym.tvalue found := tok[itoken].tvalue ###if found == lookfor then { ### writes_all([TypeComment||hint,lookfor]) ###} else { ### writes_all([TypeComment||hint,found]) ###} ###ufound := unique_name(found) ###writes_all([TypeComment||"generic name <",found, ### "> replaced by unit name <",ufound,">\n"]) #####return ufound return found } "null": { writes_type(myerr,tsym,ierror||"unexpected null: tsym") writes_type(mylog,tsym,ierror||"unexpected null: tsym") return "" # map to empty string } default: { writes_type(myerr,tsym,ierror||"unexpected type("||t||") tsym") writes_type(mylog,tsym,ierror||"unexpected type("||t||") tsym") return "(UNEXPECTED TYPE("||t||") "||unparse(tsym)||")" } "string": { s := "" every x := ! tsym do { if x == PSEPARATOR then { s ||:= PSEPARATOR # possibly added during phrase parsing } else { itoken +:= 1 if itoken > ntoken then { val := "<no more tokens>" writes_type(myerr,itoken,ierror||val||": itoken") writes_type(mylog,itoken,ierror||val||": itoken") } else { val := tok[itoken].tvalue } s ||:= val } } # end every x return s } "list": { x := [] every y := ! tsym do { z := map_symbol(y,tok) if type(z)=="string" & z=="," then { case KFORMAT of { ("ho"|"hounit"): { # keep comma #####put(x,z) # (problem: always kformat=ku) } default: { # delete comma } } # end case KFORMAT } else if type(z)=="string" & z==";" then { put(x,z) # keep semicolon (need proposition terminator) } else { put(x,z) } } return x } "SYMBOL": { case tsym.stype of { default: { return SYMBOL(tsym.stype, map_symbol(tsym.svalue,tok)) } "htxt": { return htxt_map_symbol(tsym,tok) } } } "PHRASE": { return phrase_map_symbol(tsym,tok) } # symbol.icn "BSE": { return bse_map_symbol(tsym,tok) } # bselist.icn "m_BSE": { return bse_map_symbol(mbse2bse(tsym),tok) } # bselist.icn "NVPHRASE": { return nv_map_symbol(tsym,tok) } # nvlist.icn "VOPHRASE": { return vo_map_symbol(tsym,tok) } # binrel.icn "AAPHRASE": { return aa_map_symbol(tsym,tok) } # array.icn "GROUP": { return group_map_symbol(tsym,tok) } # begin.icn "HOUNIT": { return ho_map_symbol(tsym,tok) } # hwalk.icn "RELUNIT": { return nrel_map_symbol(tsym,tok) } # relation.icn } # end case t end # integer procedure tsize(symbol) #====================== # count number of tokens in a symbol list # called by map_symbol() in symbol.icn local t,ntoken,x local L,s,B,S,E static info,ierror,slevel initial { info := "INFO: tsize: " ierror := "Internal ERROR: tsize: " slevel := 0 } if DEBUG == "TSIZE" then { writes_type(mybug,symbol,info||"slevel <"||slevel||"> symbol") } slevel +:= 1 case t := type(symbol) of { "TOKEN": { # match_token() output ntoken := tsize(symbol.ttype) } "null": { writes_type(myerr,symbol,ierror||"unexpected null: symbol") writes_type(mylog,symbol,ierror||"unexpected null: symbol") ntoken := 0 } default: { writes_type(myerr,symbol,ierror||"unexpected type("||t||") symbol") writes_type(mylog,symbol,ierror||"unexpected type("||t||") symbol") ntoken := 0 } "string": { ntoken := 0 every x := ! symbol do if x == PSEPARATOR then { # do NOT count (possibly added during phrase parsing) } else { ntoken +:= 1 } } "list": { ntoken := 0 every ntoken +:= tsize(!symbol) } "SYMBOL": { ntoken := tsize(symbol.svalue) } # symbol.icn "PHRASE": { ntoken := phrase_tsize(symbol) } # symbol.icn "BSE": { ntoken := bse_tsize(symbol) } # bselist.icn "m_BSE": { ntoken := bse_tsize(mbse2bse(symbol)) } # bselist.icn "NVPHRASE":{ ntoken := nv_tsize(symbol) } # nvlist.icn "VOPHRASE":{ ntoken := vo_tsize(symbol) } # binrel.icn "AAPHRASE":{ ntoken := aa_tsize(symbol) } # array.icn "GROUP": { ntoken := group_tsize(symbol) } # begin.icn "HOUNIT": { ntoken := ho_tsize(symbol) } # method.icn "RELUNIT": { ntoken := nrel_tsize(symbol) } # relation.icn } # end case t slevel -:= 1 if DEBUG == "TSIZE" then writes_type(mybug,ntoken,info||"slevel <"||slevel||"> ntoken") return ntoken end #================================================================# #================================================================# # LINE procedure get_line(fd) #===================== local line /fd := FD | myin while line := read(fd) do { if line == ("" | "#") then next suspend line } fail end # WORD list procedure get_wordList(fd,line) #============================== local wlist /fd := FD | myin wlist := [] every wlist ||| get_word(fd,line) return wlist end # TOKEN list procedure get_tokenList(fd,wlist) #================================ local tlist /fd := FD | myin tlist := [] every put(tlist, get_token(wlist)) return tlist end # SYMBOL list procedure get_symbolList(fd,tlist) #================================= local slist /fd := FD | myin slist := [] every slist ||| get_symbol(tlist) return slist end #================================================================# # list procedure parse_list(line,sep) #============================= # called by parse_set() in word.icn # which is called by db_decode() in database.icn # replaces OLDparse_list() in word.icn # change ParserMode since no terminating ";" local fd local tokenlist,symbollist,sym local saveKFORMAT,saveListSeparator,saveParserMode static info,ierror,warning initial { info := "INFO: parse_list: " ierror := "Internal ERROR: parse_list: " warning := "WARNING: parse_list: " } /sep := "," if sep == "," then { } else { writes_type(mylog,sep,warning||"unexpected separator") } fd := myin; yystate := "parse_list" if DEBUG=="LIST" then { writes_type(mybug,line,info||"line") } #####fpush() saveKFORMAT := KFORMAT; KFORMAT := "list" saveListSeparator := ListSeparator; ListSeparator := sep saveParserMode := ParserMode; ParserMode := "line" tokenlist := get_token(line) symbollist := get_symbol(fd,tokenlist) ParserMode := saveParserMode ListSeparator := saveListSeparator KFORMAT := saveKFORMAT #####fpop() sym := list_unparse(symbollist) if DEBUG=="LIST" then { writes_type(mybug,sym,info||"sym") } return sym end # SYMBOL list procedure parse_hierarchy(line,sep) #================================== # SYMBOL("ho",group) # hostatement ::= # honame; # / hophrase; # \ hophrase; # isa,isc local SaveKFORMAT local wlist,tlist,slist static info initial { info := "INFO: parse_hierarchy: " } /sep := HOSEPARATOR if *line = 0 then return [] if line[1] == "#" then return [] # comment ###interpret_line("begin hierarchy x;") SaveKFORMAT := KFORMAT KFORMAT := "ho" wlist := get_wordList(line) tlist := get_tokenList(wlist) ##slist := get_symbolList(tlist) slist := get_symbol(tlist) KFORMAT := SaveKFORMAT ###interpret_line("end hierarchy x;") if DEBUG == "HO" then writes_type_all(slist,info||"slist") return slist end # SYMBOL list procedure parse_relation(line,sep) #================================= # SYMBOL("nrel",group) # rnest ::= [[r,...], ;, ...] <<== old MKR # rnest ::= [[r],...]; <<== new MKR local SaveKFORMAT local wlist,tlist,slist static info initial { info := "INFO: parse_relation: " } /sep := RELSEPARATOR if type(line)=="null" then fail if *line = 0 then return [] if line[1] == "#" then return [] # comment ###interpret_line("begin relation x;") SaveKFORMAT := KFORMAT KFORMAT := "nrel" wlist := get_wordList(line) tlist := get_tokenList(wlist) slist := get_symbolList(tlist) KFORMAT := SaveKFORMAT ###interpret_line("end relation x;") if DEBUG == ("REL"|"RELATION") then writes_type_all(slist,info||"slist") return slist end # SYMBOL procedure parse_nrel(line,option) #=============================== # SYMBOL("nrel",rnest) # nrelstatement ::= # nrelphraseList ; # RELSEPARATOR ::= "," local saveKFORMAT,symbol,rnest,i static info,ierror initial { info := "INFO: parse_nrel: " ierror := "Internal ERROR: parse_nrel: " } /option := "nest" if type(line)=="null" then fail if *line = 0 then return [] if line[1] == "#" then return [] # comment saveKFORMAT := KFORMAT KFORMAT := "nrel" if symbol := parse_line(line,,"no") then { } else { writes_type(mylog,line,ierror||"parse_line failed: line") KFORMAT := saveKFORMAT fail } KFORMAT := saveKFORMAT case symbol.stype of { "error": { fail } "nrel": { rnest := symbol.svalue } } case option of { default: { writes_type(mylog,option,ierror||"unexpected option") writes_type(mylog,line,info||"line") } "nest": { } "list": { every i := 1 to *rnest do case rnest[i] of { RELSEPARATOR: { } default: { case *rnest[i] of { 0: { rnest[i] := "" } 1: { rnest[i] := rnest[i][1] } default: { rnest[i] := unparse(rnest[i]) } } } } # end case rnest[i] } # end "list" } # end case option if DEBUG == ("REL"|"RELATION") then writes_type(mybug,rnest,info||"rnest") return rnest end # list procedure parse_nv(line) #======================= # name = value # SYMBOL("nv",[name,nvop,value]) local saveKFORMAT,symbol,nvlist if *line = 0 then return [] if line[1] == "#" then return [] # comment saveKFORMAT := KFORMAT; KFORMAT := "nv" symbol := parse_line(line,,"no").symbol KFORMAT := saveKFORMAT if DEBUG == "NV" then writes_type(mybug,symbol,"INFO: parse_nv: symbol") nvlist := symbol.svalue return nvlist end # SYMBOL procedure parse_value(line) #========================== # name = value # SYMBOL("nv",[name,nvop,value]) local saveKFORMAT,nvlist,value if *line = 0 then return [] if line[1] == "#" then return [] # comment nvlist := parse_nv("x = "||line) if DEBUG == "VALUE" then writes_type(mybug,nvlist,"INFO: parse_value: nvlist") value := nvlist[3] return value end #--------------------------------------------------# # list procedure parse_quantifier(line,sep) #=================================== # quantifier - word # SYMBOL("nrel",[quantifier,"-",word]) local saveRELSEPARATOR,symbol,tuple static info initial { info := "INFO: parse_quantifier: " } /sep := dequote(QSEPARATOR) if *line = 0 then return [] if line[1] == "#" then return [] # comment saveRELSEPARATOR := RELSEPARATOR; RELSEPARATOR := sep symbol := parse_nrel(line,"list") RELSEPARATOR := saveRELSEPARATOR if DEBUG == "QUANTIFIER" then writes_type(mybug,symbol,info||"symbol") tuple := symbol return tuple end #------------------------------------------------------------------# #------------------------------------------------------------------# # string procedure interpret_line(line,kformat,dollar) #============================================ # interpret_line() called by new_concept() in concept.icn # NOTE: parse_file() indirectly calls # get_symbol() & interpret_symbol() local infd,continue local uline,rline local symbol,sline local saveKFORMAT static info,head,tail,error initial { info := "INFO: interpret_line: " error := "ERROR: interpret_line: " head := " ## interpret_line: " tail := " ##" #####init_parser() } /kformat := "ku" /dollar := "ignore" ##yystate := "interpret_line" uline := unparse(line) if *line = 0 then return line case dollar of { "replace": { rline := replace_dollar_line(uline) } default: { rline := uline } } if DEBUG == "INTERPRET_LINE" then writes_type_all(rline,info||"rline") saveKFORMAT := KFORMAT; KFORMAT := kformat parse_file(rline) KFORMAT := saveKFORMAT return rline ######################################################### if DEBUG=="TIME" then write(mybug,"## ",&time,head,"parse_line",tail) symbol := parse_line(uline,infd,continue) case type(symbol) of { default: { fail } "SYMBOL": { } } if DEBUG=="TIME" then write(mybug,"## ",&time,head,"interpret_symbol",tail) interpret_symbol(symbol) return symbol end # SYMBOL list procedure parse_line(line) #========================= # called from ifthen() in ifthen.icn # parse single line # parse external representation of KnowledgeUnit # do NOT substitute dollar and dot variables # SYMBOL(stype,svalue) local infd,continue local token,tokenlist,symbollist local mline,rline local linetoken,tline,symbol,linesymbol local lineword local info,head,tail yystate := "parse_line" info := "INFO: parse_line("||KFORMAT||"): " head := " ## parse_line("||KFORMAT||"): " tail := " ##" infd := myin case KFORMAT of { default: { continue := "no" } "ku": { continue := "yes" } "cu": { continue := "yes" } "ho": { continue := "no" } "hounit":{ continue := "no" } "nrel": { continue := "no" } "nv": { continue := "no" } "html": { continue := "yes" } "htm": { continue := "yes" } "xml": { continue := "yes" } "rdf": { continue := "yes" } "mcf": { continue := "no" } "nt": { continue := "no" } } # end case KFORMAT if DEBUG==("YES"|"PARSE") then { writes_type(mybug,line,info||"line") } if DEBUG=="TIME" then write(mybug,"## ",&time,head,"trimcomment",tail) #line := trimcomment(line) # <== in prompt() if DEBUG=="TIME" then write(mybug,"## ",&time,head,"trimws",tail) line := trimws(line) if *line = 0 then fail if line[1] == "#" then fail # comment if DEBUG=="TIME" then write(mybug,"## ",&time,head,"map to lower case",tail) mline := line case KCASE of { ("LOWER"|"lower"): { mline := map(mline) } #("UPPER"|"upper"): { mline := map(mline,&lcase,&ucase) } # <<== won't work !!! } if DEBUG=="PARSE" then writes_type(mybug,mline,info||"mline") if DEBUG=="TIME" then write(mybug,"## ",&time,head,"remove HTML",tail) rline := mline case REMOVEHTML of { ("yes"|"YES"): { #####rline := remove_html(rline) # <<== NO -- SAVEHREF in map_token() if *rline=0 then fail if rline[1] == "#" then fail # comment } } if DEBUG=="PARSE" then writes_type(mybug,rline,info||"rline") if DEBUG=="TIME" then write(mybug,"## ",&time,head,"get_word",tail) #################################################### # new tokenlist := [] while token := get_token(line) do put(tokenlist,token) symbollist := get_symbol(infd,tokenlist) return symbollist #################################################### # old -- not executed lineword := get_word(rline) if DEBUG=="PARSE" then writes_type(mybug,lineword,info||"lineword") if DEBUG=="TIME" then write(mybug,"## ",&time,head,"get_token",tail) linetoken := get_token(lineword,infd) tline := linetoken.line if *tline = 0 then fail if DEBUG=="CONTINUE" then writes_type(mybug,tline,info||"tline") if DEBUG=="TIME" then write(mybug,"## ",&time,head,"get_symbol",tail) linesymbol := get_symbol(infd,linetoken) symbol := linesymbol.symbol if DEBUG==("YES"|"PARSE") then writes_type(mybug,symbol,info||"symbol") if DEBUG=="TIME" then write(mybug,"## ",&time,head,"return linesymbol",tail) return linesymbol end #