The Tor Browser / file comparison

comparison: layout/mathml/nsMathMLOperators.cpp

layout/mathml/nsMathMLOperators.cpp

changeset 2
7e26c7da4463
equal deleted inserted replaced
-1:000000000000 0:ba9ec8534f6d
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "nsMathMLOperators.h"
7 #include "nsCOMPtr.h"
8 #include "nsDataHashtable.h"
9 #include "nsHashKeys.h"
10 #include "nsTArray.h"
11
12 #include "nsIPersistentProperties2.h"
13 #include "nsNetUtil.h"
14 #include "nsCRT.h"
15
16 // operator dictionary entry
17 struct OperatorData {
18 OperatorData(void)
19 : mFlags(0),
20 mLeadingSpace(0.0f),
21 mTrailingSpace(0.0f)
22 {
23 }
24
25 // member data
26 nsString mStr;
27 nsOperatorFlags mFlags;
28 float mLeadingSpace; // unit is em
29 float mTrailingSpace; // unit is em
30 };
31
32 static int32_t gTableRefCount = 0;
33 static uint32_t gOperatorCount = 0;
34 static OperatorData* gOperatorArray = nullptr;
35 static nsDataHashtable<nsStringHashKey, OperatorData*>* gOperatorTable = nullptr;
36 static bool gGlobalsInitialized = false;
37
38 static const char16_t kDashCh = char16_t('#');
39 static const char16_t kColonCh = char16_t(':');
40
41 static void
42 SetBooleanProperty(OperatorData* aOperatorData,
43 nsString aName)
44 {
45 if (aName.IsEmpty())
46 return;
47
48 if (aName.EqualsLiteral("stretchy") && (1 == aOperatorData->mStr.Length()))
49 aOperatorData->mFlags |= NS_MATHML_OPERATOR_STRETCHY;
50 else if (aName.EqualsLiteral("fence"))
51 aOperatorData->mFlags |= NS_MATHML_OPERATOR_FENCE;
52 else if (aName.EqualsLiteral("accent"))
53 aOperatorData->mFlags |= NS_MATHML_OPERATOR_ACCENT;
54 else if (aName.EqualsLiteral("largeop"))
55 aOperatorData->mFlags |= NS_MATHML_OPERATOR_LARGEOP;
56 else if (aName.EqualsLiteral("separator"))
57 aOperatorData->mFlags |= NS_MATHML_OPERATOR_SEPARATOR;
58 else if (aName.EqualsLiteral("movablelimits"))
59 aOperatorData->mFlags |= NS_MATHML_OPERATOR_MOVABLELIMITS;
60 else if (aName.EqualsLiteral("symmetric"))
61 aOperatorData->mFlags |= NS_MATHML_OPERATOR_SYMMETRIC;
62 else if (aName.EqualsLiteral("integral"))
63 aOperatorData->mFlags |= NS_MATHML_OPERATOR_INTEGRAL;
64 else if (aName.EqualsLiteral("mirrorable"))
65 aOperatorData->mFlags |= NS_MATHML_OPERATOR_MIRRORABLE;
66 }
67
68 static void
69 SetProperty(OperatorData* aOperatorData,
70 nsString aName,
71 nsString aValue)
72 {
73 if (aName.IsEmpty() || aValue.IsEmpty())
74 return;
75
76 // XXX These ones are not kept in the dictionary
77 // Support for these requires nsString member variables
78 // maxsize (default: infinity)
79 // minsize (default: 1)
80
81 if (aName.EqualsLiteral("direction")) {
82 if (aValue.EqualsLiteral("vertical"))
83 aOperatorData->mFlags |= NS_MATHML_OPERATOR_DIRECTION_VERTICAL;
84 else if (aValue.EqualsLiteral("horizontal"))
85 aOperatorData->mFlags |= NS_MATHML_OPERATOR_DIRECTION_HORIZONTAL;
86 else return; // invalid value
87 } else {
88 bool isLeadingSpace;
89 if (aName.EqualsLiteral("lspace"))
90 isLeadingSpace = true;
91 else if (aName.EqualsLiteral("rspace"))
92 isLeadingSpace = false;
93 else return; // input is not applicable
94
95 // aValue is assumed to be a digit from 0 to 7
96 nsresult error = NS_OK;
97 float space = aValue.ToFloat(&error) / 18.0;
98 if (NS_FAILED(error)) return;
99
100 if (isLeadingSpace)
101 aOperatorData->mLeadingSpace = space;
102 else
103 aOperatorData->mTrailingSpace = space;
104 }
105 }
106
107 static bool
108 SetOperator(OperatorData* aOperatorData,
109 nsOperatorFlags aForm,
110 const nsCString& aOperator,
111 nsString& aAttributes)
112
113 {
114 static const char16_t kNullCh = char16_t('\0');
115
116 // aOperator is in the expanded format \uNNNN\uNNNN ...
117 // First compress these Unicode points to the internal nsString format
118 int32_t i = 0;
119 nsAutoString name, value;
120 int32_t len = aOperator.Length();
121 char16_t c = aOperator[i++];
122 uint32_t state = 0;
123 char16_t uchar = 0;
124 while (i <= len) {
125 if (0 == state) {
126 if (c != '\\')
127 return false;
128 if (i < len)
129 c = aOperator[i];
130 i++;
131 if (('u' != c) && ('U' != c))
132 return false;
133 if (i < len)
134 c = aOperator[i];
135 i++;
136 state++;
137 }
138 else {
139 if (('0' <= c) && (c <= '9'))
140 uchar = (uchar << 4) | (c - '0');
141 else if (('a' <= c) && (c <= 'f'))
142 uchar = (uchar << 4) | (c - 'a' + 0x0a);
143 else if (('A' <= c) && (c <= 'F'))
144 uchar = (uchar << 4) | (c - 'A' + 0x0a);
145 else return false;
146 if (i < len)
147 c = aOperator[i];
148 i++;
149 state++;
150 if (5 == state) {
151 value.Append(uchar);
152 uchar = 0;
153 state = 0;
154 }
155 }
156 }
157 if (0 != state) return false;
158
159 // Quick return when the caller doesn't care about the attributes and just wants
160 // to know if this is a valid operator (this is the case at the first pass of the
161 // parsing of the dictionary in InitOperators())
162 if (!aForm) return true;
163
164 // Add operator to hash table
165 aOperatorData->mFlags |= aForm;
166 aOperatorData->mStr.Assign(value);
167 value.AppendInt(aForm, 10);
168 gOperatorTable->Put(value, aOperatorData);
169
170 #ifdef DEBUG
171 NS_LossyConvertUTF16toASCII str(aAttributes);
172 #endif
173 // Loop over the space-delimited list of attributes to get the name:value pairs
174 aAttributes.Append(kNullCh); // put an extra null at the end
175 char16_t* start = aAttributes.BeginWriting();
176 char16_t* end = start;
177 while ((kNullCh != *start) && (kDashCh != *start)) {
178 name.SetLength(0);
179 value.SetLength(0);
180 // skip leading space, the dash amounts to the end of the line
181 while ((kNullCh!=*start) && (kDashCh!=*start) && nsCRT::IsAsciiSpace(*start)) {
182 ++start;
183 }
184 end = start;
185 // look for ':'
186 while ((kNullCh!=*end) && (kDashCh!=*end) && !nsCRT::IsAsciiSpace(*end) &&
187 (kColonCh!=*end)) {
188 ++end;
189 }
190 // If ':' is not found, then it's a boolean property
191 bool IsBooleanProperty = (kColonCh != *end);
192 *end = kNullCh; // end segment here
193 // this segment is the name
194 if (start < end) {
195 name.Assign(start);
196 }
197 if (IsBooleanProperty) {
198 SetBooleanProperty(aOperatorData, name);
199 } else {
200 start = ++end;
201 // look for space or end of line
202 while ((kNullCh!=*end) && (kDashCh!=*end) &&
203 !nsCRT::IsAsciiSpace(*end)) {
204 ++end;
205 }
206 *end = kNullCh; // end segment here
207 if (start < end) {
208 // this segment is the value
209 value.Assign(start);
210 }
211 SetProperty(aOperatorData, name, value);
212 }
213 start = ++end;
214 }
215 return true;
216 }
217
218 static nsresult
219 InitOperators(void)
220 {
221 // Load the property file containing the Operator Dictionary
222 nsresult rv;
223 nsCOMPtr<nsIPersistentProperties> mathfontProp;
224 rv = NS_LoadPersistentPropertiesFromURISpec(getter_AddRefs(mathfontProp),
225 NS_LITERAL_CSTRING("resource://gre/res/fonts/mathfont.properties"));
226 if (NS_FAILED(rv)) return rv;
227
228 // Parse the Operator Dictionary in two passes.
229 // The first pass is to count the number of operators; the second pass is to
230 // allocate the necessary space for them and to add them in the hash table.
231 for (int32_t pass = 1; pass <= 2; pass++) {
232 OperatorData dummyData;
233 OperatorData* operatorData = &dummyData;
234 nsCOMPtr<nsISimpleEnumerator> iterator;
235 if (NS_SUCCEEDED(mathfontProp->Enumerate(getter_AddRefs(iterator)))) {
236 bool more;
237 uint32_t index = 0;
238 nsAutoCString name;
239 nsAutoString attributes;
240 while ((NS_SUCCEEDED(iterator->HasMoreElements(&more))) && more) {
241 nsCOMPtr<nsISupports> supports;
242 nsCOMPtr<nsIPropertyElement> element;
243 if (NS_SUCCEEDED(iterator->GetNext(getter_AddRefs(supports)))) {
244 element = do_QueryInterface(supports);
245 if (NS_SUCCEEDED(element->GetKey(name)) &&
246 NS_SUCCEEDED(element->GetValue(attributes))) {
247 // expected key: operator.\uNNNN.{infix,postfix,prefix}
248 if ((21 <= name.Length()) && (0 == name.Find("operator.\\u"))) {
249 name.Cut(0, 9); // 9 is the length of "operator.";
250 int32_t len = name.Length();
251 nsOperatorFlags form = 0;
252 if (kNotFound != name.RFind(".infix")) {
253 form = NS_MATHML_OPERATOR_FORM_INFIX;
254 len -= 6; // 6 is the length of ".infix";
255 }
256 else if (kNotFound != name.RFind(".postfix")) {
257 form = NS_MATHML_OPERATOR_FORM_POSTFIX;
258 len -= 8; // 8 is the length of ".postfix";
259 }
260 else if (kNotFound != name.RFind(".prefix")) {
261 form = NS_MATHML_OPERATOR_FORM_PREFIX;
262 len -= 7; // 7 is the length of ".prefix";
263 }
264 else continue; // input is not applicable
265 name.SetLength(len);
266 if (2 == pass) { // allocate space and start the storage
267 if (!gOperatorArray) {
268 if (0 == gOperatorCount) return NS_ERROR_UNEXPECTED;
269 gOperatorArray = new OperatorData[gOperatorCount];
270 if (!gOperatorArray) return NS_ERROR_OUT_OF_MEMORY;
271 }
272 operatorData = &gOperatorArray[index];
273 }
274 else {
275 form = 0; // to quickly return from SetOperator() at pass 1
276 }
277 // See if the operator should be retained
278 if (SetOperator(operatorData, form, name, attributes)) {
279 index++;
280 if (1 == pass) gOperatorCount = index;
281 }
282 }
283 }
284 }
285 }
286 }
287 }
288 return NS_OK;
289 }
290
291 static nsresult
292 InitGlobals()
293 {
294 gGlobalsInitialized = true;
295 nsresult rv = NS_ERROR_OUT_OF_MEMORY;
296 gOperatorTable = new nsDataHashtable<nsStringHashKey, OperatorData*>();
297 if (gOperatorTable) {
298 rv = InitOperators();
299 }
300 if (NS_FAILED(rv))
301 nsMathMLOperators::CleanUp();
302 return rv;
303 }
304
305 void
306 nsMathMLOperators::CleanUp()
307 {
308 if (gOperatorArray) {
309 delete[] gOperatorArray;
310 gOperatorArray = nullptr;
311 }
312 if (gOperatorTable) {
313 delete gOperatorTable;
314 gOperatorTable = nullptr;
315 }
316 }
317
318 void
319 nsMathMLOperators::AddRefTable(void)
320 {
321 gTableRefCount++;
322 }
323
324 void
325 nsMathMLOperators::ReleaseTable(void)
326 {
327 if (0 == --gTableRefCount) {
328 CleanUp();
329 }
330 }
331
332 static OperatorData*
333 GetOperatorData(const nsString& aOperator, nsOperatorFlags aForm)
334 {
335 nsAutoString key(aOperator);
336 key.AppendInt(aForm);
337 return gOperatorTable->Get(key);
338 }
339
340 bool
341 nsMathMLOperators::LookupOperator(const nsString& aOperator,
342 const nsOperatorFlags aForm,
343 nsOperatorFlags* aFlags,
344 float* aLeadingSpace,
345 float* aTrailingSpace)
346 {
347 if (!gGlobalsInitialized) {
348 InitGlobals();
349 }
350 if (gOperatorTable) {
351 NS_ASSERTION(aFlags && aLeadingSpace && aTrailingSpace, "bad usage");
352 NS_ASSERTION(aForm > 0 && aForm < 4, "*** invalid call ***");
353
354 // The MathML REC says:
355 // If the operator does not occur in the dictionary with the specified form,
356 // the renderer should use one of the forms which is available there, in the
357 // order of preference: infix, postfix, prefix.
358
359 OperatorData* found;
360 int32_t form = NS_MATHML_OPERATOR_GET_FORM(aForm);
361 if (!(found = GetOperatorData(aOperator, form))) {
362 if (form == NS_MATHML_OPERATOR_FORM_INFIX ||
363 !(found =
364 GetOperatorData(aOperator, NS_MATHML_OPERATOR_FORM_INFIX))) {
365 if (form == NS_MATHML_OPERATOR_FORM_POSTFIX ||
366 !(found =
367 GetOperatorData(aOperator, NS_MATHML_OPERATOR_FORM_POSTFIX))) {
368 if (form != NS_MATHML_OPERATOR_FORM_PREFIX) {
369 found = GetOperatorData(aOperator, NS_MATHML_OPERATOR_FORM_PREFIX);
370 }
371 }
372 }
373 }
374 if (found) {
375 NS_ASSERTION(found->mStr.Equals(aOperator), "bad setup");
376 *aLeadingSpace = found->mLeadingSpace;
377 *aTrailingSpace = found->mTrailingSpace;
378 *aFlags &= ~NS_MATHML_OPERATOR_FORM; // clear the form bits
379 *aFlags |= found->mFlags; // just add bits without overwriting
380 return true;
381 }
382 }
383 return false;
384 }
385
386 void
387 nsMathMLOperators::LookupOperators(const nsString& aOperator,
388 nsOperatorFlags* aFlags,
389 float* aLeadingSpace,
390 float* aTrailingSpace)
391 {
392 if (!gGlobalsInitialized) {
393 InitGlobals();
394 }
395
396 aFlags[NS_MATHML_OPERATOR_FORM_INFIX] = 0;
397 aLeadingSpace[NS_MATHML_OPERATOR_FORM_INFIX] = 0.0f;
398 aTrailingSpace[NS_MATHML_OPERATOR_FORM_INFIX] = 0.0f;
399
400 aFlags[NS_MATHML_OPERATOR_FORM_POSTFIX] = 0;
401 aLeadingSpace[NS_MATHML_OPERATOR_FORM_POSTFIX] = 0.0f;
402 aTrailingSpace[NS_MATHML_OPERATOR_FORM_POSTFIX] = 0.0f;
403
404 aFlags[NS_MATHML_OPERATOR_FORM_PREFIX] = 0;
405 aLeadingSpace[NS_MATHML_OPERATOR_FORM_PREFIX] = 0.0f;
406 aTrailingSpace[NS_MATHML_OPERATOR_FORM_PREFIX] = 0.0f;
407
408 if (gOperatorTable) {
409 OperatorData* found;
410 found = GetOperatorData(aOperator, NS_MATHML_OPERATOR_FORM_INFIX);
411 if (found) {
412 aFlags[NS_MATHML_OPERATOR_FORM_INFIX] = found->mFlags;
413 aLeadingSpace[NS_MATHML_OPERATOR_FORM_INFIX] = found->mLeadingSpace;
414 aTrailingSpace[NS_MATHML_OPERATOR_FORM_INFIX] = found->mTrailingSpace;
415 }
416 found = GetOperatorData(aOperator, NS_MATHML_OPERATOR_FORM_POSTFIX);
417 if (found) {
418 aFlags[NS_MATHML_OPERATOR_FORM_POSTFIX] = found->mFlags;
419 aLeadingSpace[NS_MATHML_OPERATOR_FORM_POSTFIX] = found->mLeadingSpace;
420 aTrailingSpace[NS_MATHML_OPERATOR_FORM_POSTFIX] = found->mTrailingSpace;
421 }
422 found = GetOperatorData(aOperator, NS_MATHML_OPERATOR_FORM_PREFIX);
423 if (found) {
424 aFlags[NS_MATHML_OPERATOR_FORM_PREFIX] = found->mFlags;
425 aLeadingSpace[NS_MATHML_OPERATOR_FORM_PREFIX] = found->mLeadingSpace;
426 aTrailingSpace[NS_MATHML_OPERATOR_FORM_PREFIX] = found->mTrailingSpace;
427 }
428 }
429 }
430
431 /* static */ bool
432 nsMathMLOperators::IsMirrorableOperator(const nsString& aOperator)
433 {
434 // LookupOperator will search infix, postfix and prefix forms of aOperator and
435 // return the first form found. It is assumed that all these forms have same
436 // mirrorability.
437 nsOperatorFlags flags = 0;
438 float dummy;
439 nsMathMLOperators::LookupOperator(aOperator,
440 NS_MATHML_OPERATOR_FORM_INFIX,
441 &flags, &dummy, &dummy);
442 return NS_MATHML_OPERATOR_IS_MIRRORABLE(flags);
443 }
444
445 /* static */ nsStretchDirection
446 nsMathMLOperators::GetStretchyDirection(const nsString& aOperator)
447 {
448 // LookupOperator will search infix, postfix and prefix forms of aOperator and
449 // return the first form found. It is assumed that all these forms have same
450 // direction.
451 nsOperatorFlags flags = 0;
452 float dummy;
453 nsMathMLOperators::LookupOperator(aOperator,
454 NS_MATHML_OPERATOR_FORM_INFIX,
455 &flags, &dummy, &dummy);
456
457 if (NS_MATHML_OPERATOR_IS_DIRECTION_VERTICAL(flags)) {
458 return NS_STRETCH_DIRECTION_VERTICAL;
459 } else if (NS_MATHML_OPERATOR_IS_DIRECTION_HORIZONTAL(flags)) {
460 return NS_STRETCH_DIRECTION_HORIZONTAL;
461 } else {
462 return NS_STRETCH_DIRECTION_UNSUPPORTED;
463 }
464 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial