# KEHOME/src/unparse.icn
# Oct/27/2005 Mar/28/2007 Apr/1/2007 Aug/1/2008
# Sep/1/2008  m_BSE (see symbol.icn)

# list or string
procedure list_unparse(x,lsep,psep,option)
#=========================================
# unparse names, but preserve list/set structure
# option ::= "string"|"list"
# "list" option good for subject,object,etc.
local t,st,y
static info
initial {
  info := "INFO: list_unparse: "
}
/lsep := ","  # list separator
/psep := " "  # phrase separator
/option := "list"
y := ""
case t := type(x) of {
default: { y := unparse(x,lsep,psep,option) }
"SYMBOL": {
    y := list_unparse(x.svalue,lsep,psep,option)
    }
"set": {
    return set_unparse(x,lsep,psep,option)
    }
"list": {
    case option of {
    "string": {
	case *x of {
	0: { y := "[]" }
	1: { y := unparse(!x,lsep,psep,option) }
	default: {
		y := ""
		every y ||:=  unparse(!x,lsep,psep,option) || lsep
		y := trim(y,lsep)
		}
	} # end case *x
	} # end "string"
    "list": {
	y := []
	every put(y,list_unparse(!x,lsep,psep,option))
	} # end "list"
    } # end case option
    } # end "list"
} # end case t
if DEBUG==("LIST"|"SET") then {
  writes_type(mybug,y,info||"y")
}
return y
end

# list or string
procedure set_unparse(x,lsep,psep,option)
#========================================
# unparse names, but preserve list/set structure
# like list_unparse, but sort set members
# option ::= "string"|"list"
# "list" option good for subject,object,etc.

local t,y
static info
initial {
  info := "INFO: set_unparse: "
}
/lsep := ","  # list separator
/psep := " "  # phrase separator
/option := "list"
y := ""
case t := type(x) of {
default: { y := unparse(x,lsep,psep,option) }
"list": {
    return list_unparse(x,lsep,psep,option)
    }
"set": {
    x := set(sort(x))
    case option of {
    "string": {
	case *x of {
	0: { y := "[]" }
	1: { y := unparse(!x,lsep,psep) }
	default: {
		y := ""
		every y ||:=  unparse(!x,lsep,psep) || lsep
		y := trim(y,lsep)
		}
	} # end case *x
	} # end "string"
    "list": {
	y := []
	every put(y,list_unparse(!x,lsep,psep,option))
	} # end "list"
    } # end case option
    } # end "set"
} # end case t
if DEBUG==("LIST"|"SET") then {
  writes_type(mybug,y,info||"y")
}
return y
end

# string
procedure table_unparse(x,lsep,lend,nvsep,head,tail)
#===================================================
# don't put { } around table
local name,value,y,t,val
local nvop,uname,uvalue
static info,ierror
static psep,prefix,suffix
initial {
  info := "INFO: table_unparse: "
  ierror := "Internal ERROR: table_unparse: "
  psep := PSEPARATOR  # " "
  prefix := repl(" ",4)
  suffix := "\n"
}
/lsep := ","
/lend := " "
/nvsep := NVSEPARATOR  # "="
/head := ""
/tail := ""
nvop := psep||nvsep||psep
if DEBUG==("PARSE"|"UNPARSE") then
  write(&errout,TypeComment||info,image(x))

case t := type(x) of {
default: { writes_type(mylog,t,ierror||"unexpected type"); fail }
"table": { }
}

y := psep||head||suffix
if *x > 0 then {
    every name := sort_key(x) do {
	value := x[name]
	if DEBUG==("PARSE"|"UNPARSE") then
	  writes_type(&errout,value,info||name||"=<",">\n")
	uname := unparse(name)
	uvalue := value_unparse(value)
	#writes_type_all(value,info||"value")
	#writes_type_all(uvalue,info||"uvalue")
	y ||:= prefix||
		uname||nvop||uvalue||
		lsep||suffix
    }
} # end if
y[-2] := lend  # replace initial psep or last lsep
y ||:= tail||psep
return y
end

