html-attrs-fn.sml

这是我们参加06年全国开源软件的竞赛作品

		method = getMETHOD attrVec,
		enctype = getENCTYPE attrVec,
		content = contents
	      }
	  end
    end (* local *)

  (**** Element HR ****)
    local
      val attrMap = mkAttrs [
	      ("ALIGN",		AT_NAMES["LEFT", "CENTER", "RIGHT"]),
	      ("NOSHADE",	AT_IMPLICIT),
	      ("SIZE",		AT_TEXT),
	      ("WIDTH",		AT_TEXT)
	    ]
      val getALIGN	= getNAMES HTML.HAlign.fromString (attrMap, "ALIGN")
      val getNOSHADE	= getFlag (attrMap, "NOSHADE")
      val getSIZE	= getCDATA (attrMap, "SIZE")
      val getWIDTH	= getCDATA (attrMap, "WIDTH")
    in
    fun mkHR (ctx, attrs) = let
	  val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.HR{
		align = getALIGN attrVec,
		noshade = getNOSHADE attrVec,
		size = getSIZE attrVec,
		width = getWIDTH attrVec
	      }
	  end		
    end (* local *)

  (**** Element TABLE ****)
    local
      val attrMap = mkAttrs [
	      ("ALIGN",		AT_NAMES["LEFT", "CENTER", "RIGHT"]),
	      ("BORDER",	AT_TEXT),
	      ("CELLSPACING",	AT_TEXT),
	      ("CELLPADDING",	AT_TEXT),
	      ("WIDTH",		AT_TEXT)
	    ]
      val getALIGN		= getNAMES HTML.HAlign.fromString (attrMap, "ALIGN")
      val getBORDER		= getCDATA (attrMap, "BORDER")
      val getCELLSPACING	= getCDATA (attrMap, "CELLSPACING")
      val getCELLPADDING	= getCDATA (attrMap, "CELLPADDING")
      val getWIDTH		= getCDATA (attrMap, "WIDTH")
    in
    fun mkTABLE (ctx, attrs, {caption, body}) = let
	  val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.TABLE{
		align = getALIGN attrVec,
		border = getBORDER attrVec,
		cellspacing = getCELLSPACING attrVec,
		cellpadding = getCELLPADDING attrVec,
		width = getWIDTH attrVec,
		caption = caption,
		content = body
	      }
	  end
    end (* local *)

  (**** Element CAPTION ****)
    local
      val attrMap = mkAttrs [
	      ("ALIGN",		AT_NAMES["TOP", "BOTTOM"])
	    ]
      val getALIGN	= getNAMES HTML.CaptionAlign.fromString (attrMap, "ALIGN")
    in
    fun mkCAPTION (ctx, attrs, text) = HTML.CAPTION{
	    align = getALIGN(attrListToVec(ctx, attrMap, attrs)),
	    content = text
	  }
    end (* local *)

  (**** Element TR ****)
    local
      val attrMap = mkAttrs [
	      ("ALIGN",		AT_NAMES["LEFT", "CENTER", "RIGHT"]),
	      ("VALIGN",	AT_NAMES["TOP", "MIDDLE", "BOTTOM", "BASELINE"])
	    ]
      val getALIGN	= getNAMES HTML.HAlign.fromString (attrMap, "ALIGN")
      val getVALIGN	= getNAMES HTML.CellVAlign.fromString (attrMap, "VALIGN")
    in
    fun mkTR (ctx, attrs, cells) = let
	  val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.TR{
		align = getALIGN attrVec,
		valign = getVALIGN attrVec,
		content = cells
	      }
	  end
    end (* local *)

  (**** Elements TH and TD ****)
    local
      val attrMap = mkAttrs [
	      ("ALIGN",		AT_NAMES["LEFT", "CENTER", "RIGHT"]),
	      ("COLSPAN",	AT_NUMBER),
	      ("HEIGHT",	AT_TEXT),
	      ("NOWRAP",	AT_IMPLICIT),
	      ("ROWSPAN",	AT_NUMBER),
	      ("VALIGN",	AT_NAMES["TOP", "MIDDLE", "BOTTOM", "BASELINE"]),
	      ("WIDTH",		AT_TEXT)
	    ]
      val getALIGN	= getNAMES HTML.HAlign.fromString (attrMap, "ALIGN")
      val getCOLSPAN	= getNUMBER (attrMap, "COLSPAN")
      val getHEIGHT	= getCDATA (attrMap, "HEIGHT")
      val getNOWRAP	= getFlag (attrMap, "NOWRAP")
      val getROWSPAN	= getNUMBER (attrMap, "ROWSPAN")
      val getVALIGN	= getNAMES HTML.CellVAlign.fromString (attrMap, "VALIGN")
      val getWIDTH	= getCDATA (attrMap, "WIDTH")
      fun mkCell (ctx, attrs, cells) = let
	    val attrVec = attrListToVec(ctx, attrMap, attrs)
	    in
	      { align = getALIGN attrVec,
		colspan = getCOLSPAN attrVec,
		height = getHEIGHT attrVec,
		nowrap = getNOWRAP attrVec,
		rowspan = getROWSPAN attrVec,
		valign = getVALIGN attrVec,
		width = getWIDTH attrVec,
		content = cells
	      }
	    end
    in
    fun mkTH arg = HTML.TH(mkCell arg)
    fun mkTD arg = HTML.TD(mkCell arg)
    end (* local *)

  (**** Element A ****)
    local
      val attrMap = mkAttrs [
	      ("HREF",		AT_TEXT),
	      ("NAME",		AT_TEXT),
	      ("REL",		AT_TEXT),
	      ("REV",		AT_TEXT),
	      ("TITLE",		AT_TEXT)
	    ]
      val getHREF	= getCDATA (attrMap, "HREF")
      val getNAME	= getCDATA (attrMap, "NAME")
      val getREL	= getCDATA (attrMap, "REL")
      val getREV	= getCDATA (attrMap, "REV")
      val getTITLE	= getCDATA (attrMap, "TITLE")
    in
    fun mkA (ctx, attrs, contents) = let
	  val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.A{
		name = getNAME attrVec,
		href = getHREF attrVec,
		rel = getREL attrVec,
		rev = getREV attrVec,
		title = getTITLE attrVec,
		content = contents
	      }
	  end
    end (* local *)

  (**** Element IMG ****)
     local
      val attrMap = mkAttrs [
	      ("ALIGN",		AT_NAMES["TOP", "MIDDLE", "BOTTOM", "LEFT", "RIGHT"]),
	      ("ALT",		AT_TEXT),
	      ("BORDER",	AT_TEXT),
	      ("HEIGHT",	AT_TEXT),
	      ("HSPACE",	AT_TEXT),
	      ("ISMAP",		AT_IMPLICIT),
	      ("SRC",		AT_TEXT),
	      ("USEMAP",	AT_TEXT),
	      ("VSPACE",	AT_TEXT),
	      ("WIDTH",		AT_TEXT)
	    ]
      val getALIGN	= getNAMES HTML.IAlign.fromString (attrMap, "ALIGN")
      val getALT	= getCDATA (attrMap, "ALT")
      val getBORDER	= getCDATA (attrMap, "BORDER")
      val getHEIGHT	= getCDATA (attrMap, "HEIGHT")
      val getHSPACE	= getCDATA (attrMap, "HSPACE")
      val getISMAP	= getFlag (attrMap, "ISMAP")
      val getSRC	= require (getCDATA, attrMap, "SRC", "")
      val getUSEMAP	= getCDATA (attrMap, "USEMAP")
      val getVSPACE	= getCDATA (attrMap, "VSPACE")
      val getWIDTH	= getCDATA (attrMap, "WIDTH")
    in
    fun mkIMG (ctx, attrs) = let
	  val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.IMG{
		src = getSRC attrVec,
		alt = getALT attrVec,
		align = getALIGN attrVec,
		height = getHEIGHT attrVec,
		width = getWIDTH attrVec,
		border = getBORDER attrVec,
		hspace = getHSPACE attrVec,
		vspace = getVSPACE attrVec,
		usemap = getUSEMAP attrVec,
		ismap = getISMAP attrVec
	      }
	  end
    end (* local *)

  (**** Element APPLET ****)
    local
      val attrMap = mkAttrs [
	      ("ALIGN",		AT_NAMES["TOP", "MIDDLE", "BOTTOM", "LEFT", "RIGHT"]),
	      ("ALT",		AT_TEXT),
	      ("CODE",		AT_TEXT),
	      ("CODEBASE",	AT_TEXT),
	      ("HEIGHT",	AT_TEXT),
	      ("HSPACE",	AT_TEXT),
	      ("NAME",		AT_TEXT),
	      ("VSPACE",	AT_TEXT),
	      ("WIDTH",		AT_TEXT)
	    ]
      val getALIGN	= getNAMES HTML.IAlign.fromString (attrMap, "ALIGN")
      val getALT	= getCDATA (attrMap, "ALT")
      val getCODE	= require (getCDATA, attrMap, "CODE", "")
      val getCODEBASE	= getCDATA (attrMap, "CODEBASE")
      val getHEIGHT	= getCDATA (attrMap, "HEIGHT")
      val getHSPACE	= getCDATA (attrMap, "HSPACE")
      val getNAME	= getCDATA (attrMap, "NAME")
      val getVSPACE	= getCDATA (attrMap, "VSPACE")
      val getWIDTH	= getCDATA (attrMap, "WIDTH")
    in
    fun mkAPPLET (ctx, attrs, content) = let
	  val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.APPLET{
		codebase = getCODEBASE attrVec,
		code = getCODE attrVec,
		name = getNAME attrVec,
		alt = getALT attrVec,
		align = getALIGN attrVec,
		height = getHEIGHT attrVec,
		width = getWIDTH attrVec,
		hspace = getHSPACE attrVec,
		vspace = getVSPACE attrVec,
		content = content
	      }
	  end
    end (* local *)

  (**** Element PARAM ****)
    local
      val attrMap = mkAttrs [
	      ("NAME",		AT_TEXT),
	      ("VALUE",		AT_TEXT)
	    ]
      val getNAME	= require (getCDATA, attrMap, "NAME", "")
      val getVALUE	= getCDATA (attrMap, "VALUE")
    in
    fun mkPARAM (ctx, attrs) = let
	  val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.PARAM{
		name = getNAME attrVec,
		value = getVALUE attrVec
	      }
	  end
    end (* local *)

  (**** Element FONT ****)
    local
      val attrMap = mkAttrs [
	      ("COLOR",		AT_TEXT),
	      ("SIZE",		AT_TEXT)
	    ]
      val getCOLOR	= getCDATA (attrMap, "COLOR")
      val getSIZE	= getCDATA (attrMap, "SIZE")
    in
    fun mkFONT (ctx, attrs, content) = let
	  val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.FONT{
		size = getSIZE attrVec,
		color = getCOLOR attrVec,
		content = content
	      }
	  end
    end (* local *)

  (**** Element BASEFONT ****)
    local
      val attrMap = mkAttrs [
	      ("SIZE",		AT_TEXT)
	    ]
      val getSIZE	= getCDATA (attrMap, "SIZE")
    in
    fun mkBASEFONT (ctx, attrs, content) = HTML.BASEFONT{
	    size = getSIZE(attrListToVec(ctx, attrMap, attrs)),
	    content = content
	  }
    end (* local *)

  (**** Element BR ****)
    local
      val attrMap = mkAttrs [
	      ("CLEAR",		AT_NAMES["LEFT", "RIGHT", "ALL", "NONE"])
	    ]
      val getCLEAR = getNAMES HTML.TextFlowCtl.fromString (attrMap, "CLEAR")
    in
    fun mkBR (ctx, attrs) = HTML.BR{
	    clear = getCLEAR(attrListToVec(ctx, attrMap, attrs))
	  }
    end (* local *)

  (**** Element MAP ****)
    local
      val attrMap = mkAttrs [
	      ("NAME",		AT_TEXT)
	    ]
      val getNAME	= getCDATA (attrMap, "NAME")
    in
    fun mkMAP (ctx, attrs, content) = HTML.MAP{
	    name = getNAME (attrListToVec(ctx, attrMap, attrs)),
	    content = content
	  }
    end (* local *)

  (**** Element INPUT ****)
    local
      val attrMap = mkAttrs [
	      ("ALIGN",		AT_NAMES["TOP", "MIDDLE", "BOTTOM", "LEFT", "RIGHT"]),
	      ("CHECKED",	AT_IMPLICIT),
	      ("MAXLENGTH",	AT_NUMBER),
	      ("NAME",		AT_TEXT),
	      ("SIZE",		AT_TEXT),
	      ("SRC",		AT_TEXT),
	      ("TYPE",		AT_NAMES[
				    "TEXT", "PASSWORD", "CHECKBOX",
				    "RADIO", "SUBMIT", "RESET",
				    "FILE", "HIDDEN", "IMAGE"
				  ]),
	      ("VALUE",		AT_TEXT)
	    ]
      val getALIGN	= getNAMES HTML.IAlign.fromString (attrMap, "ALIGN")
      val getCHECKED	= getFlag (attrMap, "CHECKED")
      val getMAXLENGTH	= getNUMBER (attrMap, "MAXLENGTH")
      val getNAME	= getCDATA (attrMap, "NAME")
      val getSIZE	= getCDATA (attrMap, "SIZE")
      val getSRC	= getCDATA (attrMap, "SRC")
      val getTYPE	= getNAMES HTML.InputType.fromString (attrMap, "TYPE")
      val getVALUE	= getCDATA (attrMap, "VALUE")
    in
    fun mkINPUT (ctx, attrs) = let
	  val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.INPUT{
		ty = getTYPE attrVec,
		name = getNAME attrVec,
		value = getVALUE attrVec,
		src = getSRC attrVec,
		checked = getCHECKED attrVec,
		size = getSIZE attrVec,
		maxlength = getMAXLENGTH attrVec,
		align = getALIGN attrVec
	      }
	  end
    end (* local *)

  (**** Element SELECT ****)
    local
      val attrMap = mkAttrs [
	      ("NAME",		AT_TEXT),
	      ("SIZE",		AT_TEXT)
	    ]
      val getNAME	= require (getCDATA, attrMap, "NAME", "")
      val getSIZE	= getNUMBER (attrMap, "SIZE")
    in
    fun mkSELECT (ctx, attrs, contents) = let
	  val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.SELECT{
		name = getNAME attrVec,
		size = getSIZE attrVec,
		content = contents
	      }
	  end
    end (* local *)

  (**** Element TEXTAREA ****)
    local
      val attrMap = mkAttrs [
	      ("NAME",		AT_TEXT),
	      ("ROWS",		AT_NUMBER),
	      ("COLS",		AT_NUMBER)
	    ]
      val getNAME	= require (getCDATA, attrMap, "NAME", "")
      val getROWS	= require (getNUMBER, attrMap, "ROWS", 0)
      val getCOLS	= require (getNUMBER, attrMap, "COLS", 0)
    in
    fun mkTEXTAREA (ctx, attrs, contents) = let
	  val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.TEXTAREA{
		name = getNAME attrVec,
		rows = getROWS attrVec,
		cols = getCOLS attrVec,
		content = contents
	      }
	  end
    end (* local *)

  (**** Element AREA ****)
    local
      val attrMap = mkAttrs [
	      ("ALT",		AT_TEXT),
	      ("COORDS",	AT_TEXT),
	      ("HREF",		AT_TEXT),
	      ("NOHREF",	AT_IMPLICIT),
	      ("SHAPE",		AT_NAMES["RECT", "CIRCLE", "POLY", "DEFAULT"])
	    ]
      val getALT	= require (getCDATA, attrMap, "ALT", "")
      val getCOORDS	= getCDATA (attrMap, "COORDS")
      val getHREF	= getCDATA (attrMap, "HREF")
      val getNOHREF	= getFlag (attrMap, "NOHREF")
      val getSHAPE	= getNAMES HTML.Shape.fromString (attrMap, "SHAPE")
    in
    fun mkAREA (ctx, attrs) = let
	   val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.AREA{
		shape = getSHAPE attrVec,
		coords = getCOORDS attrVec,
		href = getHREF attrVec,
		nohref = getNOHREF attrVec,
		alt = getALT attrVec
	      }
	  end
    end (* local *)

  (**** Element OPTION ****)
    local
      val attrMap = mkAttrs [
	      ("SELECTED",	AT_IMPLICIT),
	      ("VALUE",		AT_TEXT)
	    ]
      val getSELECTED	= getFlag (attrMap, "SELECTED")
      val getVALUE	= getCDATA (attrMap, "VALUE")
    in
    fun mkOPTION (ctx, attrs, contents) = let
	  val attrVec = attrListToVec(ctx, attrMap, attrs)
	  in
	    HTML.OPTION{
		selected = getSELECTED attrVec,
		value = getVALUE attrVec,
		content = contents
	      }
	  end
    end (* local *)

  end