469 lines
15 KiB
C++
469 lines
15 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "nsMathMLOperators.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsDataHashtable.h"
|
|
#include "nsHashKeys.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsTArray.h"
|
|
|
|
#include "nsIPersistentProperties2.h"
|
|
#include "nsISimpleEnumerator.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsCRT.h"
|
|
|
|
// operator dictionary entry
|
|
struct OperatorData {
|
|
OperatorData(void)
|
|
: mFlags(0),
|
|
mLeadingSpace(0.0f),
|
|
mTrailingSpace(0.0f)
|
|
{
|
|
}
|
|
|
|
// member data
|
|
nsString mStr;
|
|
nsOperatorFlags mFlags;
|
|
float mLeadingSpace; // unit is em
|
|
float mTrailingSpace; // unit is em
|
|
};
|
|
|
|
static int32_t gTableRefCount = 0;
|
|
static uint32_t gOperatorCount = 0;
|
|
static OperatorData* gOperatorArray = nullptr;
|
|
static nsDataHashtable<nsStringHashKey, OperatorData*>* gOperatorTable = nullptr;
|
|
static bool gGlobalsInitialized = false;
|
|
|
|
static const char16_t kDashCh = char16_t('#');
|
|
static const char16_t kColonCh = char16_t(':');
|
|
|
|
static void
|
|
SetBooleanProperty(OperatorData* aOperatorData,
|
|
nsString aName)
|
|
{
|
|
if (aName.IsEmpty())
|
|
return;
|
|
|
|
if (aName.EqualsLiteral("stretchy") && (1 == aOperatorData->mStr.Length()))
|
|
aOperatorData->mFlags |= NS_MATHML_OPERATOR_STRETCHY;
|
|
else if (aName.EqualsLiteral("fence"))
|
|
aOperatorData->mFlags |= NS_MATHML_OPERATOR_FENCE;
|
|
else if (aName.EqualsLiteral("accent"))
|
|
aOperatorData->mFlags |= NS_MATHML_OPERATOR_ACCENT;
|
|
else if (aName.EqualsLiteral("largeop"))
|
|
aOperatorData->mFlags |= NS_MATHML_OPERATOR_LARGEOP;
|
|
else if (aName.EqualsLiteral("separator"))
|
|
aOperatorData->mFlags |= NS_MATHML_OPERATOR_SEPARATOR;
|
|
else if (aName.EqualsLiteral("movablelimits"))
|
|
aOperatorData->mFlags |= NS_MATHML_OPERATOR_MOVABLELIMITS;
|
|
else if (aName.EqualsLiteral("symmetric"))
|
|
aOperatorData->mFlags |= NS_MATHML_OPERATOR_SYMMETRIC;
|
|
else if (aName.EqualsLiteral("integral"))
|
|
aOperatorData->mFlags |= NS_MATHML_OPERATOR_INTEGRAL;
|
|
else if (aName.EqualsLiteral("mirrorable"))
|
|
aOperatorData->mFlags |= NS_MATHML_OPERATOR_MIRRORABLE;
|
|
}
|
|
|
|
static void
|
|
SetProperty(OperatorData* aOperatorData,
|
|
nsString aName,
|
|
nsString aValue)
|
|
{
|
|
if (aName.IsEmpty() || aValue.IsEmpty())
|
|
return;
|
|
|
|
// XXX These ones are not kept in the dictionary
|
|
// Support for these requires nsString member variables
|
|
// maxsize (default: infinity)
|
|
// minsize (default: 1)
|
|
|
|
if (aName.EqualsLiteral("direction")) {
|
|
if (aValue.EqualsLiteral("vertical"))
|
|
aOperatorData->mFlags |= NS_MATHML_OPERATOR_DIRECTION_VERTICAL;
|
|
else if (aValue.EqualsLiteral("horizontal"))
|
|
aOperatorData->mFlags |= NS_MATHML_OPERATOR_DIRECTION_HORIZONTAL;
|
|
else return; // invalid value
|
|
} else {
|
|
bool isLeadingSpace;
|
|
if (aName.EqualsLiteral("lspace"))
|
|
isLeadingSpace = true;
|
|
else if (aName.EqualsLiteral("rspace"))
|
|
isLeadingSpace = false;
|
|
else return; // input is not applicable
|
|
|
|
// aValue is assumed to be a digit from 0 to 7
|
|
nsresult error = NS_OK;
|
|
float space = aValue.ToFloat(&error) / 18.0;
|
|
if (NS_FAILED(error)) return;
|
|
|
|
if (isLeadingSpace)
|
|
aOperatorData->mLeadingSpace = space;
|
|
else
|
|
aOperatorData->mTrailingSpace = space;
|
|
}
|
|
}
|
|
|
|
static bool
|
|
SetOperator(OperatorData* aOperatorData,
|
|
nsOperatorFlags aForm,
|
|
const nsCString& aOperator,
|
|
nsString& aAttributes)
|
|
|
|
{
|
|
static const char16_t kNullCh = char16_t('\0');
|
|
|
|
// aOperator is in the expanded format \uNNNN\uNNNN ...
|
|
// First compress these Unicode points to the internal nsString format
|
|
int32_t i = 0;
|
|
nsAutoString name, value;
|
|
int32_t len = aOperator.Length();
|
|
char16_t c = aOperator[i++];
|
|
uint32_t state = 0;
|
|
char16_t uchar = 0;
|
|
while (i <= len) {
|
|
if (0 == state) {
|
|
if (c != '\\')
|
|
return false;
|
|
if (i < len)
|
|
c = aOperator[i];
|
|
i++;
|
|
if (('u' != c) && ('U' != c))
|
|
return false;
|
|
if (i < len)
|
|
c = aOperator[i];
|
|
i++;
|
|
state++;
|
|
}
|
|
else {
|
|
if (('0' <= c) && (c <= '9'))
|
|
uchar = (uchar << 4) | (c - '0');
|
|
else if (('a' <= c) && (c <= 'f'))
|
|
uchar = (uchar << 4) | (c - 'a' + 0x0a);
|
|
else if (('A' <= c) && (c <= 'F'))
|
|
uchar = (uchar << 4) | (c - 'A' + 0x0a);
|
|
else return false;
|
|
if (i < len)
|
|
c = aOperator[i];
|
|
i++;
|
|
state++;
|
|
if (5 == state) {
|
|
value.Append(uchar);
|
|
uchar = 0;
|
|
state = 0;
|
|
}
|
|
}
|
|
}
|
|
if (0 != state) return false;
|
|
|
|
// Quick return when the caller doesn't care about the attributes and just wants
|
|
// to know if this is a valid operator (this is the case at the first pass of the
|
|
// parsing of the dictionary in InitOperators())
|
|
if (!aForm) return true;
|
|
|
|
// Add operator to hash table
|
|
aOperatorData->mFlags |= aForm;
|
|
aOperatorData->mStr.Assign(value);
|
|
value.AppendInt(aForm, 10);
|
|
gOperatorTable->Put(value, aOperatorData);
|
|
|
|
#ifdef DEBUG
|
|
NS_LossyConvertUTF16toASCII str(aAttributes);
|
|
#endif
|
|
// Loop over the space-delimited list of attributes to get the name:value pairs
|
|
aAttributes.Append(kNullCh); // put an extra null at the end
|
|
char16_t* start = aAttributes.BeginWriting();
|
|
char16_t* end = start;
|
|
while ((kNullCh != *start) && (kDashCh != *start)) {
|
|
name.SetLength(0);
|
|
value.SetLength(0);
|
|
// skip leading space, the dash amounts to the end of the line
|
|
while ((kNullCh!=*start) && (kDashCh!=*start) && nsCRT::IsAsciiSpace(*start)) {
|
|
++start;
|
|
}
|
|
end = start;
|
|
// look for ':'
|
|
while ((kNullCh!=*end) && (kDashCh!=*end) && !nsCRT::IsAsciiSpace(*end) &&
|
|
(kColonCh!=*end)) {
|
|
++end;
|
|
}
|
|
// If ':' is not found, then it's a boolean property
|
|
bool IsBooleanProperty = (kColonCh != *end);
|
|
*end = kNullCh; // end segment here
|
|
// this segment is the name
|
|
if (start < end) {
|
|
name.Assign(start);
|
|
}
|
|
if (IsBooleanProperty) {
|
|
SetBooleanProperty(aOperatorData, name);
|
|
} else {
|
|
start = ++end;
|
|
// look for space or end of line
|
|
while ((kNullCh!=*end) && (kDashCh!=*end) &&
|
|
!nsCRT::IsAsciiSpace(*end)) {
|
|
++end;
|
|
}
|
|
*end = kNullCh; // end segment here
|
|
if (start < end) {
|
|
// this segment is the value
|
|
value.Assign(start);
|
|
}
|
|
SetProperty(aOperatorData, name, value);
|
|
}
|
|
start = ++end;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static nsresult
|
|
InitOperators(void)
|
|
{
|
|
// Load the property file containing the Operator Dictionary
|
|
nsresult rv;
|
|
nsCOMPtr<nsIPersistentProperties> mathfontProp;
|
|
rv = NS_LoadPersistentPropertiesFromURISpec(
|
|
getter_AddRefs(mathfontProp),
|
|
NS_LITERAL_CSTRING("resource://gre/res/fonts/mathfont.properties"));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
// Parse the Operator Dictionary in two passes.
|
|
// The first pass is to count the number of operators; the second pass is to
|
|
// allocate the necessary space for them and to add them in the hash table.
|
|
for (int32_t pass = 1; pass <= 2; pass++) {
|
|
OperatorData dummyData;
|
|
OperatorData* operatorData = &dummyData;
|
|
nsCOMPtr<nsISimpleEnumerator> iterator;
|
|
if (NS_SUCCEEDED(mathfontProp->Enumerate(getter_AddRefs(iterator)))) {
|
|
bool more;
|
|
uint32_t index = 0;
|
|
nsAutoCString name;
|
|
nsAutoString attributes;
|
|
while ((NS_SUCCEEDED(iterator->HasMoreElements(&more))) && more) {
|
|
nsCOMPtr<nsISupports> supports;
|
|
nsCOMPtr<nsIPropertyElement> element;
|
|
if (NS_SUCCEEDED(iterator->GetNext(getter_AddRefs(supports)))) {
|
|
element = do_QueryInterface(supports);
|
|
if (NS_SUCCEEDED(element->GetKey(name)) &&
|
|
NS_SUCCEEDED(element->GetValue(attributes))) {
|
|
// expected key: operator.\uNNNN.{infix,postfix,prefix}
|
|
if ((21 <= name.Length()) && (0 == name.Find("operator.\\u"))) {
|
|
name.Cut(0, 9); // 9 is the length of "operator.";
|
|
int32_t len = name.Length();
|
|
nsOperatorFlags form = 0;
|
|
if (kNotFound != name.RFind(".infix")) {
|
|
form = NS_MATHML_OPERATOR_FORM_INFIX;
|
|
len -= 6; // 6 is the length of ".infix";
|
|
}
|
|
else if (kNotFound != name.RFind(".postfix")) {
|
|
form = NS_MATHML_OPERATOR_FORM_POSTFIX;
|
|
len -= 8; // 8 is the length of ".postfix";
|
|
}
|
|
else if (kNotFound != name.RFind(".prefix")) {
|
|
form = NS_MATHML_OPERATOR_FORM_PREFIX;
|
|
len -= 7; // 7 is the length of ".prefix";
|
|
}
|
|
else continue; // input is not applicable
|
|
name.SetLength(len);
|
|
if (2 == pass) { // allocate space and start the storage
|
|
if (!gOperatorArray) {
|
|
if (0 == gOperatorCount) return NS_ERROR_UNEXPECTED;
|
|
gOperatorArray = new OperatorData[gOperatorCount];
|
|
if (!gOperatorArray) return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
operatorData = &gOperatorArray[index];
|
|
}
|
|
else {
|
|
form = 0; // to quickly return from SetOperator() at pass 1
|
|
}
|
|
// See if the operator should be retained
|
|
if (SetOperator(operatorData, form, name, attributes)) {
|
|
index++;
|
|
if (1 == pass) gOperatorCount = index;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
static nsresult
|
|
InitOperatorGlobals()
|
|
{
|
|
gGlobalsInitialized = true;
|
|
nsresult rv = NS_ERROR_OUT_OF_MEMORY;
|
|
gOperatorTable = new nsDataHashtable<nsStringHashKey, OperatorData*>();
|
|
if (gOperatorTable) {
|
|
rv = InitOperators();
|
|
}
|
|
if (NS_FAILED(rv))
|
|
nsMathMLOperators::CleanUp();
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
nsMathMLOperators::CleanUp()
|
|
{
|
|
if (gOperatorArray) {
|
|
delete[] gOperatorArray;
|
|
gOperatorArray = nullptr;
|
|
}
|
|
if (gOperatorTable) {
|
|
delete gOperatorTable;
|
|
gOperatorTable = nullptr;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsMathMLOperators::AddRefTable(void)
|
|
{
|
|
gTableRefCount++;
|
|
}
|
|
|
|
void
|
|
nsMathMLOperators::ReleaseTable(void)
|
|
{
|
|
if (0 == --gTableRefCount) {
|
|
CleanUp();
|
|
}
|
|
}
|
|
|
|
static OperatorData*
|
|
GetOperatorData(const nsString& aOperator, nsOperatorFlags aForm)
|
|
{
|
|
nsAutoString key(aOperator);
|
|
key.AppendInt(aForm);
|
|
return gOperatorTable->Get(key);
|
|
}
|
|
|
|
bool
|
|
nsMathMLOperators::LookupOperator(const nsString& aOperator,
|
|
const nsOperatorFlags aForm,
|
|
nsOperatorFlags* aFlags,
|
|
float* aLeadingSpace,
|
|
float* aTrailingSpace)
|
|
{
|
|
if (!gGlobalsInitialized) {
|
|
InitOperatorGlobals();
|
|
}
|
|
if (gOperatorTable) {
|
|
NS_ASSERTION(aFlags && aLeadingSpace && aTrailingSpace, "bad usage");
|
|
NS_ASSERTION(aForm > 0 && aForm < 4, "*** invalid call ***");
|
|
|
|
// The MathML REC says:
|
|
// If the operator does not occur in the dictionary with the specified form,
|
|
// the renderer should use one of the forms which is available there, in the
|
|
// order of preference: infix, postfix, prefix.
|
|
|
|
OperatorData* found;
|
|
int32_t form = NS_MATHML_OPERATOR_GET_FORM(aForm);
|
|
if (!(found = GetOperatorData(aOperator, form))) {
|
|
if (form == NS_MATHML_OPERATOR_FORM_INFIX ||
|
|
!(found =
|
|
GetOperatorData(aOperator, NS_MATHML_OPERATOR_FORM_INFIX))) {
|
|
if (form == NS_MATHML_OPERATOR_FORM_POSTFIX ||
|
|
!(found =
|
|
GetOperatorData(aOperator, NS_MATHML_OPERATOR_FORM_POSTFIX))) {
|
|
if (form != NS_MATHML_OPERATOR_FORM_PREFIX) {
|
|
found = GetOperatorData(aOperator, NS_MATHML_OPERATOR_FORM_PREFIX);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (found) {
|
|
NS_ASSERTION(found->mStr.Equals(aOperator), "bad setup");
|
|
*aLeadingSpace = found->mLeadingSpace;
|
|
*aTrailingSpace = found->mTrailingSpace;
|
|
*aFlags &= ~NS_MATHML_OPERATOR_FORM; // clear the form bits
|
|
*aFlags |= found->mFlags; // just add bits without overwriting
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
nsMathMLOperators::LookupOperators(const nsString& aOperator,
|
|
nsOperatorFlags* aFlags,
|
|
float* aLeadingSpace,
|
|
float* aTrailingSpace)
|
|
{
|
|
if (!gGlobalsInitialized) {
|
|
InitOperatorGlobals();
|
|
}
|
|
|
|
aFlags[NS_MATHML_OPERATOR_FORM_INFIX] = 0;
|
|
aLeadingSpace[NS_MATHML_OPERATOR_FORM_INFIX] = 0.0f;
|
|
aTrailingSpace[NS_MATHML_OPERATOR_FORM_INFIX] = 0.0f;
|
|
|
|
aFlags[NS_MATHML_OPERATOR_FORM_POSTFIX] = 0;
|
|
aLeadingSpace[NS_MATHML_OPERATOR_FORM_POSTFIX] = 0.0f;
|
|
aTrailingSpace[NS_MATHML_OPERATOR_FORM_POSTFIX] = 0.0f;
|
|
|
|
aFlags[NS_MATHML_OPERATOR_FORM_PREFIX] = 0;
|
|
aLeadingSpace[NS_MATHML_OPERATOR_FORM_PREFIX] = 0.0f;
|
|
aTrailingSpace[NS_MATHML_OPERATOR_FORM_PREFIX] = 0.0f;
|
|
|
|
if (gOperatorTable) {
|
|
OperatorData* found;
|
|
found = GetOperatorData(aOperator, NS_MATHML_OPERATOR_FORM_INFIX);
|
|
if (found) {
|
|
aFlags[NS_MATHML_OPERATOR_FORM_INFIX] = found->mFlags;
|
|
aLeadingSpace[NS_MATHML_OPERATOR_FORM_INFIX] = found->mLeadingSpace;
|
|
aTrailingSpace[NS_MATHML_OPERATOR_FORM_INFIX] = found->mTrailingSpace;
|
|
}
|
|
found = GetOperatorData(aOperator, NS_MATHML_OPERATOR_FORM_POSTFIX);
|
|
if (found) {
|
|
aFlags[NS_MATHML_OPERATOR_FORM_POSTFIX] = found->mFlags;
|
|
aLeadingSpace[NS_MATHML_OPERATOR_FORM_POSTFIX] = found->mLeadingSpace;
|
|
aTrailingSpace[NS_MATHML_OPERATOR_FORM_POSTFIX] = found->mTrailingSpace;
|
|
}
|
|
found = GetOperatorData(aOperator, NS_MATHML_OPERATOR_FORM_PREFIX);
|
|
if (found) {
|
|
aFlags[NS_MATHML_OPERATOR_FORM_PREFIX] = found->mFlags;
|
|
aLeadingSpace[NS_MATHML_OPERATOR_FORM_PREFIX] = found->mLeadingSpace;
|
|
aTrailingSpace[NS_MATHML_OPERATOR_FORM_PREFIX] = found->mTrailingSpace;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* static */ bool
|
|
nsMathMLOperators::IsMirrorableOperator(const nsString& aOperator)
|
|
{
|
|
// LookupOperator will search infix, postfix and prefix forms of aOperator and
|
|
// return the first form found. It is assumed that all these forms have same
|
|
// mirrorability.
|
|
nsOperatorFlags flags = 0;
|
|
float dummy;
|
|
nsMathMLOperators::LookupOperator(aOperator,
|
|
NS_MATHML_OPERATOR_FORM_INFIX,
|
|
&flags, &dummy, &dummy);
|
|
return NS_MATHML_OPERATOR_IS_MIRRORABLE(flags);
|
|
}
|
|
|
|
/* static */ nsStretchDirection
|
|
nsMathMLOperators::GetStretchyDirection(const nsString& aOperator)
|
|
{
|
|
// LookupOperator will search infix, postfix and prefix forms of aOperator and
|
|
// return the first form found. It is assumed that all these forms have same
|
|
// direction.
|
|
nsOperatorFlags flags = 0;
|
|
float dummy;
|
|
nsMathMLOperators::LookupOperator(aOperator,
|
|
NS_MATHML_OPERATOR_FORM_INFIX,
|
|
&flags, &dummy, &dummy);
|
|
|
|
if (NS_MATHML_OPERATOR_IS_DIRECTION_VERTICAL(flags)) {
|
|
return NS_STRETCH_DIRECTION_VERTICAL;
|
|
} else if (NS_MATHML_OPERATOR_IS_DIRECTION_HORIZONTAL(flags)) {
|
|
return NS_STRETCH_DIRECTION_HORIZONTAL;
|
|
} else {
|
|
return NS_STRETCH_DIRECTION_UNSUPPORTED;
|
|
}
|
|
}
|