# string
procedure value_unparse(x)
#=========================
# do NOT use [] unless necessary for list
# use { } for table
local t
static info
initial {
  info := "INFO: value_unparse: "
}
#writes_type_all(x,info||"x")
case t := type(x) of {
default: { return unparse(x) }
("list"|"set"): {
	case *x of {
	0: { return "[]" }
	1: { return unparse(x) }
	default: { return "[" || unparse(x) || "]" }
	} # end case *x
	} # end "list"
"table": {
	return "{" ||unparse(x)|| "}"
	} 
"string": {
	case *x of {
	0: { return "\"\"" }
	default: { return x }
	} # end case *x
	} # end "string"
} # end case t
end

#------------------------------------------#

# string
procedure unparse(x,lsep,psep,option)
#====================================
# unparse symbol (convert symbol to line)
# option ::= "string"|"list"
local line,n,i,y,z
local nov,rnest
local xt,st
local gslist
static squote,dquote,b
static info,ierror,warning
initial {
  info := "INFO: unparse: "
  ierror := "Internal ERROR: unparse: "
  warning := "WARNING: unparse: "
  squote := "\'"
  dquote := "\""
  b := " "
  /DEBUG := "NO"
}
/lsep := ","  # list separator
/psep := " "  # phrase separator
/option := "string"
if DEBUG=="UNPARSE" then {
  writes_type(mybug,x,info||"input symbol")
}
case xt := type(x) of {
default: {
  writes_type(mylog,x,ierror||"unexpected type")
  #fail
  return "UnexpectedType_"||xt||"_"||new_id()
  }
"null": {
  if DEBUG=="NULL" then {
    writes_type_all(x,warning||"null type x")
  }
  return "&null"
  }
";": { return x }
"integer": { return string(x) }
"real":    { return string(x) }
"string":  { return x }
"cset":    { return squote||string(x)||squote }
"file":    { return image(x) }
"table":   { return table_unparse(x,lsep,psep) }
"list":    { return list_unparse(x,lsep,psep,option) }
"set":     { return list_unparse(x,lsep,psep,option) }
"WORD":       { return x.wvalue }            # token.icn
"TOKEN":      { return token_value(x) }      # token.icn
"SYMBOL":     { } # continue below
"PHRASE":     { return phrase_unparse(x) }   # symbol.icn
"NVPHRASE":   { return nv_unparse(x) }       # nvlist.icn
"VOPHRASE":   { return vo_unparse(x) }       # nvlist.icn
"AAPHRASE":   { return aa_unparse(x) }       # array.icn
"BSE":        { return bse_unparse(x) }      # bselist.icn
"m_BSE":      { return mbse_unparse(x) }     # bselist.icn
"GROUP":      { return group_unparse(x) }    # begin.icn
"RELUNIT":    { return nrel_unparse(x) }     # relation.icn
"HOUNIT":     { return ho_unparse(x) }       # hwalk.icn
"PPOBJECT":   { return ppobject_unparse(x) } # pplist.icn

"ARGINFO": { return argdef_unparse(x) }  # role.icn
"CONCEPT": { return concept_unparse(x) } # role.icn

"TRIPLE": { return nt_unparse(x) }   # xml.icn
"MCF":    { return mcf_unparse(x) }  # xml.icn
} # end case type

