OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2011 Google Inc. All rights reserved. | 2 * Copyright (C) 2011 Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
95 if (m_token->characters().isEmpty()) { | 95 if (m_token->characters().isEmpty()) { |
96 WEBVTT_ADVANCE_TO(TagState); | 96 WEBVTT_ADVANCE_TO(TagState); |
97 } else { | 97 } else { |
98 // We don't want to advance input or perform a state transit
ion - just return a (new) token. | 98 // We don't want to advance input or perform a state transit
ion - just return a (new) token. |
99 // (On the next call to nextToken we will see '<' again, but
take the other branch in this if instead.) | 99 // (On the next call to nextToken we will see '<' again, but
take the other branch in this if instead.) |
100 return emitToken(VTTTokenTypes::Character); | 100 return emitToken(VTTTokenTypes::Character); |
101 } | 101 } |
102 } else if (cc == kEndOfFileMarker) { | 102 } else if (cc == kEndOfFileMarker) { |
103 return advanceAndEmitToken(source, VTTTokenTypes::Character); | 103 return advanceAndEmitToken(source, VTTTokenTypes::Character); |
104 } else { | 104 } else { |
105 bufferCharacter(cc); | 105 m_token->appendToData(cc); |
106 WEBVTT_ADVANCE_TO(DataState); | 106 WEBVTT_ADVANCE_TO(DataState); |
107 } | 107 } |
108 } | 108 } |
109 END_STATE() | 109 END_STATE() |
110 | 110 |
111 WEBVTT_BEGIN_STATE(EscapeState) { | 111 WEBVTT_BEGIN_STATE(EscapeState) { |
112 if (cc == ';') { | 112 if (cc == ';') { |
113 if (equalLiteral(m_buffer, "&")) { | 113 if (equalLiteral(m_buffer, "&")) { |
114 bufferCharacter('&'); | 114 m_token->appendToData('&'); |
115 } else if (equalLiteral(m_buffer, "<")) { | 115 } else if (equalLiteral(m_buffer, "<")) { |
116 bufferCharacter('<'); | 116 m_token->appendToData('<'); |
117 } else if (equalLiteral(m_buffer, ">")) { | 117 } else if (equalLiteral(m_buffer, ">")) { |
118 bufferCharacter('>'); | 118 m_token->appendToData('>'); |
119 } else if (equalLiteral(m_buffer, "&lrm")) { | 119 } else if (equalLiteral(m_buffer, "&lrm")) { |
120 bufferCharacter(leftToRightMark); | 120 m_token->appendToData(leftToRightMark); |
121 } else if (equalLiteral(m_buffer, "&rlm")) { | 121 } else if (equalLiteral(m_buffer, "&rlm")) { |
122 bufferCharacter(rightToLeftMark); | 122 m_token->appendToData(rightToLeftMark); |
123 } else if (equalLiteral(m_buffer, " ")) { | 123 } else if (equalLiteral(m_buffer, " ")) { |
124 bufferCharacter(noBreakSpace); | 124 m_token->appendToData(noBreakSpace); |
125 } else { | 125 } else { |
126 m_buffer.append(static_cast<LChar>(cc)); | 126 m_buffer.append(static_cast<LChar>(cc)); |
127 m_token->appendToCharacter(m_buffer); | 127 m_token->appendToData(m_buffer); |
128 } | 128 } |
129 m_buffer.clear(); | 129 m_buffer.clear(); |
130 WEBVTT_ADVANCE_TO(DataState); | 130 WEBVTT_ADVANCE_TO(DataState); |
131 } else if (isASCIIAlphanumeric(cc)) { | 131 } else if (isASCIIAlphanumeric(cc)) { |
132 m_buffer.append(static_cast<LChar>(cc)); | 132 m_buffer.append(static_cast<LChar>(cc)); |
133 WEBVTT_ADVANCE_TO(EscapeState); | 133 WEBVTT_ADVANCE_TO(EscapeState); |
134 } else if (cc == kEndOfFileMarker) { | 134 } else if (cc == kEndOfFileMarker) { |
135 m_token->appendToCharacter(m_buffer); | 135 m_token->appendToData(m_buffer); |
136 return advanceAndEmitToken(source, VTTTokenTypes::Character); | 136 return advanceAndEmitToken(source, VTTTokenTypes::Character); |
137 } else { | 137 } else { |
138 if (!equalLiteral(m_buffer, "&")) | 138 if (!equalLiteral(m_buffer, "&")) |
139 m_token->appendToCharacter(m_buffer); | 139 m_token->appendToData(m_buffer); |
140 m_buffer.clear(); | 140 m_buffer.clear(); |
141 WEBVTT_ADVANCE_TO(DataState); | 141 WEBVTT_ADVANCE_TO(DataState); |
142 } | 142 } |
143 } | 143 } |
144 END_STATE() | 144 END_STATE() |
145 | 145 |
146 WEBVTT_BEGIN_STATE(TagState) { | 146 WEBVTT_BEGIN_STATE(TagState) { |
147 if (isTokenizerWhitespace(cc)) { | 147 if (isTokenizerWhitespace(cc)) { |
148 m_token->beginEmptyStartTag(); | 148 ASSERT(m_token->name().isEmpty()); |
149 WEBVTT_ADVANCE_TO(StartTagAnnotationState); | 149 WEBVTT_ADVANCE_TO(StartTagAnnotationState); |
150 } else if (cc == '.') { | 150 } else if (cc == '.') { |
151 m_token->beginEmptyStartTag(); | 151 ASSERT(m_token->name().isEmpty()); |
152 WEBVTT_ADVANCE_TO(StartTagClassState); | 152 WEBVTT_ADVANCE_TO(StartTagClassState); |
153 } else if (cc == '/') { | 153 } else if (cc == '/') { |
154 WEBVTT_ADVANCE_TO(EndTagState); | 154 WEBVTT_ADVANCE_TO(EndTagState); |
155 } else if (WTF::isASCIIDigit(cc)) { | 155 } else if (WTF::isASCIIDigit(cc)) { |
156 m_token->beginTimestampTag(cc); | 156 m_token->appendToData(cc); |
157 WEBVTT_ADVANCE_TO(TimestampTagState); | 157 WEBVTT_ADVANCE_TO(TimestampTagState); |
158 } else if (cc == '>' || cc == kEndOfFileMarker) { | 158 } else if (cc == '>' || cc == kEndOfFileMarker) { |
159 m_token->beginEmptyStartTag(); | 159 ASSERT(m_token->name().isEmpty()); |
160 return advanceAndEmitToken(source, VTTTokenTypes::StartTag); | 160 return advanceAndEmitToken(source, VTTTokenTypes::StartTag); |
161 } else { | 161 } else { |
162 m_token->beginStartTag(cc); | 162 m_token->appendToData(cc); |
163 WEBVTT_ADVANCE_TO(StartTagState); | 163 WEBVTT_ADVANCE_TO(StartTagState); |
164 } | 164 } |
165 } | 165 } |
166 END_STATE() | 166 END_STATE() |
167 | 167 |
168 WEBVTT_BEGIN_STATE(StartTagState) { | 168 WEBVTT_BEGIN_STATE(StartTagState) { |
169 if (isTokenizerWhitespace(cc)) { | 169 if (isTokenizerWhitespace(cc)) { |
170 WEBVTT_ADVANCE_TO(StartTagAnnotationState); | 170 WEBVTT_ADVANCE_TO(StartTagAnnotationState); |
171 } else if (cc == '.') { | 171 } else if (cc == '.') { |
172 WEBVTT_ADVANCE_TO(StartTagClassState); | 172 WEBVTT_ADVANCE_TO(StartTagClassState); |
173 } else if (cc == '>' || cc == kEndOfFileMarker) { | 173 } else if (cc == '>' || cc == kEndOfFileMarker) { |
174 return advanceAndEmitToken(source, VTTTokenTypes::StartTag); | 174 return advanceAndEmitToken(source, VTTTokenTypes::StartTag); |
175 } else { | 175 } else { |
176 m_token->appendToName(cc); | 176 m_token->appendToData(cc); |
177 WEBVTT_ADVANCE_TO(StartTagState); | 177 WEBVTT_ADVANCE_TO(StartTagState); |
178 } | 178 } |
179 } | 179 } |
180 END_STATE() | 180 END_STATE() |
181 | 181 |
182 WEBVTT_BEGIN_STATE(StartTagClassState) { | 182 WEBVTT_BEGIN_STATE(StartTagClassState) { |
183 if (isTokenizerWhitespace(cc)) { | 183 if (isTokenizerWhitespace(cc)) { |
184 m_token->addNewClass(); | 184 m_token->addNewClass(m_buffer); |
| 185 m_buffer.clear(); |
185 WEBVTT_ADVANCE_TO(StartTagAnnotationState); | 186 WEBVTT_ADVANCE_TO(StartTagAnnotationState); |
186 } else if (cc == '.') { | 187 } else if (cc == '.') { |
187 m_token->addNewClass(); | 188 m_token->addNewClass(m_buffer); |
| 189 m_buffer.clear(); |
188 WEBVTT_ADVANCE_TO(StartTagClassState); | 190 WEBVTT_ADVANCE_TO(StartTagClassState); |
189 } else if (cc == '>' || cc == kEndOfFileMarker) { | 191 } else if (cc == '>' || cc == kEndOfFileMarker) { |
190 m_token->addNewClass(); | 192 m_token->addNewClass(m_buffer); |
| 193 m_buffer.clear(); |
191 return advanceAndEmitToken(source, VTTTokenTypes::StartTag); | 194 return advanceAndEmitToken(source, VTTTokenTypes::StartTag); |
192 } else { | 195 } else { |
193 m_token->appendToClass(cc); | 196 m_buffer.append(cc); |
194 WEBVTT_ADVANCE_TO(StartTagClassState); | 197 WEBVTT_ADVANCE_TO(StartTagClassState); |
195 } | 198 } |
196 | |
197 } | 199 } |
198 END_STATE() | 200 END_STATE() |
199 | 201 |
200 WEBVTT_BEGIN_STATE(StartTagAnnotationState) { | 202 WEBVTT_BEGIN_STATE(StartTagAnnotationState) { |
201 if (cc == '>' || cc == kEndOfFileMarker) { | 203 if (cc == '>' || cc == kEndOfFileMarker) { |
202 m_token->addNewAnnotation(); | 204 m_token->addNewAnnotation(m_buffer); |
| 205 m_buffer.clear(); |
203 return advanceAndEmitToken(source, VTTTokenTypes::StartTag); | 206 return advanceAndEmitToken(source, VTTTokenTypes::StartTag); |
204 } | 207 } |
205 m_token->appendToAnnotation(cc); | 208 m_buffer.append(cc); |
206 WEBVTT_ADVANCE_TO(StartTagAnnotationState); | 209 WEBVTT_ADVANCE_TO(StartTagAnnotationState); |
207 } | 210 } |
208 END_STATE() | 211 END_STATE() |
209 | 212 |
210 WEBVTT_BEGIN_STATE(EndTagState) { | 213 WEBVTT_BEGIN_STATE(EndTagState) { |
211 if (cc == '>' || cc == kEndOfFileMarker) | 214 if (cc == '>' || cc == kEndOfFileMarker) |
212 return advanceAndEmitToken(source, VTTTokenTypes::EndTag); | 215 return advanceAndEmitToken(source, VTTTokenTypes::EndTag); |
213 m_token->appendToName(cc); | 216 m_token->appendToData(cc); |
214 WEBVTT_ADVANCE_TO(EndTagState); | 217 WEBVTT_ADVANCE_TO(EndTagState); |
215 } | 218 } |
216 END_STATE() | 219 END_STATE() |
217 | 220 |
218 WEBVTT_BEGIN_STATE(TimestampTagState) { | 221 WEBVTT_BEGIN_STATE(TimestampTagState) { |
219 if (cc == '>' || cc == kEndOfFileMarker) | 222 if (cc == '>' || cc == kEndOfFileMarker) |
220 return advanceAndEmitToken(source, VTTTokenTypes::TimestampTag); | 223 return advanceAndEmitToken(source, VTTTokenTypes::TimestampTag); |
221 m_token->appendToTimestamp(cc); | 224 m_token->appendToData(cc); |
222 WEBVTT_ADVANCE_TO(TimestampTagState); | 225 WEBVTT_ADVANCE_TO(TimestampTagState); |
223 } | 226 } |
224 END_STATE() | 227 END_STATE() |
225 | 228 |
226 } | 229 } |
227 | 230 |
228 ASSERT_NOT_REACHED(); | 231 ASSERT_NOT_REACHED(); |
229 return false; | 232 return false; |
230 } | 233 } |
231 | 234 |
232 } | 235 } |
233 | 236 |
OLD | NEW |