Source file src/pkg/html/template/context.go
1 // Copyright 2011 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package template 6 7 import ( 8 "fmt" 9 ) 10 11 // context describes the state an HTML parser must be in when it reaches the 12 // portion of HTML produced by evaluating a particular template node. 13 // 14 // The zero value of type context is the start context for a template that 15 // produces an HTML fragment as defined at 16 // http://www.w3.org/TR/html5/the-end.html#parsing-html-fragments 17 // where the context element is null. 18 type context struct { 19 state state 20 delim delim 21 urlPart urlPart 22 jsCtx jsCtx 23 attr attr 24 element element 25 err *Error 26 } 27 28 func (c context) String() string { 29 return fmt.Sprintf("{%v %v %v %v %v %v %v}", c.state, c.delim, c.urlPart, c.jsCtx, c.attr, c.element, c.err) 30 } 31 32 // eq returns whether two contexts are equal. 33 func (c context) eq(d context) bool { 34 return c.state == d.state && 35 c.delim == d.delim && 36 c.urlPart == d.urlPart && 37 c.jsCtx == d.jsCtx && 38 c.attr == d.attr && 39 c.element == d.element && 40 c.err == d.err 41 } 42 43 // mangle produces an identifier that includes a suffix that distinguishes it 44 // from template names mangled with different contexts. 45 func (c context) mangle(templateName string) string { 46 // The mangled name for the default context is the input templateName. 47 if c.state == stateText { 48 return templateName 49 } 50 s := templateName + "$htmltemplate_" + c.state.String() 51 if c.delim != 0 { 52 s += "_" + c.delim.String() 53 } 54 if c.urlPart != 0 { 55 s += "_" + c.urlPart.String() 56 } 57 if c.jsCtx != 0 { 58 s += "_" + c.jsCtx.String() 59 } 60 if c.attr != 0 { 61 s += "_" + c.attr.String() 62 } 63 if c.element != 0 { 64 s += "_" + c.element.String() 65 } 66 return s 67 } 68 69 // state describes a high-level HTML parser state. 70 // 71 // It bounds the top of the element stack, and by extension the HTML insertion 72 // mode, but also contains state that does not correspond to anything in the 73 // HTML5 parsing algorithm because a single token production in the HTML 74 // grammar may contain embedded actions in a template. For instance, the quoted 75 // HTML attribute produced by 76 // <div title="Hello {{.World}}"> 77 // is a single token in HTML's grammar but in a template spans several nodes. 78 type state uint8 79 80 const ( 81 // stateText is parsed character data. An HTML parser is in 82 // this state when its parse position is outside an HTML tag, 83 // directive, comment, and special element body. 84 stateText state = iota 85 // stateTag occurs before an HTML attribute or the end of a tag. 86 stateTag 87 // stateAttrName occurs inside an attribute name. 88 // It occurs between the ^'s in ` ^name^ = value`. 89 stateAttrName 90 // stateAfterName occurs after an attr name has ended but before any 91 // equals sign. It occurs between the ^'s in ` name^ ^= value`. 92 stateAfterName 93 // stateBeforeValue occurs after the equals sign but before the value. 94 // It occurs between the ^'s in ` name =^ ^value`. 95 stateBeforeValue 96 // stateHTMLCmt occurs inside an <!-- HTML comment -->. 97 stateHTMLCmt 98 // stateRCDATA occurs inside an RCDATA element (<textarea> or <title>) 99 // as described at http://dev.w3.org/html5/spec/syntax.html#elements-0 100 stateRCDATA 101 // stateAttr occurs inside an HTML attribute whose content is text. 102 stateAttr 103 // stateURL occurs inside an HTML attribute whose content is a URL. 104 stateURL 105 // stateJS occurs inside an event handler or script element. 106 stateJS 107 // stateJSDqStr occurs inside a JavaScript double quoted string. 108 stateJSDqStr 109 // stateJSSqStr occurs inside a JavaScript single quoted string. 110 stateJSSqStr 111 // stateJSRegexp occurs inside a JavaScript regexp literal. 112 stateJSRegexp 113 // stateJSBlockCmt occurs inside a JavaScript /* block comment */. 114 stateJSBlockCmt 115 // stateJSLineCmt occurs inside a JavaScript // line comment. 116 stateJSLineCmt 117 // stateCSS occurs inside a <style> element or style attribute. 118 stateCSS 119 // stateCSSDqStr occurs inside a CSS double quoted string. 120 stateCSSDqStr 121 // stateCSSSqStr occurs inside a CSS single quoted string. 122 stateCSSSqStr 123 // stateCSSDqURL occurs inside a CSS double quoted url("..."). 124 stateCSSDqURL 125 // stateCSSSqURL occurs inside a CSS single quoted url('...'). 126 stateCSSSqURL 127 // stateCSSURL occurs inside a CSS unquoted url(...). 128 stateCSSURL 129 // stateCSSBlockCmt occurs inside a CSS /* block comment */. 130 stateCSSBlockCmt 131 // stateCSSLineCmt occurs inside a CSS // line comment. 132 stateCSSLineCmt 133 // stateError is an infectious error state outside any valid 134 // HTML/CSS/JS construct. 135 stateError 136 ) 137 138 var stateNames = [...]string{ 139 stateText: "stateText", 140 stateTag: "stateTag", 141 stateAttrName: "stateAttrName", 142 stateAfterName: "stateAfterName", 143 stateBeforeValue: "stateBeforeValue", 144 stateHTMLCmt: "stateHTMLCmt", 145 stateRCDATA: "stateRCDATA", 146 stateAttr: "stateAttr", 147 stateURL: "stateURL", 148 stateJS: "stateJS", 149 stateJSDqStr: "stateJSDqStr", 150 stateJSSqStr: "stateJSSqStr", 151 stateJSRegexp: "stateJSRegexp", 152 stateJSBlockCmt: "stateJSBlockCmt", 153 stateJSLineCmt: "stateJSLineCmt", 154 stateCSS: "stateCSS", 155 stateCSSDqStr: "stateCSSDqStr", 156 stateCSSSqStr: "stateCSSSqStr", 157 stateCSSDqURL: "stateCSSDqURL", 158 stateCSSSqURL: "stateCSSSqURL", 159 stateCSSURL: "stateCSSURL", 160 stateCSSBlockCmt: "stateCSSBlockCmt", 161 stateCSSLineCmt: "stateCSSLineCmt", 162 stateError: "stateError", 163 } 164 165 func (s state) String() string { 166 if int(s) < len(stateNames) { 167 return stateNames[s] 168 } 169 return fmt.Sprintf("illegal state %d", int(s)) 170 } 171 172 // isComment is true for any state that contains content meant for template 173 // authors & maintainers, not for end-users or machines. 174 func isComment(s state) bool { 175 switch s { 176 case stateHTMLCmt, stateJSBlockCmt, stateJSLineCmt, stateCSSBlockCmt, stateCSSLineCmt: 177 return true 178 } 179 return false 180 } 181 182 // isInTag return whether s occurs solely inside an HTML tag. 183 func isInTag(s state) bool { 184 switch s { 185 case stateTag, stateAttrName, stateAfterName, stateBeforeValue, stateAttr: 186 return true 187 } 188 return false 189 } 190 191 // delim is the delimiter that will end the current HTML attribute. 192 type delim uint8 193 194 const ( 195 // delimNone occurs outside any attribute. 196 delimNone delim = iota 197 // delimDoubleQuote occurs when a double quote (") closes the attribute. 198 delimDoubleQuote 199 // delimSingleQuote occurs when a single quote (') closes the attribute. 200 delimSingleQuote 201 // delimSpaceOrTagEnd occurs when a space or right angle bracket (>) 202 // closes the attribute. 203 delimSpaceOrTagEnd 204 ) 205 206 var delimNames = [...]string{ 207 delimNone: "delimNone", 208 delimDoubleQuote: "delimDoubleQuote", 209 delimSingleQuote: "delimSingleQuote", 210 delimSpaceOrTagEnd: "delimSpaceOrTagEnd", 211 } 212 213 func (d delim) String() string { 214 if int(d) < len(delimNames) { 215 return delimNames[d] 216 } 217 return fmt.Sprintf("illegal delim %d", int(d)) 218 } 219 220 // urlPart identifies a part in an RFC 3986 hierarchical URL to allow different 221 // encoding strategies. 222 type urlPart uint8 223 224 const ( 225 // urlPartNone occurs when not in a URL, or possibly at the start: 226 // ^ in "^http://auth/path?k=v#frag". 227 urlPartNone urlPart = iota 228 // urlPartPreQuery occurs in the scheme, authority, or path; between the 229 // ^s in "h^ttp://auth/path^?k=v#frag". 230 urlPartPreQuery 231 // urlPartQueryOrFrag occurs in the query portion between the ^s in 232 // "http://auth/path?^k=v#frag^". 233 urlPartQueryOrFrag 234 // urlPartUnknown occurs due to joining of contexts both before and 235 // after the query separator. 236 urlPartUnknown 237 ) 238 239 var urlPartNames = [...]string{ 240 urlPartNone: "urlPartNone", 241 urlPartPreQuery: "urlPartPreQuery", 242 urlPartQueryOrFrag: "urlPartQueryOrFrag", 243 urlPartUnknown: "urlPartUnknown", 244 } 245 246 func (u urlPart) String() string { 247 if int(u) < len(urlPartNames) { 248 return urlPartNames[u] 249 } 250 return fmt.Sprintf("illegal urlPart %d", int(u)) 251 } 252 253 // jsCtx determines whether a '/' starts a regular expression literal or a 254 // division operator. 255 type jsCtx uint8 256 257 const ( 258 // jsCtxRegexp occurs where a '/' would start a regexp literal. 259 jsCtxRegexp jsCtx = iota 260 // jsCtxDivOp occurs where a '/' would start a division operator. 261 jsCtxDivOp 262 // jsCtxUnknown occurs where a '/' is ambiguous due to context joining. 263 jsCtxUnknown 264 ) 265 266 func (c jsCtx) String() string { 267 switch c { 268 case jsCtxRegexp: 269 return "jsCtxRegexp" 270 case jsCtxDivOp: 271 return "jsCtxDivOp" 272 case jsCtxUnknown: 273 return "jsCtxUnknown" 274 } 275 return fmt.Sprintf("illegal jsCtx %d", int(c)) 276 } 277 278 // element identifies the HTML element when inside a start tag or special body. 279 // Certain HTML element (for example <script> and <style>) have bodies that are 280 // treated differently from stateText so the element type is necessary to 281 // transition into the correct context at the end of a tag and to identify the 282 // end delimiter for the body. 283 type element uint8 284 285 const ( 286 // elementNone occurs outside a special tag or special element body. 287 elementNone element = iota 288 // elementScript corresponds to the raw text <script> element. 289 elementScript 290 // elementStyle corresponds to the raw text <style> element. 291 elementStyle 292 // elementTextarea corresponds to the RCDATA <textarea> element. 293 elementTextarea 294 // elementTitle corresponds to the RCDATA <title> element. 295 elementTitle 296 ) 297 298 var elementNames = [...]string{ 299 elementNone: "elementNone", 300 elementScript: "elementScript", 301 elementStyle: "elementStyle", 302 elementTextarea: "elementTextarea", 303 elementTitle: "elementTitle", 304 } 305 306 func (e element) String() string { 307 if int(e) < len(elementNames) { 308 return elementNames[e] 309 } 310 return fmt.Sprintf("illegal element %d", int(e)) 311 } 312 313 // attr identifies the most recent HTML attribute when inside a start tag. 314 type attr uint8 315 316 const ( 317 // attrNone corresponds to a normal attribute or no attribute. 318 attrNone attr = iota 319 // attrScript corresponds to an event handler attribute. 320 attrScript 321 // attrStyle corresponds to the style attribute whose value is CSS. 322 attrStyle 323 // attrURL corresponds to an attribute whose value is a URL. 324 attrURL 325 ) 326 327 var attrNames = [...]string{ 328 attrNone: "attrNone", 329 attrScript: "attrScript", 330 attrStyle: "attrStyle", 331 attrURL: "attrURL", 332 } 333 334 func (a attr) String() string { 335 if int(a) < len(attrNames) { 336 return attrNames[a] 337 } 338 return fmt.Sprintf("illegal attr %d", int(a)) 339 }