# SYMBOL(stype,svalue)
##case xt := type(x) of {
##"SYMBOL": { }
##default: {
##	writes_all([TypeComment||ierror||"unexpected type <",xt,">"])
##	writes_all([TypeComment||info||"image(x) <",image(x),">"])
##	}
##}
line := ""
case st := x.stype of {
default: {
  writes_type(mylog,x,ierror||"unexpected stype <"||st||"> x")
  return unparse(x.svalue,lsep,psep)
  }
"null": {
  if DEBUG=="NULL" then {
    writes_type_all(x,warning||"null stype x")
  }
  return "&null"
  }
"vvv": {
	# SYMBOL("vvv",[verb1,verb2,verb3])
	line := unparse(x.svalue,b)
	return line
	}
"wordproposition": {
	# SYMBOL("wordproposition",[qword,";"])
	line := unparse(x.svalue,"")
	return line
	}
"grammar hint": {
	# SYMBOL("grammar hint",match_token(TOKEN("w","grammar term")))
	line := unparse(x.svalue,psep)
	return line
	}

"DOCTYPE": {
	# SYMBOL("DOCTYPE",["<!DOCTYPE",docname,entitylist,">"])
	}
"ENTITY": {
	# SYMBOL("ENTITY",["<!ENTITY",name,uri,">"])
	line := unparse(x.svalue,psep,psep)
	return line
	}

"variable": {
	# SYMBOL(stype,[name])
	# SYMBOL(stype,[name,bracket])
	line := unparse(x.svalue,psep,psep)
	line ||:= unparse(x.svalue,lsep,psep)
	return line
	}
"arrayref": {
	# name[char];
	# SYMBOL("arrayref",[AAPHRASE(name,index),=";"])
	line := unparse(x.svalue[1],psep,psep)
	line ||:= unparse(x.svalue[2])
	return line
	}
"arrayset": {
	# name[char]
	# SYMBOL("arrayset",[AAPHRASE(name,index)])
	line := unparse(x.svalue[1],psep,psep)
	return line
	}
"arrayval": {
	# phrase;
	# SYMBOL("arrayval",[phrase,";")])
	line := unparse(x.svalue[1],psep,psep)
	line ||:= unparse(x.svalue[2],psep,psep)
	return line
	}
"index": {
	# SYMBOL("index",SYMBOL("bracket",svalue))
	# or SYMBOL("index",["[",phrase,"]"])
	line := unparse(x.svalue[1])
	line ||:= unparse(x.svalue[2],lsep,psep)
	line ||:= unparse(x.svalue[3])
	return line
	}

# stype (symbol.icn)
"begin": { return unparse(x.svalue,psep,psep) }
"end":   { return unparse(x.svalue,psep,psep) }

# stype (symbol.icn)
"group": {
	###### SYMBOL("group",[gbegin,gslist,gend])  # <<== OLD
	#####line := unparse(x.svalue[1],lsep,psep)
	#####gslist := x.svalue[2]
	#####every line ||:= psep||unparse(!gslist,lsep,psep)
	#####line ||:= psep||unparse(x.svalue[3],lsep,psep)
	# SYMBOL("group",GROUP(gtype,gvalue)
	# gtype ::= begin | gs | end
	return unparse(x.svalue,lsep,psep)
	}
"?": {
	return unparse(x.svalue,lsep,psep)
	}
"kb": {
	return unparse(x.svalue,lsep,psep)
	}
"prop": { # prop
	#####line := unparse(x.svalue[1],lsep,psep)
	#####line ||:= psep||unparse(x.svalue[2],lsep,psep)
	#####return line
	return unparse(x.svalue,lsep,psep)
	}
"proplist": { # prop proplist
	line := ""
	every line ||:= psep||unparse(!x.svalue,lsep,psep)
	return line
	}
"conjunction": {
	return unparse(x.svalue,lsep,psep)
	}
"context sentence": { # SYMBOL("context sentence",[context,brace,;])
	line := unparse(x.svalue[1][1])
	line ||:= psep||unparse(x.svalue[1][2],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}
"context": { # SYMBOL("context",[[[at],nvlist],;])
	line := unparse(x.svalue[1][1])
	line ||:= psep||unparse(x.svalue[1][2],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	return line
	}
"situation": { # view supports
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	return line
	}
"phrase": { # "w" list with separator=blank
	return unparse(x.svalue,psep,psep)
	}
"phrase_pplist": { # subject|product|propname
	line := unparse(x.svalue[1],psep,psep)
	line ||:= psep||unparse(x.svalue[2],psep,psep)
	return line
	}
"compound sentence": {
	# brace ;
	# notbrace ;
	# brace conjunction compound_sentence
	# notbrace conjunction compound_sentence
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep|| unparse(x.svalue[2],lsep,psep)
	if *x.svalue > 2 then
		line ||:= psep|| unparse(x.svalue[3:0],psep,psep)
	return line
	}
"sentence": {
	return unparse(x.svalue,lsep,psep)
	}
"assignment": {
	return unparse(x.svalue,lsep,psep)
	}
"assign": { # set variable = value
	line := x.svalue[1]
	line ||:= psep || unparse(x.svalue[2],lsep,psep)
	line ||:= psep || unparse(x.svalue[3],lsep,psep)
	line ||:= psep || unparse(x.svalue[4],lsep,psep)
	return line
}
"production": {
	# product := sentence
	# product := var[char] ;
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep || unparse(x.svalue[2],lsep,psep)
	line ||:= psep || unparse(x.svalue[3],lsep,psep)
	line ||:= unparse(x.svalue[4],psep,psep)
	return line
	}
"product": {
	return unparse(x.svalue,lsep,psep)
	}
"producer": {
	return unparse(x.svalue,psep,psep)
	}
"command": {
	return unparse(x.svalue,lsep,psep)
	}
"statement": {
	return unparse(x.svalue,lsep,psep)
	}
"question": {
	return unparse(x.svalue,lsep,psep)
	}
"itef": { # SYMBOL("itef",[IF,FI])
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	return line
	}
"if": { # SYMBOL("if",["if",m_proposition()])
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	return line
	}
"then": { # SYMBOL("then",["then",m_proplist(),"fi",";"])
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= unparse(x.svalue[4],lsep,psep)
	return line
	}
"else": { # SYMBOL("else",["else",m_proplist(),"fi",";"])
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= unparse(x.svalue[3],lsep,psep)
	return line
	}
"thenelse": { # SYMBOL("thenelse",["then",m_proplist(),"else",m_proplist(),"fi",";"])
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= psep||unparse(x.svalue[4],lsep,psep)
	line ||:= psep||unparse(x.svalue[5],lsep,psep)
	line ||:= unparse(x.svalue[6],lsep,psep)
	return line
	}
"eitheror": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= psep||unparse(x.svalue[4],lsep,psep)
	return line
	}
"alland": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= psep||unparse(x.svalue[4],lsep,psep)
	return line
	}
("every"|"while"|"when"|
"forall"|"exists"|
"forAll"|"forSome"): {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= psep||unparse(x.svalue[4],lsep,psep)
	line ||:= psep||unparse(x.svalue[5],lsep,psep)
	return line
	}
"generator": {
	# generator ::= subject verb object pplist ;
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= psep||unparse(x.svalue[4],lsep,psep)
	line ||:= psep||unparse(x.svalue[5],lsep,psep)
	return line
	}
"cd": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}
"exit": { # exit KE
	return unparse(x.svalue,"",psep)
	}
"w": {
	return unparse(x.svalue,lsep,psep)
	}
"command string": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	return line
	}
"vdo": { # vdo, delete
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= psep||unparse(x.svalue[4],lsep,psep)
	line ||:= psep||unparse(x.svalue[5],lsep,psep)
	return line
	}
"delete": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}

# new kustatement -- semicolon terminator
(
"sLo"	|
"se"	|
"sIo"	|
"spo"	|
"sHa"	|
"sRo"	|
"Dcd"
): {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= psep||unparse(x.svalue[4],lsep,psep)  # ;
	return line
	}
(
"sLRo"	|
"sIop"	|
"sHap"	|
"sRop"	|
"sDad"	|
"Dcpd"
#"Dcod"	   # obsolete
): {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= psep||unparse(x.svalue[4],lsep,psep)
	line ||:= psep||unparse(x.svalue[5],lsep,psep)  # ;
	return line
	}
(
"sDapd"
#"sDaod"|  # obsolete
#"Dcopd"   # obsolete
): {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= psep||unparse(x.svalue[4],lsep,psep)
	line ||:= psep||unparse(x.svalue[5],lsep,psep)
	line ||:= psep||unparse(x.svalue[6],lsep,psep)  # ;
	return line
	}
#####(
#####"sDaopd"  # obsolete
#####): {
#####	line := unparse(x.svalue[1],lsep,psep)
#####	line ||:= psep||unparse(x.svalue[2],lsep,psep)
#####	line ||:= psep||unparse(x.svalue[3],lsep,psep)
#####	line ||:= psep||unparse(x.svalue[4],lsep,psep)
#####	line ||:= psep||unparse(x.svalue[5],lsep,psep)
#####	line ||:= psep||unparse(x.svalue[6],lsep,psep)
#####	line ||:= psep||unparse(x.svalue[7],lsep,psep)  # ;
#####	return line
#####	}


"do": { # do verb
	#writes_type(mybug,x,info||"dophrase")
	line := unparse(x.svalue,lsep,psep)
	return line
	}
"od": { # od phrase  # obsolete
	#writes_type(mybug,x,info||"odphrase")
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep || unparse(x.svalue[2],lsep,psep)
	return line
	}
"verb": {  # subsumes "is","has","do","relverb"
	return unparse(x.svalue,lsep,psep)
	}
"is": {
	return unparse(x.svalue,lsep,psep)
	}
"isbegin": {
	return unparse(x.svalue,lsep,psep)
	}
"has": {
	return unparse(x.svalue,lsep,psep)
	}
"object": { # SYMBOL("object",phraselist)
	lsep := ","  # always use comma
	return unparse(x.svalue,lsep,psep)
	}
"nvobject": { # SYMBOL("nvobject",nvlist)
	lsep := ","  # always use comma
	return unparse(x.svalue,lsep,psep)
	}
"voobject": { # SYMBOL("voobject",volist)
	lsep := ","  # always use comma
	return unparse(x.svalue,lsep,psep)
	}
#"op": {  # obsolete
#	line := unparse(x.svalue[1],lsep,psep)
#	line ||:= psep||unparse(x.svalue[2],lsep,psep)
#	return line
#	}
"qstm": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= psep||unparse(x.svalue[4],lsep,psep)
	return line
	}
"nv": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}
"nvnull": { # SYMBOL("nvnull",[name])
	return unparse(x.svalue,lsep,psep)
	}
"qp": {
	return unparse(x.svalue,lsep,psep)
	}
"wp": {
	return unparse(x.svalue,lsep,psep)
	}
"bp": {
	return unparse(x.svalue,lsep,psep)
	}
#####"hlist": {
#####	line := unparse(x.svalue,psep,psep)
#####	return line
#####	}
"htmlone": {
	# one line only -- MKR format control
	# SYMBOL("htmlone",html_statement)
	# html_statement ::= html_command | html_group
	line := unparse(x.svalue,psep,psep)
	return line
	}
"html": {
	# SYMBOL("html",html_statement)
	# html_statement ::= html_command | html_text
	line := unparse(x.svalue,psep,psep)
	return line
	}
"html_statement": {
	# SYMBOL("html_statement",html_statement)
	# html_statement ::= html_simple | html_complex
	line := unparse(x.svalue,psep,psep)
	return line
	}
"html_simple": {
	# SYMBOL("html_simple",["<",htag,harg,"/",">"])
	line := unparse(x.svalue[1],psep,psep)
	line ||:= unparse(x.svalue[2],psep,psep)
	line ||:= psep||unparse(x.svalue[3],psep,psep)
	line ||:= psep||unparse(x.svalue[4:0],psep,psep)
	return line
	}
"html_end": {
	# SYMBOL("html_end",["<","/",htmlword,">"])
	line := unparse(x.svalue,psep,psep)
	return line
	}
"html_compound": {
	# SYMBOL("html_compound",[html_commnad,html_list,html_end])
	line := unparse(x.svalue,psep,psep)
	return line
	}
"html_text": {
	# SYMBOL("html_text",[html_command,htxt,html_end])
	line := unparse(x.svalue,psep,psep)
	return line
	}
"html_null": {
	# SYMBOL("html_compound",[html_commnad,html_end])
	line := unparse(x.svalue,psep,psep)
	return line
	}
"html_list": {
	# SYMBOL("html_list",html_list)
	line := unparse(x.svalue,psep,psep)
	return line
	}
"html_command": {
	# SYMBOL("html_command",["<",htag,harg,">"])
	line := unparse(x.svalue[1],psep,psep)
	line ||:= unparse(x.svalue[2],psep,psep)
	line ||:= psep||unparse(x.svalue[3],psep,psep)
	line ||:= unparse(x.svalue[4],psep,psep)
	return line
	}
"html_group": {
	# SYMBOL("html_group",[htxt,"<",hend,">"])
	line := unparse(x.svalue[1],psep,psep)
	line ||:= psep||unparse(x.svalue[2],psep,psep)
	line ||:= unparse(x.svalue[3],psep,psep)
	line ||:= unparse(x.svalue[4],psep,psep)
	return line
	}
"htag": {
	# SYMBOL("htag",htmlword)
	line := unparse(x.svalue,psep,psep)
	return line
	}
"harg": {
	# SYMBOL("harg",html_nvlist)
	line := ""
	every line ||:= psep||unparse(!x.svalue,"",psep)
	return line
	}
"htxt": {
	# SYMBOL("htxt",html_phrase)
	line := htxt_unparse(x)
	return line
	}

"rdfsentence": {
	# SYMBOL("rdfsentence",rdfstatement)
	# rdfstatement isa list of rdfphrase with separator=blank
	line := unparse(x.svalue,psep,psep)
	#####line := ""
	#####y := x.svalue
	#####n := *y
	#####i := 0
	#####every z := !y do {
	#####	i +:= 1
	#####	line ||:= unparse(z,psep,psep)
	#####	if i < n then
	#####		line ||:= psep
	#####}
	return line
	}
"rdfphrase": {
	# SYMBOL("rdfphrase",rp)
	# rp ::= html_command | html_text
	line := unparse(x.svalue,psep,psep)
	return line
	}
("nt"|"rdftriple"): {
	# SYMBOL("rdftriple",[subject,property,value])
	line := unparse(x.svalue[1],psep,psep)
	line ||:= psep||unparse(x.svalue[2],psep,psep)
	line ||:= psep||unparse(x.svalue[3],psep,psep)
	return line
	}
"rdfdescription": {
	# SYMBOL("rdfdescription",[m_html()])
	line := unparse(x.svalue[1],psep,psep)
	return line
	}
"rdfpv": {
	# SYMBOL("rdfpv",[m_html_group()])
	line := unparse(x.svalue[1],psep,psep)
	return line
	}
"mcf": {
	# SYMBOL("mcf",[property:,value])
	line := unparse(x.svalue[1],psep,psep)
	line ||:= psep||unparse(x.svalue[2],psep,psep)
	return line
	}
"bracket": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}
"brace": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}
"notbrace": {  # "not" brace
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	return line
	}
"paren": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}
"angle": { # SYMBOL("angle",["<",list,">"])
	line := unparse(x.svalue,psep,psep)
	return line
	}
"subject": { # SYMBOL("subject",phraselist)
	lsep := ","  # always use comma
	return unparse(x.svalue,lsep,psep)
	}
"sp": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	return line
	}
"ppnull": { # no prepphrase
	return ""
	}
"pplist": {
	# blank-separated list
	# pplist ::= SYMBOL("pplist",[pp,...])
	# pp ::= SYMBOL("pp",[[prep],nvobject])
	# nvobject ::= SYMBOL("nvobject",[nvphrase,...])
	return unparse(x.svalue,psep,psep)
	#####line := ""
	#####n := *x.svalue
	#####i := 0
	#####every y := !x.svalue do {
	#####	i +:= 1
	#####	line ||:= unparse(y,lsep,psep)
	#####	if i < n then
	#####		line ||:= psep
	#####}
	#####return line
	}
"pp": { # preposition phrase: of with from to prod out
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	return line
	}
"part": { # partphrase ::= wphrase
	line := unparse(x.svalue[1],lsep,psep)  # string
	return line
	}
"partpp": { # partphrase ::= wphrase prep wphrase
	line := unparse(x.svalue,psep,psep)  # list of string
	return line
	}
"ho": {
	return unparse(x.svalue,lsep,psep)
	}
"honame": {
	return unparse(x.svalue,lsep,psep)
	}
"hophrase": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	return line
	}
"dir": {
	line := x.svalue
	return line
	}
"relverb": { # relation verb
	return unparse(x.svalue,lsep,psep)
	}

"nrel": { # relation infon
	# rnest isa semicolon list -- semicolon NOT removed
	rnest := x.svalue
	line := ""
	n := *rnest
	i := 0
	every y := !rnest do {
		# y isa comma list -- comma removed
		i +:= 1
		line ||:= unparse(y,lsep,psep)
		# no semicolon added here
	}
	return line
	}

"error": {
	return unparse(x.svalue,psep,psep)
	}

# sentence.icn

# state.icn
"qstatement": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	line ||:= psep||unparse(x.svalue[4],lsep,psep)
	return line
	}

# assign.icn
"qassignment": {
	return unparse(x.svalue,lsep,psep)
	}

# question.icn
"question": {
	return unparse(x.svalue,lsep,psep)
	}
"qvariable": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}
"qsubject": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}
"qverb": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}
"qobject": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}
"qksentence": {
	return "OBSOLETE(qksentence)"
	}
"qksubject": {
	return "OBSOLETE(qksubject)"
	}
"qvalue": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}
"qhlevel": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}
"qsubjectobject": {
	line := unparse(x.svalue[1],lsep,psep)
	line ||:= psep||unparse(x.svalue[2],lsep,psep)
	line ||:= psep||unparse(x.svalue[3],lsep,psep)
	return line
	}

# ifthen.icn

} # end case stype

if DEBUG=="UNPARSE" then
  writes_type(mybug,line,info||"output line")
return line
end

#--------------------------------------------------#
#--------------------------------------------------#

# string or standard Icon type or MKE record
procedure to_value(x)
#====================
# do NOT unparse standard Icon types or MKE records
# called by put_charvalue() in char.icn
local t

case t := type(x) of {
default:   { return unparse(x) }
"null":    { }
"integer": { }
"real":    { }
"string":  { }
"list":    { }
"set":     { }
"table":   { }

"WORD":    { }
"TOKEN":   { }
"SYMBOL":  { }

"PHRASE":  { }
"NVPHRASE":{ }
"VOPHRASE":{ }
"BSE":     { }
"m_BSE":   { }
"GROUP":   { }
"RELUNIT": { }
"HOUNIT":  { }

"ACTCHAR": { }
"PPOBJECT":{ }

"ARGINFO": { }
"CONCEPT": { }
}
return x
end

# string
procedure to_string(x)
#=====================
case type(x) of {
"null":    { fail }
"integer": { return x }
"real":    { return x }
"string":  { return x }
default:   { return unparse(x) }  # string
}
end

# list
procedure to_list(x)
#===================
# permit enclosing []
local y
case type(x) of {
"null":    { fail }
"list":    { return x }
"set":     { return set2list(x) }
"integer": { return [x] }
"real":    { return [x] }
"BSE":     { return bse_list(x) }
"m_BSE":   { return bse_list(mbse2bse(x)) }
default: {
	y := unparse(x)  # string
	return to_list(y)
	} # end default
"string":  {
	case x of {
	"":      { return [] }
	"[]":    { return [] }
	default: {
		if is_bracket(x) then {
			y := x[2:-1]
		} else {
			y := x
		}
		return string2list(y)  # convert.icn
		}
	} # end case x
	} # end "string"
} # end case type()
end

# set
procedure to_set(x)
#==================
local y
if y := to_list(x) then {
	return set(y)
} else {
	fail
}
end

# SYMBOL
procedure to_hierarchy(x)
#========================
# hostatement ::= h | /h
# exclusive concepts: isa, isc
local y,z
y := unparse(x)
z := parse_hierarchy(y)  # symbol.icn
return SYMBOL("ho",z)
end

# SYMBOL
procedure to_lattice(x)
#======================
# hostatement ::= h | /h
# inclusive groups: ism, isc
local y,z
y := unparse(x)
z := parse_hierarchy(y)  # symbol.icn
return SYMBOL("lattice",z)
end

# SYMBOL
procedure to_relation(x)
#=======================
# relstatement ::=  r,...; ... 
local y,z
y := unparse(x)
z := parse_relation(y)
return SYMBOL("nrel",z)
end

# SYMBOL
procedure to_nv(x)
#=================
# name op value
# op ::= = | += | -= | *=
local y,z
y := unparse(x)
z := parse_nv(y)
return SYMBOL("nv",z)
end

# TOKEN list
procedure to_word(x)
#===================
# TOKEN(ttype,tvalue)
local y,z
y := unparse(x)
z := get_word(y)
return z
end

# TOKEN list
procedure to_token(x)
#====================
# TOKEN(ttype,tvalue)
local y,z
y := to_word(x)
z := get_token(y,,"no")
return z.token
end

# SYMBOL
procedure to_symbol(x)
#=====================
# SYMBOL(stype,svalue)
local y,z
y := unparse(x)
z := parse_line(y,,"no")
return z.symbol
end
# </xmp></html>