wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge m-c to b-i

Browse Source
This commit is contained in:
Phil Ringnalda 2013-12-15 18:03:06 -08:00
commit 00949b2a37
58 changed files with 758 additions and 449 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
accessible/src/jsat/AccessFu.jsm
View File

@ -118,8 +118,8 @@ this.AccessFu = {
Output.start();
TouchAdapter.start();
Services.obs.addObserver(this, 'remote-browser-shown', false);
Services.obs.addObserver(this, 'inprocess-browser-shown', false);
Services.obs.addObserver(this, 'remote-browser-frame-shown', false);
Services.obs.addObserver(this, 'in-process-browser-or-app-frame-shown', false);
Services.obs.addObserver(this, 'Accessibility:NextObject', false);
Services.obs.addObserver(this, 'Accessibility:PreviousObject', false);
Services.obs.addObserver(this, 'Accessibility:Focus', false);
@ -162,8 +162,8 @@ this.AccessFu = {
Utils.win.removeEventListener('TabClose', this);
Utils.win.removeEventListener('TabSelect', this);
Services.obs.removeObserver(this, 'remote-browser-shown');
Services.obs.removeObserver(this, 'inprocess-browser-shown');
Services.obs.removeObserver(this, 'remote-browser-frame-shown');
Services.obs.removeObserver(this, 'in-process-browser-or-app-frame-shown');
Services.obs.removeObserver(this, 'Accessibility:NextObject');
Services.obs.removeObserver(this, 'Accessibility:PreviousObject');
Services.obs.removeObserver(this, 'Accessibility:Focus');
@ -304,15 +304,11 @@ this.AccessFu = {
case 'Accessibility:MoveByGranularity':
this.Input.moveByGranularity(JSON.parse(aData));
break;
case 'remote-browser-shown':
case 'inprocess-browser-shown':
case 'remote-browser-frame-shown':
case 'in-process-browser-or-app-frame-shown':
{
// Ignore notifications that aren't from a BrowserOrApp
let frameLoader = aSubject.QueryInterface(Ci.nsIFrameLoader);
if (!frameLoader.ownerIsBrowserOrAppFrame) {
return;
}
this._handleMessageManager(frameLoader.messageManager);
let mm = aSubject.QueryInterface(Ci.nsIFrameLoader).messageManager;
this._handleMessageManager(mm);
break;
}
}

8
b2g/components/ErrorPage.jsm
View File

@ -150,16 +150,12 @@ let ErrorPage = {
},
init: function errorPageInit() {
Services.obs.addObserver(this, 'inprocess-browser-shown', false);
Services.obs.addObserver(this, 'remote-browser-shown', false);
Services.obs.addObserver(this, 'in-process-browser-or-app-frame-shown', false);
Services.obs.addObserver(this, 'remote-browser-frame-shown', false);
},
observe: function errorPageObserve(aSubject, aTopic, aData) {
let frameLoader = aSubject.QueryInterface(Ci.nsIFrameLoader);
// Ignore notifications that aren't from a BrowserOrApp
if (!frameLoader.ownerIsBrowserOrAppFrame) {
return;
}
let mm = frameLoader.messageManager;
// This won't happen from dom/ipc/preload.js in non-OOP builds.

6
browser/components/safebrowsing/content/test/browser.ini
View File

@ -2,7 +2,7 @@
support-files = head.js
[browser_bug400731.js]
# [browser_bug415846.js]
# Disabled for too many intermittent failures (bug 546169)
# Previously disabled on Mac because of its bizarre special-and-unique
[browser_bug415846.js]
skip-if = os == "mac"
# Disabled on Mac because of its bizarre special-and-unique
# snowflake of a help menu.

4
browser/components/safebrowsing/content/test/browser_bug415846.js
View File

@ -37,11 +37,13 @@ function testNormal_PopupListener() {
// Now launch the phishing test. Can't use onload here because error pages don't
// fire normal load events.
window.addEventListener("DOMContentLoaded", testPhishing, true);
content.location = "http://www.mozilla.org/firefox/its-a-trap.html";
setTimeout(testPhishing, 2000);
}
function testPhishing() {
window.removeEventListener("DOMContentLoaded", testPhishing, true);
menu.addEventListener("popupshown", testPhishing_PopupListener, false);
menu.openPopup(null, "", 0, 0, false, null);
}

7
browser/components/sessionstore/content/content-sessionStore.js
View File

@ -392,7 +392,12 @@ let MessageQueue = {
let sync = options && options.sync;
let startID = (options && options.id) || this._id;
let sendMessage = sync ? sendSyncMessage : sendAsyncMessage;
// We use sendRpcMessage in the sync case because we may have been called
// through a CPOW. RPC messages are the only synchronous messages that the
// child is allowed to send to the parent while it is handling a CPOW
// request.
let sendMessage = sync ? sendRpcMessage : sendAsyncMessage;
let data = {};
for (let [key, id] of this._lastUpdated) {

7
content/base/public/nsIFrameLoader.idl
View File

@ -111,7 +111,7 @@ interface nsIContentViewManager : nsISupports
readonly attribute nsIContentView rootContentView;
};
[scriptable, builtinclass, uuid(a723673b-a26e-4cc6-ae23-ec70df9d97c9)]
[scriptable, builtinclass, uuid(5b9949dc-56f1-47b6-b6d2-3785bb90ed6d)]
interface nsIFrameLoader : nsISupports
{
/**
@ -272,11 +272,6 @@ interface nsIFrameLoader : nsISupports
* have a notion of visibility in the parent process when frames are OOP.
*/
[infallible] attribute boolean visible;
/**
* Find out whether the owner content really is a browser or app frame
*/
readonly attribute boolean ownerIsBrowserOrAppFrame;
};
%{C++

32
content/base/src/nsFrameLoader.cpp
View File

@ -948,9 +948,9 @@ nsFrameLoader::ShowRemoteFrame(const nsIntSize& size,
EnsureMessageManager();
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
if (os && !mRemoteBrowserInitialized) {
if (OwnerIsBrowserOrAppFrame() && os && !mRemoteBrowserInitialized) {
os->NotifyObservers(NS_ISUPPORTS_CAST(nsIFrameLoader*, this),
"remote-browser-shown", nullptr);
"remote-browser-frame-shown", nullptr);
mRemoteBrowserInitialized = true;
}
} else {
@ -1409,14 +1409,6 @@ nsFrameLoader::OwnerIsBrowserOrAppFrame()
return browserFrame ? browserFrame->GetReallyIsBrowserOrApp() : false;
}
// The xpcom getter version
NS_IMETHODIMP
nsFrameLoader::GetOwnerIsBrowserOrAppFrame(bool* aResult)
{
*aResult = OwnerIsBrowserOrAppFrame();
return NS_OK;
}
bool
nsFrameLoader::OwnerIsAppFrame()
{
@ -1685,16 +1677,18 @@ nsFrameLoader::MaybeCreateDocShell()
mDocShell->SetIsBrowserInsideApp(containingAppId);
}
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
if (os) {
os->NotifyObservers(NS_ISUPPORTS_CAST(nsIFrameLoader*, this),
"inprocess-browser-shown", nullptr);
}
if (OwnerIsBrowserOrAppFrame()) {
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
if (os) {
os->NotifyObservers(NS_ISUPPORTS_CAST(nsIFrameLoader*, this),
"in-process-browser-or-app-frame-shown", nullptr);
}
if (OwnerIsBrowserOrAppFrame() && mMessageManager) {
mMessageManager->LoadFrameScript(
NS_LITERAL_STRING("chrome://global/content/BrowserElementChild.js"),
/* allowDelayedLoad = */ true);
if (mMessageManager) {
mMessageManager->LoadFrameScript(
NS_LITERAL_STRING("chrome://global/content/BrowserElementChild.js"),
/* allowDelayedLoad = */ true);
}
}
return NS_OK;

6
content/canvas/src/CanvasRenderingContext2D.cpp
View File

@ -91,18 +91,18 @@
#include "mozilla/dom/TextMetrics.h"
#include "mozilla/dom/UnionTypes.h"
#include "nsGlobalWindow.h"
#include "GLContext.h"
#include "GLContextProvider.h"
#ifdef USE_SKIA_GPU
#undef free // apparently defined by some windows header, clashing with a free()
// method in SkTypes.h
#include "GLContext.h"
#include "GLContextProvider.h"
#include "GLContextSkia.h"
#include "SurfaceTypes.h"
#include "nsIGfxInfo.h"
#endif
using mozilla::gl::GLContext;
using mozilla::gl::GLContextProvider;
#endif
#ifdef XP_WIN
#include "gfxWindowsPlatform.h"

16
dom/browser-element/BrowserElementParent.js
View File

@ -65,8 +65,8 @@ BrowserElementParentFactory.prototype = {
// alive for as long as its frame element lives.
this._bepMap = new WeakMap();
Services.obs.addObserver(this, 'remote-browser-shown', /* ownsWeak = */ true);
Services.obs.addObserver(this, 'inprocess-browser-shown', /* ownsWeak = */ true);
Services.obs.addObserver(this, 'remote-browser-frame-shown', /* ownsWeak = */ true);
Services.obs.addObserver(this, 'in-process-browser-or-app-frame-shown', /* ownsWeak = */ true);
},
_browserFramesPrefEnabled: function() {
@ -79,19 +79,11 @@ BrowserElementParentFactory.prototype = {
},
_observeInProcessBrowserFrameShown: function(frameLoader) {
// Ignore notifications that aren't from a BrowserOrApp
if (!frameLoader.QueryInterface(Ci.nsIFrameLoader).ownerIsBrowserOrAppFrame) {
return;
}
debug("In-process browser frame shown " + frameLoader);
this._createBrowserElementParent(frameLoader, /* hasRemoteFrame = */ false);
},
_observeRemoteBrowserFrameShown: function(frameLoader) {
// Ignore notifications that aren't from a BrowserOrApp
if (!frameLoader.QueryInterface(Ci.nsIFrameLoader).ownerIsBrowserOrAppFrame) {
return;
}
debug("Remote browser frame shown " + frameLoader);
this._createBrowserElementParent(frameLoader, /* hasRemoteFrame = */ true);
},
@ -111,10 +103,10 @@ BrowserElementParentFactory.prototype = {
this._init();
}
break;
case 'remote-browser-shown':
case 'remote-browser-frame-shown':
this._observeRemoteBrowserFrameShown(subject);
break;
case 'inprocess-browser-shown':
case 'in-process-browser-or-app-frame-shown':
this._observeInProcessBrowserFrameShown(subject);
break;
case 'content-document-global-created':

8
dom/inputmethod/Keyboard.jsm
View File

@ -44,8 +44,8 @@ this.Keyboard = {
},
init: function keyboardInit() {
Services.obs.addObserver(this, 'inprocess-browser-shown', false);
Services.obs.addObserver(this, 'remote-browser-shown', false);
Services.obs.addObserver(this, 'in-process-browser-or-app-frame-shown', false);
Services.obs.addObserver(this, 'remote-browser-frame-shown', false);
Services.obs.addObserver(this, 'oop-frameloader-crashed', false);
for (let name of this._messageNames)
@ -63,10 +63,6 @@ this.Keyboard = {
ppmm.broadcastAsyncMessage('Keyboard:FocusChange', { 'type': 'blur' });
}
} else {
// Ignore notifications that aren't from a BrowserOrApp
if (!frameLoader.ownerIsBrowserOrAppFrame) {
return;
}
this.initFormsFrameScript(mm);
}
},

11
dom/ipc/ProcessPriorityManager.cpp
View File

@ -602,7 +602,7 @@ ParticularProcessPriorityManager::Init()
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
if (os) {
os->AddObserver(this, "audio-channel-process-changed", /* ownsWeak */ true);
os->AddObserver(this, "remote-browser-shown", /* ownsWeak */ true);
os->AddObserver(this, "remote-browser-frame-shown", /* ownsWeak */ true);
os->AddObserver(this, "ipc:browser-destroyed", /* ownsWeak */ true);
os->AddObserver(this, "frameloader-visible-changed", /* ownsWeak */ true);
}
@ -674,7 +674,7 @@ ParticularProcessPriorityManager::Observe(nsISupports* aSubject,
if (topic.EqualsLiteral("audio-channel-process-changed")) {
OnAudioChannelProcessChanged(aSubject);
} else if (topic.EqualsLiteral("remote-browser-shown")) {
} else if (topic.EqualsLiteral("remote-browser-frame-shown")) {
OnRemoteBrowserFrameShown(aSubject);
} else if (topic.EqualsLiteral("ipc:browser-destroyed")) {
OnTabParentDestroyed(aSubject);
@ -747,13 +747,6 @@ ParticularProcessPriorityManager::OnRemoteBrowserFrameShown(nsISupports* aSubjec
nsCOMPtr<nsIFrameLoader> fl = do_QueryInterface(aSubject);
NS_ENSURE_TRUE_VOID(fl);
// Ignore notifications that aren't from a BrowserOrApp
bool isBrowserOrApp;
fl->GetOwnerIsBrowserOrAppFrame(&isBrowserOrApp);
if (!isBrowserOrApp) {
return;
}
nsCOMPtr<nsITabParent> tp;
fl->GetTabParent(getter_AddRefs(tp));
NS_ENSURE_TRUE_VOID(tp);

340
intl/uconv/tools/jamap.pl Normal file
View File

@ -0,0 +1,340 @@
#!/usr/local/bin/perl
use strict;
my @source_files;
my @sjis_h;
$sjis_h[0] = -1;
@sjis_h[0x81..0x9f] = map { 0x2100 + $_ * 0x200 } (0 .. 30);
@sjis_h[0xe0..0xef] = map { 0x5F00 + $_ * 0x200 } (0 .. 15);
@sjis_h[0xf0..0xf9] = (-2) x 10;
my @sjis_l;
@sjis_l[0x40..0x7e] = (0x21..0x5f);
@sjis_l[0x80..0xfc] = (0x60..0x7e, 0x121..0x17e);
sub sjis_to_jis {
my ($s) = @_;
my $j;
my $type;
my $h = $sjis_h[($s>>8)&0xff];
if ( $h > 0 ) { # jis0208
my $l = $sjis_l[$s&0xff];
if ( $l == 0 ) {
$j = $s;
$type = 'sjis2undef';
} else {
$j = $h + $l;
if ( $j >= 0x3000 && $j < 0x7500 ) { # jis0208 kanji
$type = 'jis0208';
} elsif ( $j < 0x2900 ) { # jis0208
$type = 'jis0208';
} else {
$type = 'jis0208undef';
}
}
} elsif ( $h == -1 ) { # single byte
$j = $s;
if ( $s <= 0x7f ) { # jis0201 roman
$type = 'jis0201';
} elsif ( $s >= 0xa1 && $s <= 0xdf ) { # jis0201 kana
$type = 'jis0201';
} else { # sjis single byte undefined
$type = 'sjis1undef';
}
} elsif ( $h == -2 ) { # private use
$j = $s;
$type = 'private';
} else { # sjis undefined
$j = $s;
$type = 'sjis2undef';
}
return ($j, $type);
}
sub read_sjis_map {
my ($filename, $s_col, $u_col) = @_;
my %map;
open MAP, $filename or die $!;
while (<MAP>) {
my @cols = split /\s+/;
my ($s, $u) = @cols[$s_col, $u_col];
$s =~ /^0x[0-9A-Fa-f]+$/ && $u =~ /^0x[0-9A-Fa-f]+$/ or next;
$s = oct($s);
$u = oct($u);
my ($j, $type) = sjis_to_jis($s);
push @{$map{$type}}, [$j, $s, $u];
}
close MAP or warn $!;
push @source_files, $filename;
return %map;
}
sub read_0212_map {
my ($filename, $j_col, $u_col) = @_;
my $map;
open MAP, $filename or die $!;
while (<MAP>) {
my @cols = split /\s+/;
my ($j, $u) = @cols[$j_col, $u_col];
$j =~ /^0x[0-9A-Fa-f]+$/ && $u =~ /^0x[0-9A-Fa-f]+$/ or next;
$j = oct($j);
$u = oct($u);
$u = 0xff5e if $u == 0x007e;
push @$map, [$j, 0, $u];
}
close MAP or warn $!;
push @source_files, $filename;
return $map;
}
my %printed;
sub write_fromu_map {
my ($filename, $code, @maps) = @_;
open MAP, ">$filename" or die $!;
foreach my $map (@maps) {
foreach my $pair (@$map) {
my ($j, $s, $u) = @$pair;
if ( $code eq 'sjis' ) {
$j = $s;
}
if ( defined($printed{$u}) ) {
if ( $printed{$u} ne $j ) {
printf "conflict 0x%04x to 0x%04x, 0x%04x\n", $u, $printed{$u}, $j;
}
} else {
if ( $j < 0x100 ) {
printf MAP "0x%02X\t0x%04X\n", $j, $u;
} else {
printf MAP "0x%04X\t0x%04X\n", $j, $u;
}
$printed{$u} = $j;
}
}
}
close MAP or warn $!;
}
my @table;
my %table;
my $table_next_count = 0;
sub get_94table_index {
my ($map_table) = @_;
my $key = join ',', map {int($map_table->[$_])} (0 .. 93);
my $table_index = $table{$key};
if ( !defined($table_index) ) {
$table_index = $table_next_count;
$table_next_count += 94;
$table[$table_index] = $map_table;
$table{$key} = $table_index;
}
return $table_index;
}
sub get_188table_index {
my ($map_table) = @_;
my $map_table1 = [ @{$map_table}[0 .. 93] ];
my $map_table2 = [ @{$map_table}[94 .. 187] ];
my $key = join ',', map {int($map_table->[$_])} (0 .. 187);
my $key1 = join ',', map {int($map_table1->[$_])} (0 .. 93);
my $key2 = join ',', map {int($map_table2->[$_])} (0 .. 93);
my $table_index = $table{$key};
if ( !defined($table_index) ) {
$table_index = $table_next_count;
$table_next_count += 188;
$table[$table_index] = $map_table1;
$table[$table_index + 94] = $map_table2;
$table{$key} = $table_index;
$table{$key1} = $table_index unless defined($table{$key1});
$table{$key2} = $table_index + 94 unless defined($table{$key2});
}
return $table_index;
}
get_188table_index([]);
sub print_sjis_table_index {
my @maps = @_;
my %map_table;
foreach my $map (@maps) {
foreach my $pair (@$map) {
my ($j, $s, $u) = @$pair;
my $row = $s >> 8;
my $cell = $s&0xff;
if ( $cell >= 0x40 && $cell <= 0x7e ) {
$cell -= 0x40;
} elsif ( $cell >= 0x80 && $cell <= 0xfc ) {
$cell -= 0x41;
} else {
next;
}
if ( defined($map_table{$row}->[$cell]) && $map_table{$row}->[$cell] != $u ) {
print "conflict!\n";
}
$map_table{$row}->[$cell] = $u;
}
}
for ( my $i = 0x80; $i < 0x100; $i++ ) {
if ( ($i & 0x7) == 0 ) {
print MAP "\n ";
}
if ( $i >= 0xa1 && $i <= 0xdf ) {
printf MAP " 0x%04X,", $i + 0xfec0;
} elsif ( $i >= 0xf0 && $i <= 0xf9 ) {
printf MAP " 0x%04X,", 0xe000 + ($i - 0xf0) * 188;
} elsif ( $i == 0x80 ) {
print MAP " 0xFFFD,";
} elsif ( $i == 0xa0 ) {
print MAP " 0xF8F0,";
} elsif ( $i >= 0xfd ) {
printf MAP " 0x%04X,", $i + (0xf8f1 - 0xfd);
} else {
my $table_index = get_188table_index($map_table{$i});
printf MAP " %6d,", $table_index;
}
}
}
sub print_jis_table_index {
my @maps = @_;
my %map_table;
foreach my $map (@maps) {
foreach my $pair (@$map) {
my ($j, $s, $u) = @$pair;
my $row = $j >> 8;
my $cell = ($j&0xff) - 0x21;
if ( defined($map_table{$row}->[$cell]) && $map_table{$row}->[$cell] != $u ) {
print "conflict!\n";
}
$map_table{$row}->[$cell] = $u;
}
}
for ( my $i = 0; $i < 0x80; $i++ ) {
if ( ($i & 0x7) == 0 ) {
print MAP "\n ";
}
if ( $i >= 0x21 && $i <= 0x7e ) {
my $table_index = get_94table_index($map_table{$i});
printf MAP " %6d,", $table_index;
} else {
print MAP " 0xFFFD,";
}
}
}
sub print_table_index {
my ($map_name, @maps) = @_;
print MAP "static const uint16_t g${map_name}IndexShiftJis[] = {";
print_sjis_table_index(@maps);
print MAP "\n};\n";
print MAP "static const uint16_t g${map_name}IndexJis0208[] = {";
print_jis_table_index(@maps);
print MAP "\n};\n";
print MAP "static const uint16_t * const g${map_name}Index[] = {";
print MAP "\n g${map_name}IndexShiftJis, g${map_name}IndexJis0208";
print MAP "\n};\n\n";
}
sub print_0212_table_index {
my ($map_name, @maps) = @_;
print MAP "static const uint16_t g${map_name}Index[] = {";
print_jis_table_index(@maps);
print MAP "\n};\n\n";
}
sub print_table {
print MAP "static const uint16_t gJapaneseMap[] = {";
for ( my $i = 0; $i < $table_next_count; $i += 94 ) {
my $index = $i;
print MAP "\n /* index $index */\n ";
my $map_table = $table[$i];
my $print_count = 1;
for ( my $j = 0; $j < 94; $j++ ) {
my $u = $map_table->[$j];
if ( $u == 0 ) { $u = 0xfffd; }
printf MAP " 0x%04X,", $u;
if ( ++$print_count == 8 ) {
print MAP "\n ";
$print_count = 0;
}
}
}
print MAP "\n};\n";
}
my %cp932 = read_sjis_map('CP932.TXT', 0, 1);
my %ibm = read_sjis_map('IBM943.TXT', 0, 1);
my $jis0212 = read_0212_map('JIS0212.TXT', 0, 1);
%printed = ();
write_fromu_map('jis0201-uf-unify', 'jis',
$cp932{jis0201},
$ibm{jis0201}
);
write_fromu_map('jis0208-uf-unify', 'jis',
$cp932{jis0208},
$ibm{jis0208}
);
%printed = ();
write_fromu_map('jis0208ext-uf-unify', 'jis',
$cp932{jis0208undef},
$ibm{jis0208undef}
);
%printed = ();
write_fromu_map('sjis-uf-unify', 'sjis',
@cp932{'jis0201', 'jis0208', 'jis0208undef', 'sjis1undef', 'sjis2undef'},
@ibm{'jis0201', 'jis0208', 'jis0208undef', 'sjis1undef', 'sjis2undef'}
);
open MAP, ">japanese.map" or die $!;
binmode MAP;
while (<DATA>) {
if ( /^!/ ) { last; }
print MAP;
}
print MAP "/* generated by jamap.pl @source_files */\n\n";
print MAP <<EOM;
// IE-compatible handling of undefined codepoints:
// 0x80 --> U+0080
// 0xa0 --> U+F8F0
// 0xfd --> U+F8F1
// 0xfe --> U+F8F2
// 0xff --> U+F8F3
EOM
print_table_index('CP932', @cp932{'jis0208', 'jis0208undef', 'sjis2undef'});
print_table_index('IBM943', @ibm{'jis0208', 'jis0208undef', 'sjis2undef'});
print_0212_table_index('JIS0212', $jis0212);
print_table();
close MAP or warn $!;
__DATA__
/* -*- 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/. */
!

260
intl/uconv/ucvja/japanese.map
View File

@ -3,47 +3,7 @@
* 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/. */
/* generated by JaMap.java */
static const uint16_t gIndexShiftJis[] = {
0xFFFD, 188, 376, 564, 752, 0, 0, 940,
1128, 1316, 1504, 1692, 1880, 2068, 2256, 2444,
2632, 2820, 3008, 3196, 3384, 3572, 3760, 3948,
4136, 4324, 4512, 4700, 4888, 5076, 5264, 5452,
0xFFFD, 0xFF61, 0xFF62, 0xFF63, 0xFF64, 0xFF65, 0xFF66, 0xFF67,
0xFF68, 0xFF69, 0xFF6A, 0xFF6B, 0xFF6C, 0xFF6D, 0xFF6E, 0xFF6F,
0xFF70, 0xFF71, 0xFF72, 0xFF73, 0xFF74, 0xFF75, 0xFF76, 0xFF77,
0xFF78, 0xFF79, 0xFF7A, 0xFF7B, 0xFF7C, 0xFF7D, 0xFF7E, 0xFF7F,
0xFF80, 0xFF81, 0xFF82, 0xFF83, 0xFF84, 0xFF85, 0xFF86, 0xFF87,
0xFF88, 0xFF89, 0xFF8A, 0xFF8B, 0xFF8C, 0xFF8D, 0xFF8E, 0xFF8F,
0xFF90, 0xFF91, 0xFF92, 0xFF93, 0xFF94, 0xFF95, 0xFF96, 0xFF97,
0xFF98, 0xFF99, 0xFF9A, 0xFF9B, 0xFF9C, 0xFF9D, 0xFF9E, 0xFF9F,
5640, 5828, 6016, 6204, 6392, 6580, 6768, 6956,
7144, 7332, 7520, 0, 0, 7708, 7896, 0,
0xE000, 0xE0BC, 0xE178, 0xE234, 0xE2F0, 0xE3AC, 0xE468, 0xE524,
0xE5E0, 0xE69C, 8084, 8272, 8460, 0xFFFD, 0xFFFD, 0xFFFD,
};
static const uint16_t gIndexJis0208[] = {
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 188, 282, 376, 470, 564, 658, 752,
846, 0, 0, 0, 0, 940, 0, 0,
1222, 1316, 1410, 1504, 1598, 1692, 1786, 1880,
1974, 2068, 2162, 2256, 2350, 2444, 2538, 2632,
2726, 2820, 2914, 3008, 3102, 3196, 3290, 3384,
3478, 3572, 3666, 3760, 3854, 3948, 4042, 4136,
4230, 4324, 4418, 4512, 4606, 4700, 4794, 4888,
4982, 5076, 5170, 5264, 5358, 5452, 5546, 5640,
5734, 5828, 5922, 6016, 6110, 6204, 6298, 6392,
6486, 6580, 6674, 6768, 6862, 6956, 7050, 7144,
7238, 7332, 7426, 7520, 7614, 0, 0, 0,
0, 7708, 7802, 7896, 7990, 0, 0, 0xFFFD,
};
static const uint16_t * const gIndex[] = {
gIndexShiftJis, gIndexJis0208
};
/* generated by jamap.pl CP932.TXT IBM943.TXT JIS0212.TXT */
// IE-compatible handling of undefined codepoints:
// 0x80 --> U+0080
@ -52,7 +12,7 @@ static const uint16_t * const gIndex[] = {
// 0xfe --> U+F8F2
// 0xff --> U+F8F3
static const uint16_t gCP932IndexShiftJis[] = {
0xFFFD, 8648, 376, 564, 752, 0, 0, 940,
0xFFFD, 188, 376, 564, 752, 0, 0, 940,
1128, 1316, 1504, 1692, 1880, 2068, 2256, 2444,
2632, 2820, 3008, 3196, 3384, 3572, 3760, 3948,
4136, 4324, 4512, 4700, 4888, 5076, 5264, 5452,
@ -74,7 +34,7 @@ static const uint16_t gCP932IndexJis0208[] = {
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 8648, 8742, 376, 470, 564, 658, 752,
0xFFFD, 188, 282, 376, 470, 564, 658, 752,
846, 0, 0, 0, 0, 940, 0, 0,
1222, 1316, 1410, 1504, 1598, 1692, 1786, 1880,
1974, 2068, 2162, 2256, 2350, 2444, 2538, 2632,
@ -92,7 +52,7 @@ static const uint16_t * const gCP932Index[] = {
};
static const uint16_t gIBM943IndexShiftJis[] = {
0xFFFD, 8836, 376, 564, 752, 0, 0, 940,
0xFFFD, 8648, 376, 564, 752, 0, 0, 940,
1128, 1316, 1504, 1692, 1880, 2068, 2256, 2444,
2632, 2820, 3008, 3196, 3384, 3572, 3760, 3948,
4136, 4324, 4512, 4700, 4888, 5076, 5264, 5452,
@ -105,16 +65,16 @@ static const uint16_t gIBM943IndexShiftJis[] = {
0xFF90, 0xFF91, 0xFF92, 0xFF93, 0xFF94, 0xFF95, 0xFF96, 0xFF97,
0xFF98, 0xFF99, 0xFF9A, 0xFF9B, 0xFF9C, 0xFF9D, 0xFF9E, 0xFF9F,
5640, 5828, 6016, 6204, 6392, 6580, 6768, 6956,
7144, 7332, 7520, 0, 0, 7708, 9024, 0,
7144, 7332, 7520, 0, 0, 7708, 8836, 0,
0xE000, 0xE0BC, 0xE178, 0xE234, 0xE2F0, 0xE3AC, 0xE468, 0xE524,
0xE5E0, 0xE69C, 9212, 8272, 8460, 0xF8F1, 0xF8F2, 0xF8F3,
0xE5E0, 0xE69C, 9024, 8272, 8460, 0xF8F1, 0xF8F2, 0xF8F3,
};
static const uint16_t gIBM943IndexJis0208[] = {
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 8836, 8742, 376, 470, 564, 658, 752,
0xFFFD, 8648, 282, 376, 470, 564, 658, 752,
846, 0, 0, 0, 0, 940, 0, 0,
1222, 1316, 1410, 1504, 1598, 1692, 1786, 1880,
1974, 2068, 2162, 2256, 2350, 2444, 2538, 2632,
@ -125,7 +85,7 @@ static const uint16_t gIBM943IndexJis0208[] = {
5734, 5828, 5922, 6016, 6110, 6204, 6298, 6392,
6486, 6580, 6674, 6768, 6862, 6956, 7050, 7144,
7238, 7332, 7426, 7520, 7614, 0, 0, 0,
0, 7708, 7802, 7896, 9118, 0, 0, 0xFFFD,
0, 7708, 7802, 7896, 8930, 0, 0, 0xFFFD,
};
static const uint16_t * const gIBM943Index[] = {
gIBM943IndexShiftJis, gIBM943IndexJis0208
@ -136,16 +96,16 @@ static const uint16_t gJIS0212Index[] = {
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0, 9400, 0, 0, 0, 9494, 9588,
0, 9682, 9776, 9870, 0, 0, 0, 0,
9964, 10058, 10152, 10246, 10340, 10434, 10528, 10622,
10716, 10810, 10904, 10998, 11092, 11186, 11280, 11374,
11468, 11562, 11656, 11750, 11844, 11938, 12032, 12126,
12220, 12314, 12408, 12502, 12596, 12690, 12784, 12878,
12972, 13066, 13160, 13254, 13348, 13442, 13536, 13630,
13724, 13818, 13912, 14006, 14100, 14194, 14288, 14382,
14476, 14570, 14664, 14758, 14852, 14946, 15040, 15134,
15228, 15322, 15416, 15510, 15604, 15698, 0, 0,
0xFFFD, 0, 9212, 0, 0, 0, 9306, 9400,
0, 9494, 9588, 9682, 0, 0, 0, 0,
9776, 9870, 9964, 10058, 10152, 10246, 10340, 10434,
10528, 10622, 10716, 10810, 10904, 10998, 11092, 11186,
11280, 11374, 11468, 11562, 11656, 11750, 11844, 11938,
12032, 12126, 12220, 12314, 12408, 12502, 12596, 12690,
12784, 12878, 12972, 13066, 13160, 13254, 13348, 13442,
13536, 13630, 13724, 13818, 13912, 14006, 14100, 14194,
14288, 14382, 14476, 14570, 14664, 14758, 14852, 14946,
15040, 15134, 15228, 15322, 15416, 15510, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0xFFFD,
};
@ -181,14 +141,14 @@ static const uint16_t gJapaneseMap[] = {
0x3000, 0x3001, 0x3002, 0xFF0C, 0xFF0E, 0x30FB, 0xFF1A,
0xFF1B, 0xFF1F, 0xFF01, 0x309B, 0x309C, 0x00B4, 0xFF40, 0x00A8,
0xFF3E, 0xFFE3, 0xFF3F, 0x30FD, 0x30FE, 0x309D, 0x309E, 0x3003,
0x4EDD, 0x3005, 0x3006, 0x3007, 0x30FC, 0x2014, 0x2010, 0xFF0F,
0xFF3C, 0x301C, 0x2016, 0xFF5C, 0x2026, 0x2025, 0x2018, 0x2019,
0x4EDD, 0x3005, 0x3006, 0x3007, 0x30FC, 0x2015, 0x2010, 0xFF0F,
0xFF3C, 0xFF5E, 0x2225, 0xFF5C, 0x2026, 0x2025, 0x2018, 0x2019,
0x201C, 0x201D, 0xFF08, 0xFF09, 0x3014, 0x3015, 0xFF3B, 0xFF3D,
0xFF5B, 0xFF5D, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C, 0x300D,
0x300E, 0x300F, 0x3010, 0x3011, 0xFF0B, 0x2212, 0x00B1, 0x00D7,
0x300E, 0x300F, 0x3010, 0x3011, 0xFF0B, 0xFF0D, 0x00B1, 0x00D7,
0x00F7, 0xFF1D, 0x2260, 0xFF1C, 0xFF1E, 0x2266, 0x2267, 0x221E,
0x2234, 0x2642, 0x2640, 0x00B0, 0x2032, 0x2033, 0x2103, 0xFFE5,
0xFF04, 0x00A2, 0x00A3, 0xFF05, 0xFF03, 0xFF06, 0xFF0A, 0xFF20,
0xFF04, 0xFFE0, 0xFFE1, 0xFF05, 0xFF03, 0xFF06, 0xFF0A, 0xFF20,
0x00A7, 0x2606, 0x2605, 0x25CB, 0x25CF, 0x25CE, 0x25C7,
/* index 282 */
0x25C6, 0x25A1, 0x25A0, 0x25B3, 0x25B2, 0x25BD, 0x25BC,
@ -196,7 +156,7 @@ static const uint16_t gJapaneseMap[] = {
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0x2208, 0x220B, 0x2286, 0x2287, 0x2282, 0x2283,
0x222A, 0x2229, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0x2227, 0x2228, 0x00AC, 0x21D2, 0x21D4, 0x2200,
0xFFFD, 0xFFFD, 0x2227, 0x2228, 0xFFE2, 0x21D2, 0x21D4, 0x2200,
0x2203, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x2220, 0x22A5, 0x2312, 0x2202,
0x2207, 0x2261, 0x2252, 0x226A, 0x226B, 0x221A, 0x223D, 0x221D,
@ -1351,11 +1311,11 @@ static const uint16_t gJapaneseMap[] = {
0x3000, 0x3001, 0x3002, 0xFF0C, 0xFF0E, 0x30FB, 0xFF1A,
0xFF1B, 0xFF1F, 0xFF01, 0x309B, 0x309C, 0x00B4, 0xFF40, 0x00A8,
0xFF3E, 0xFFE3, 0xFF3F, 0x30FD, 0x30FE, 0x309D, 0x309E, 0x3003,
0x4EDD, 0x3005, 0x3006, 0x3007, 0x30FC, 0x2015, 0x2010, 0xFF0F,
0xFF3C, 0xFF5E, 0x2225, 0xFF5C, 0x2026, 0x2025, 0x2018, 0x2019,
0x4EDD, 0x3005, 0x3006, 0x3007, 0x30FC, 0x2014, 0x2010, 0xFF0F,
0xFF3C, 0x301C, 0x2016, 0xFF5C, 0x2026, 0x2025, 0x2018, 0x2019,
0x201C, 0x201D, 0xFF08, 0xFF09, 0x3014, 0x3015, 0xFF3B, 0xFF3D,
0xFF5B, 0xFF5D, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C, 0x300D,
0x300E, 0x300F, 0x3010, 0x3011, 0xFF0B, 0xFF0D, 0x00B1, 0x00D7,
0x300E, 0x300F, 0x3010, 0x3011, 0xFF0B, 0x2212, 0x00B1, 0x00D7,
0x00F7, 0xFF1D, 0x2260, 0xFF1C, 0xFF1E, 0x2266, 0x2267, 0x221E,
0x2234, 0x2642, 0x2640, 0x00B0, 0x2032, 0x2033, 0x2103, 0xFFE5,
0xFF04, 0xFFE0, 0xFFE1, 0xFF05, 0xFF03, 0xFF06, 0xFF0A, 0xFF20,
@ -1374,32 +1334,6 @@ static const uint16_t gJapaneseMap[] = {
0xFFFD, 0xFFFD, 0x212B, 0x2030, 0x266F, 0x266D, 0x266A, 0x2020,
0x2021, 0x00B6, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x25EF,
/* index 8836 */
0x3000, 0x3001, 0x3002, 0xFF0C, 0xFF0E, 0x30FB, 0xFF1A,
0xFF1B, 0xFF1F, 0xFF01, 0x309B, 0x309C, 0x00B4, 0xFF40, 0x00A8,
0xFF3E, 0xFFE3, 0xFF3F, 0x30FD, 0x30FE, 0x309D, 0x309E, 0x3003,
0x4EDD, 0x3005, 0x3006, 0x3007, 0x30FC, 0x2014, 0x2010, 0xFF0F,
0xFF3C, 0x301C, 0x2016, 0xFF5C, 0x2026, 0x2025, 0x2018, 0x2019,
0x201C, 0x201D, 0xFF08, 0xFF09, 0x3014, 0x3015, 0xFF3B, 0xFF3D,
0xFF5B, 0xFF5D, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C, 0x300D,
0x300E, 0x300F, 0x3010, 0x3011, 0xFF0B, 0x2212, 0x00B1, 0x00D7,
0x00F7, 0xFF1D, 0x2260, 0xFF1C, 0xFF1E, 0x2266, 0x2267, 0x221E,
0x2234, 0x2642, 0x2640, 0x00B0, 0x2032, 0x2033, 0x2103, 0xFFE5,
0xFF04, 0xFFE0, 0xFFE1, 0xFF05, 0xFF03, 0xFF06, 0xFF0A, 0xFF20,
0x00A7, 0x2606, 0x2605, 0x25CB, 0x25CF, 0x25CE, 0x25C7,
/* index 8930 */
0x25C6, 0x25A1, 0x25A0, 0x25B3, 0x25B2, 0x25BD, 0x25BC,
0x203B, 0x3012, 0x2192, 0x2190, 0x2191, 0x2193, 0x3013, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0x2208, 0x220B, 0x2286, 0x2287, 0x2282, 0x2283,
0x222A, 0x2229, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0x2227, 0x2228, 0xFFE2, 0x21D2, 0x21D4, 0x2200,
0x2203, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x2220, 0x22A5, 0x2312, 0x2202,
0x2207, 0x2261, 0x2252, 0x226A, 0x226B, 0x221A, 0x223D, 0x221D,
0x2235, 0x222B, 0x222C, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0x212B, 0x2030, 0x266F, 0x266D, 0x266A, 0x2020,
0x2021, 0x00B6, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x25EF,
/* index 9024 */
0x72BE, 0x7324, 0xFA16, 0x7377, 0x73BD, 0x73C9, 0x73D6,
0x73E3, 0x73D2, 0x7407, 0x73F5, 0x7426, 0x742A, 0x7429, 0x742E,
0x7462, 0x7489, 0x749F, 0x7501, 0x756F, 0x7682, 0x769C, 0x769E,
@ -1412,7 +1346,7 @@ static const uint16_t gJapaneseMap[] = {
0x8A37, 0x8A79, 0x8AA7, 0x8ABE, 0x8ADF, 0xFA22, 0x8AF6, 0x8B53,
0x8B7F, 0x8CF0, 0x8CF4, 0x8D12, 0x8D76, 0xFA23, 0x8ECF, 0xFA24,
0xFA25, 0x9067, 0x90DE, 0xFA26, 0x9115, 0x9127, 0x91DA,
/* index 9118 */
/* index 8930 */
0x91D7, 0x91DE, 0x91ED, 0x91EE, 0x91E4, 0x91E5, 0x9206,
0x9210, 0x920A, 0x923A, 0x9240, 0x923C, 0x924E, 0x9259, 0x9251,
0x9239, 0x9267, 0x92A7, 0x9277, 0x9278, 0x92E7, 0x92D7, 0x92D9,
@ -1425,7 +1359,7 @@ static const uint16_t gJapaneseMap[] = {
0x9BBB, 0x9C00, 0x9D70, 0x9D6B, 0xFA2D, 0x9E19, 0x9ED1, 0xFFFD,
0xFFFD, 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176,
0x2177, 0x2178, 0x2179, 0xFFE2, 0x00A6, 0xFF07, 0xFF02,
/* index 9212 */
/* index 9024 */
0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176,
0x2177, 0x2178, 0x2179, 0x2160, 0x2161, 0x2162, 0x2163, 0x2164,
0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0xFFE2, 0x00A6, 0xFF07,
@ -1438,7 +1372,7 @@ static const uint16_t gJapaneseMap[] = {
0x52DB, 0x5300, 0x5307, 0x5324, 0x5372, 0x5393, 0x53B2, 0x53DD,
0xFA0E, 0x549C, 0x548A, 0x54A9, 0x54FF, 0x5586, 0x5759, 0x5765,
0x57AC, 0x57C8, 0x57C7, 0xFA0F, 0xFA10, 0x589E, 0x58B2,
/* index 9306 */
/* index 9118 */
0x590B, 0x5953, 0x595B, 0x595D, 0x5963, 0x59A4, 0x59BA,
0x5B56, 0x5BC0, 0x752F, 0x5BD8, 0x5BEC, 0x5C1E, 0x5CA6, 0x5CBA,
0x5CF5, 0x5D27, 0x5D53, 0xFA11, 0x5D42, 0x5D6D, 0x5DB8, 0x5DB9,
@ -1451,7 +1385,7 @@ static const uint16_t gJapaneseMap[] = {
0x6844, 0x68CF, 0xFA13, 0x6968, 0xFA14, 0x6998, 0x69E2, 0x6A30,
0x6A6B, 0x6A46, 0x6A73, 0x6A7E, 0x6AE2, 0x6AE4, 0x6BD6, 0x6C3F,
0x6C5C, 0x6C86, 0x6C6F, 0x6CDA, 0x6D04, 0x6D87, 0x6D6F,
/* index 9400 */
/* index 9212 */
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x02D8,
0x02C7, 0x00B8, 0x02D9, 0x02DD, 0x00AF, 0x02DB, 0x02DA, 0xFF5E,
@ -1464,7 +1398,7 @@ static const uint16_t gJapaneseMap[] = {
0xFFFD, 0xFFFD, 0xFFFD, 0x00BA, 0x00AA, 0x00A9, 0x00AE, 0x2122,
0x00A4, 0x2116, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
/* index 9494 */
/* index 9306 */
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
@ -1477,7 +1411,7 @@ static const uint16_t gJapaneseMap[] = {
0xFFFD, 0x038E, 0x03AB, 0xFFFD, 0x038F, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0x03AC, 0x03AD, 0x03AE, 0x03AF, 0x03CA, 0x0390, 0x03CC,
0x03C2, 0x03CD, 0x03CB, 0x03B0, 0x03CE, 0xFFFD, 0xFFFD,
/* index 9588 */
/* index 9400 */
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
@ -1490,7 +1424,7 @@ static const uint16_t gJapaneseMap[] = {
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457,
0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x045E, 0x045F,
/* index 9682 */
/* index 9494 */
0x00C6, 0x0110, 0xFFFD, 0x0126, 0xFFFD, 0x0132, 0xFFFD,
0x0141, 0x013F, 0xFFFD, 0x014A, 0x00D8, 0x0152, 0xFFFD, 0x0166,
0x00DE, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
@ -1503,7 +1437,7 @@ static const uint16_t gJapaneseMap[] = {
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
/* index 9776 */
/* index 9588 */
0x00C1, 0x00C0, 0x00C4, 0x00C2, 0x0102, 0x01CD, 0x0100,
0x0104, 0x00C5, 0x00C3, 0x0106, 0x0108, 0x010C, 0x00C7, 0x010A,
0x010E, 0x00C9, 0x00C8, 0x00CB, 0x00CA, 0x011A, 0x0116, 0x0112,
@ -1516,7 +1450,7 @@ static const uint16_t gJapaneseMap[] = {
0x0170, 0x016A, 0x0172, 0x016E, 0x0168, 0x01D7, 0x01DB, 0x01D9,
0x01D5, 0x0174, 0x00DD, 0x0178, 0x0176, 0x0179, 0x017D, 0x017B,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
/* index 9870 */
/* index 9682 */
0x00E1, 0x00E0, 0x00E4, 0x00E2, 0x0103, 0x01CE, 0x0101,
0x0105, 0x00E5, 0x00E3, 0x0107, 0x0109, 0x010D, 0x00E7, 0x010B,
0x010F, 0x00E9, 0x00E8, 0x00EB, 0x00EA, 0x011B, 0x0117, 0x0113,
@ -1529,7 +1463,7 @@ static const uint16_t gJapaneseMap[] = {
0x0171, 0x016B, 0x0173, 0x016F, 0x0169, 0x01D8, 0x01DC, 0x01DA,
0x01D6, 0x0175, 0x00FD, 0x00FF, 0x0177, 0x017A, 0x017E, 0x017C,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
/* index 9964 */
/* index 9776 */
0x4E02, 0x4E04, 0x4E05, 0x4E0C, 0x4E12, 0x4E1F, 0x4E23,
0x4E24, 0x4E28, 0x4E2B, 0x4E2E, 0x4E2F, 0x4E30, 0x4E35, 0x4E40,
0x4E41, 0x4E44, 0x4E47, 0x4E51, 0x4E5A, 0x4E5C, 0x4E63, 0x4E68,
@ -1542,7 +1476,7 @@ static const uint16_t gJapaneseMap[] = {
0x4F48, 0x4F49, 0x4F4B, 0x4F4C, 0x4F52, 0x4F54, 0x4F56, 0x4F58,
0x4F5F, 0x4F63, 0x4F6A, 0x4F6C, 0x4F6E, 0x4F71, 0x4F77, 0x4F78,
0x4F79, 0x4F7A, 0x4F7D, 0x4F7E, 0x4F81, 0x4F82, 0x4F84,
/* index 10058 */
/* index 9870 */
0x4F85, 0x4F89, 0x4F8A, 0x4F8C, 0x4F8E, 0x4F90, 0x4F92,
0x4F93, 0x4F94, 0x4F97, 0x4F99, 0x4F9A, 0x4F9E, 0x4F9F, 0x4FB2,
0x4FB7, 0x4FB9, 0x4FBB, 0x4FBC, 0x4FBD, 0x4FBE, 0x4FC0, 0x4FC1,
@ -1555,7 +1489,7 @@ static const uint16_t gJapaneseMap[] = {
0x5052, 0x5053, 0x5057, 0x5059, 0x505F, 0x5060, 0x5062, 0x5063,
0x5066, 0x5067, 0x506A, 0x506D, 0x5070, 0x5071, 0x503B, 0x5081,
0x5083, 0x5084, 0x5086, 0x508A, 0x508E, 0x508F, 0x5090,
/* index 10152 */
/* index 9964 */
0x5092, 0x5093, 0x5094, 0x5096, 0x509B, 0x509C, 0x509E,
0x509F, 0x50A0, 0x50A1, 0x50A2, 0x50AA, 0x50AF, 0x50B0, 0x50B9,
0x50BA, 0x50BD, 0x50C0, 0x50C3, 0x50C4, 0x50C7, 0x50CC, 0x50CE,
@ -1568,7 +1502,7 @@ static const uint16_t gJapaneseMap[] = {
0x5153, 0x5155, 0x5157, 0x5158, 0x515F, 0x5164, 0x5166, 0x517E,
0x5183, 0x5184, 0x518B, 0x518E, 0x5198, 0x519D, 0x51A1, 0x51A3,
0x51AD, 0x51B8, 0x51BA, 0x51BC, 0x51BE, 0x51BF, 0x51C2,
/* index 10246 */
/* index 10058 */
0x51C8, 0x51CF, 0x51D1, 0x51D2, 0x51D3, 0x51D5, 0x51D8,
0x51DE, 0x51E2, 0x51E5, 0x51EE, 0x51F2, 0x51F3, 0x51F4, 0x51F7,
0x5201, 0x5202, 0x5205, 0x5212, 0x5213, 0x5215, 0x5216, 0x5218,
@ -1581,7 +1515,7 @@ static const uint16_t gJapaneseMap[] = {
0x52C8, 0x52CC, 0x52CF, 0x52D1, 0x52D4, 0x52D6, 0x52DB, 0x52DC,
0x52E1, 0x52E5, 0x52E8, 0x52E9, 0x52EA, 0x52EC, 0x52F0, 0x52F1,
0x52F4, 0x52F6, 0x52F7, 0x5300, 0x5303, 0x530A, 0x530B,
/* index 10340 */
/* index 10152 */
0x530C, 0x5311, 0x5313, 0x5318, 0x531B, 0x531C, 0x531E,
0x531F, 0x5325, 0x5327, 0x5328, 0x5329, 0x532B, 0x532C, 0x532D,
0x5330, 0x5332, 0x5335, 0x533C, 0x533D, 0x533E, 0x5342, 0x534C,
@ -1594,7 +1528,7 @@ static const uint16_t gJapaneseMap[] = {
0x5427, 0x5428, 0x542A, 0x542F, 0x5431, 0x5434, 0x5435, 0x5443,
0x5444, 0x5447, 0x544D, 0x544F, 0x545E, 0x5462, 0x5464, 0x5466,
0x5467, 0x5469, 0x546B, 0x546D, 0x546E, 0x5474, 0x547F,
/* index 10434 */
/* index 10246 */
0x5481, 0x5483, 0x5485, 0x5488, 0x5489, 0x548D, 0x5491,
0x5495, 0x5496, 0x549C, 0x549F, 0x54A1, 0x54A6, 0x54A7, 0x54A9,
0x54AA, 0x54AD, 0x54AE, 0x54B1, 0x54B7, 0x54B9, 0x54BA, 0x54BB,
@ -1607,7 +1541,7 @@ static const uint16_t gJapaneseMap[] = {
0x5586, 0x5588, 0x558E, 0x558F, 0x5591, 0x5592, 0x5593, 0x5594,
0x5597, 0x55A3, 0x55A4, 0x55AD, 0x55B2, 0x55BF, 0x55C1, 0x55C3,
0x55C6, 0x55C9, 0x55CB, 0x55CC, 0x55CE, 0x55D1, 0x55D2,
/* index 10528 */
/* index 10340 */
0x55D3, 0x55D7, 0x55D8, 0x55DB, 0x55DE, 0x55E2, 0x55E9,
0x55F6, 0x55FF, 0x5605, 0x5608, 0x560A, 0x560D, 0x560E, 0x560F,
0x5610, 0x5611, 0x5612, 0x5619, 0x562C, 0x5630, 0x5633, 0x5635,
@ -1620,7 +1554,7 @@ static const uint16_t gJapaneseMap[] = {
0x56B7, 0x56BE, 0x56C5, 0x56C9, 0x56CA, 0x56CB, 0x56CF, 0x56D0,
0x56CC, 0x56CD, 0x56D9, 0x56DC, 0x56DD, 0x56DF, 0x56E1, 0x56E4,
0x56E5, 0x56E6, 0x56E7, 0x56E8, 0x56F1, 0x56EB, 0x56ED,
/* index 10622 */
/* index 10434 */
0x56F6, 0x56F7, 0x5701, 0x5702, 0x5707, 0x570A, 0x570C,
0x5711, 0x5715, 0x571A, 0x571B, 0x571D, 0x5720, 0x5722, 0x5723,
0x5724, 0x5725, 0x5729, 0x572A, 0x572C, 0x572E, 0x572F, 0x5733,
@ -1633,7 +1567,7 @@ static const uint16_t gJapaneseMap[] = {
0x57C8, 0x57CC, 0x57CF, 0x57D5, 0x57DD, 0x57DE, 0x57E4, 0x57E6,
0x57E7, 0x57E9, 0x57ED, 0x57F0, 0x57F5, 0x57F6, 0x57F8, 0x57FD,
0x57FE, 0x57FF, 0x5803, 0x5804, 0x5808, 0x5809, 0x57E1,
/* index 10716 */
/* index 10528 */
0x580C, 0x580D, 0x581B, 0x581E, 0x581F, 0x5820, 0x5826,
0x5827, 0x582D, 0x5832, 0x5839, 0x583F, 0x5849, 0x584C, 0x584D,
0x584F, 0x5850, 0x5855, 0x585F, 0x5861, 0x5864, 0x5867, 0x5868,
@ -1646,7 +1580,7 @@ static const uint16_t gJapaneseMap[] = {
0x5921, 0x5923, 0x5924, 0x5928, 0x592F, 0x5930, 0x5933, 0x5935,
0x5936, 0x593F, 0x5943, 0x5946, 0x5952, 0x5953, 0x5959, 0x595B,
0x595D, 0x595E, 0x595F, 0x5961, 0x5963, 0x596B, 0x596D,
/* index 10810 */
/* index 10622 */
0x596F, 0x5972, 0x5975, 0x5976, 0x5979, 0x597B, 0x597C,
0x598B, 0x598C, 0x598E, 0x5992, 0x5995, 0x5997, 0x599F, 0x59A4,
0x59A7, 0x59AD, 0x59AE, 0x59AF, 0x59B0, 0x59B3, 0x59B7, 0x59BA,
@ -1659,7 +1593,7 @@ static const uint16_t gJapaneseMap[] = {
0x5A7A, 0x5A7B, 0x5A7E, 0x5A8B, 0x5A90, 0x5A93, 0x5A96, 0x5A99,
0x5A9C, 0x5A9E, 0x5A9F, 0x5AA0, 0x5AA2, 0x5AA7, 0x5AAC, 0x5AB1,
0x5AB2, 0x5AB3, 0x5AB5, 0x5AB8, 0x5ABA, 0x5ABB, 0x5ABF,
/* index 10904 */
/* index 10716 */
0x5AC4, 0x5AC6, 0x5AC8, 0x5ACF, 0x5ADA, 0x5ADC, 0x5AE0,
0x5AE5, 0x5AEA, 0x5AEE, 0x5AF5, 0x5AF6, 0x5AFD, 0x5B00, 0x5B01,
0x5B08, 0x5B17, 0x5B34, 0x5B19, 0x5B1B, 0x5B1D, 0x5B21, 0x5B25,
@ -1672,7 +1606,7 @@ static const uint16_t gJapaneseMap[] = {
0x5BFD, 0x5C0C, 0x5C17, 0x5C1E, 0x5C1F, 0x5C23, 0x5C26, 0x5C29,
0x5C2B, 0x5C2C, 0x5C2E, 0x5C30, 0x5C32, 0x5C35, 0x5C36, 0x5C59,
0x5C5A, 0x5C5C, 0x5C62, 0x5C63, 0x5C67, 0x5C68, 0x5C69,
/* index 10998 */
/* index 10810 */
0x5C6D, 0x5C70, 0x5C74, 0x5C75, 0x5C7A, 0x5C7B, 0x5C7C,
0x5C7D, 0x5C87, 0x5C88, 0x5C8A, 0x5C8F, 0x5C92, 0x5C9D, 0x5C9F,
0x5CA0, 0x5CA2, 0x5CA3, 0x5CA6, 0x5CAA, 0x5CB2, 0x5CB4, 0x5CB5,
@ -1685,7 +1619,7 @@ static const uint16_t gJapaneseMap[] = {
0x5D92, 0x5D93, 0x5D94, 0x5D95, 0x5D99, 0x5D9B, 0x5D9F, 0x5DA0,
0x5DA7, 0x5DAB, 0x5DB0, 0x5DB4, 0x5DB8, 0x5DB9, 0x5DC3, 0x5DC7,
0x5DCB, 0x5DD0, 0x5DCE, 0x5DD8, 0x5DD9, 0x5DE0, 0x5DE4,
/* index 11092 */
/* index 10904 */
0x5DE9, 0x5DF8, 0x5DF9, 0x5E00, 0x5E07, 0x5E0D, 0x5E12,
0x5E14, 0x5E15, 0x5E18, 0x5E1F, 0x5E20, 0x5E2E, 0x5E28, 0x5E32,
0x5E35, 0x5E3E, 0x5E4B, 0x5E50, 0x5E49, 0x5E51, 0x5E56, 0x5E58,
@ -1698,7 +1632,7 @@ static const uint16_t gJapaneseMap[] = {
0x5F28, 0x5F2B, 0x5F2C, 0x5F2E, 0x5F30, 0x5F34, 0x5F36, 0x5F3B,
0x5F3D, 0x5F3F, 0x5F40, 0x5F44, 0x5F45, 0x5F47, 0x5F4D, 0x5F50,
0x5F54, 0x5F58, 0x5F5B, 0x5F60, 0x5F63, 0x5F64, 0x5F67,
/* index 11186 */
/* index 10998 */
0x5F6F, 0x5F72, 0x5F74, 0x5F75, 0x5F78, 0x5F7A, 0x5F7D,
0x5F7E, 0x5F89, 0x5F8D, 0x5F8F, 0x5F96, 0x5F9C, 0x5F9D, 0x5FA2,
0x5FA7, 0x5FAB, 0x5FA4, 0x5FAC, 0x5FAF, 0x5FB0, 0x5FB1, 0x5FB8,
@ -1711,7 +1645,7 @@ static const uint16_t gJapaneseMap[] = {
0x6061, 0x6067, 0x6071, 0x607E, 0x607F, 0x6082, 0x6086, 0x6088,
0x608A, 0x608E, 0x6091, 0x6093, 0x6095, 0x6098, 0x609D, 0x609E,
0x60A2, 0x60A4, 0x60A5, 0x60A8, 0x60B0, 0x60B1, 0x60B7,
/* index 11280 */
/* index 11092 */
0x60BB, 0x60BE, 0x60C2, 0x60C4, 0x60C8, 0x60C9, 0x60CA,
0x60CB, 0x60CE, 0x60CF, 0x60D4, 0x60D5, 0x60D9, 0x60DB, 0x60DD,
0x60DE, 0x60E2, 0x60E5, 0x60F2, 0x60F5, 0x60F8, 0x60FC, 0x60FD,
@ -1724,7 +1658,7 @@ static const uint16_t gJapaneseMap[] = {
0x61A0, 0x61A5, 0x61A8, 0x61AA, 0x61AD, 0x61B8, 0x61B9, 0x61BC,
0x61C0, 0x61C1, 0x61C2, 0x61CE, 0x61CF, 0x61D5, 0x61DC, 0x61DD,
0x61DE, 0x61DF, 0x61E1, 0x61E2, 0x61E7, 0x61E9, 0x61E5,
/* index 11374 */
/* index 11186 */
0x61EC, 0x61ED, 0x61EF, 0x6201, 0x6203, 0x6204, 0x6207,
0x6213, 0x6215, 0x621C, 0x6220, 0x6222, 0x6223, 0x6227, 0x6229,
0x622B, 0x6239, 0x623D, 0x6242, 0x6243, 0x6244, 0x6246, 0x624C,
@ -1737,7 +1671,7 @@ static const uint16_t gJapaneseMap[] = {
0x6336, 0x6339, 0x633C, 0x6341, 0x6342, 0x6343, 0x6344, 0x6346,
0x634A, 0x634B, 0x634E, 0x6352, 0x6353, 0x6354, 0x6358, 0x635B,
0x6365, 0x6366, 0x636C, 0x636D, 0x6371, 0x6374, 0x6375,
/* index 11468 */
/* index 11280 */
0x6378, 0x637C, 0x637D, 0x637F, 0x6382, 0x6384, 0x6387,
0x638A, 0x6390, 0x6394, 0x6395, 0x6399, 0x639A, 0x639E, 0x63A4,
0x63A6, 0x63AD, 0x63AE, 0x63AF, 0x63BD, 0x63C1, 0x63C5, 0x63C8,
@ -1750,7 +1684,7 @@ static const uint16_t gJapaneseMap[] = {
0x6473, 0x6474, 0x647B, 0x647D, 0x6485, 0x6487, 0x648F, 0x6490,
0x6491, 0x6498, 0x6499, 0x649B, 0x649D, 0x649F, 0x64A1, 0x64A3,
0x64A6, 0x64A8, 0x64AC, 0x64B3, 0x64BD, 0x64BE, 0x64BF,
/* index 11562 */
/* index 11374 */
0x64C4, 0x64C9, 0x64CA, 0x64CB, 0x64CC, 0x64CE, 0x64D0,
0x64D1, 0x64D5, 0x64D7, 0x64E4, 0x64E5, 0x64E9, 0x64EA, 0x64ED,
0x64F0, 0x64F5, 0x64F7, 0x64FB, 0x64FF, 0x6501, 0x6504, 0x6508,
@ -1763,7 +1697,7 @@ static const uint16_t gJapaneseMap[] = {
0x65CE, 0x65D0, 0x65D4, 0x65D6, 0x65D8, 0x65DF, 0x65F0, 0x65F2,
0x65F4, 0x65F5, 0x65F9, 0x65FE, 0x65FF, 0x6600, 0x6604, 0x6608,
0x6609, 0x660D, 0x6611, 0x6612, 0x6615, 0x6616, 0x661D,
/* index 11656 */
/* index 11468 */
0x661E, 0x6621, 0x6622, 0x6623, 0x6624, 0x6626, 0x6629,
0x662A, 0x662B, 0x662C, 0x662E, 0x6630, 0x6631, 0x6633, 0x6639,
0x6637, 0x6640, 0x6645, 0x6646, 0x664A, 0x664C, 0x6651, 0x664E,
@ -1776,7 +1710,7 @@ static const uint16_t gJapaneseMap[] = {
0x66DF, 0x66E8, 0x66EB, 0x66EC, 0x66EE, 0x66FA, 0x6705, 0x6707,
0x670E, 0x6713, 0x6719, 0x671C, 0x6720, 0x6722, 0x6733, 0x673E,
0x6745, 0x6747, 0x6748, 0x674C, 0x6754, 0x6755, 0x675D,
/* index 11750 */
/* index 11562 */
0x6766, 0x676C, 0x676E, 0x6774, 0x6776, 0x677B, 0x6781,
0x6784, 0x678E, 0x678F, 0x6791, 0x6793, 0x6796, 0x6798, 0x6799,
0x679B, 0x67B0, 0x67B1, 0x67B2, 0x67B5, 0x67BB, 0x67BC, 0x67BD,
@ -1789,7 +1723,7 @@ static const uint16_t gJapaneseMap[] = {
0x687A, 0x687B, 0x687C, 0x6882, 0x6884, 0x6886, 0x6888, 0x6896,
0x6898, 0x689A, 0x689C, 0x68A1, 0x68A3, 0x68A5, 0x68A9, 0x68AA,
0x68AE, 0x68B2, 0x68BB, 0x68C5, 0x68C8, 0x68CC, 0x68CF,
/* index 11844 */
/* index 11656 */
0x68D0, 0x68D1, 0x68D3, 0x68D6, 0x68D9, 0x68DC, 0x68DD,
0x68E5, 0x68E8, 0x68EA, 0x68EB, 0x68EC, 0x68ED, 0x68F0, 0x68F1,
0x68F5, 0x68F6, 0x68FB, 0x68FC, 0x68FD, 0x6906, 0x6909, 0x690A,
@ -1802,7 +1736,7 @@ static const uint16_t gJapaneseMap[] = {
0x69D6, 0x69D7, 0x69E2, 0x69E5, 0x69EE, 0x69EF, 0x69F1, 0x69F3,
0x69F5, 0x69FE, 0x6A00, 0x6A01, 0x6A03, 0x6A0F, 0x6A11, 0x6A15,
0x6A1A, 0x6A1D, 0x6A20, 0x6A24, 0x6A28, 0x6A30, 0x6A32,
/* index 11938 */
/* index 11750 */
0x6A34, 0x6A37, 0x6A3B, 0x6A3E, 0x6A3F, 0x6A45, 0x6A46,
0x6A49, 0x6A4A, 0x6A4E, 0x6A50, 0x6A51, 0x6A52, 0x6A55, 0x6A56,
0x6A5B, 0x6A64, 0x6A67, 0x6A6A, 0x6A71, 0x6A73, 0x6A7E, 0x6A81,
@ -1815,7 +1749,7 @@ static const uint16_t gJapaneseMap[] = {
0x6B24, 0x6B28, 0x6B2B, 0x6B2C, 0x6B2F, 0x6B35, 0x6B36, 0x6B3B,
0x6B3F, 0x6B46, 0x6B4A, 0x6B4D, 0x6B52, 0x6B56, 0x6B58, 0x6B5D,
0x6B60, 0x6B67, 0x6B6B, 0x6B6E, 0x6B70, 0x6B75, 0x6B7D,
/* index 12032 */
/* index 11844 */
0x6B7E, 0x6B82, 0x6B85, 0x6B97, 0x6B9B, 0x6B9F, 0x6BA0,
0x6BA2, 0x6BA3, 0x6BA8, 0x6BA9, 0x6BAC, 0x6BAD, 0x6BAE, 0x6BB0,
0x6BB8, 0x6BB9, 0x6BBD, 0x6BBE, 0x6BC3, 0x6BC4, 0x6BC9, 0x6BCC,
@ -1828,7 +1762,7 @@ static const uint16_t gJapaneseMap[] = {
0x6C7B, 0x6C85, 0x6C86, 0x6C87, 0x6C89, 0x6C94, 0x6C95, 0x6C97,
0x6C98, 0x6C9C, 0x6C9F, 0x6CB0, 0x6CB2, 0x6CB4, 0x6CC2, 0x6CC6,
0x6CCD, 0x6CCF, 0x6CD0, 0x6CD1, 0x6CD2, 0x6CD4, 0x6CD6,
/* index 12126 */
/* index 11938 */
0x6CDA, 0x6CDC, 0x6CE0, 0x6CE7, 0x6CE9, 0x6CEB, 0x6CEC,
0x6CEE, 0x6CF2, 0x6CF4, 0x6D04, 0x6D07, 0x6D0A, 0x6D0E, 0x6D0F,
0x6D11, 0x6D13, 0x6D1A, 0x6D26, 0x6D27, 0x6D28, 0x6C67, 0x6D2E,
@ -1841,7 +1775,7 @@ static const uint16_t gJapaneseMap[] = {
0x6E04, 0x6E1E, 0x6E22, 0x6E27, 0x6E32, 0x6E36, 0x6E39, 0x6E3B,
0x6E3C, 0x6E44, 0x6E45, 0x6E48, 0x6E49, 0x6E4B, 0x6E4F, 0x6E51,
0x6E52, 0x6E53, 0x6E54, 0x6E57, 0x6E5C, 0x6E5D, 0x6E5E,
/* index 12220 */
/* index 12032 */
0x6E62, 0x6E63, 0x6E68, 0x6E73, 0x6E7B, 0x6E7D, 0x6E8D,
0x6E93, 0x6E99, 0x6EA0, 0x6EA7, 0x6EAD, 0x6EAE, 0x6EB1, 0x6EB3,
0x6EBB, 0x6EBF, 0x6EC0, 0x6EC1, 0x6EC3, 0x6EC7, 0x6EC8, 0x6ECA,
@ -1854,7 +1788,7 @@ static const uint16_t gJapaneseMap[] = {
0x6F8D, 0x6F90, 0x6F92, 0x6F93, 0x6F94, 0x6F96, 0x6F9A, 0x6F9F,
0x6FA0, 0x6FA5, 0x6FA6, 0x6FA7, 0x6FA8, 0x6FAE, 0x6FAF, 0x6FB0,
0x6FB5, 0x6FB6, 0x6FBC, 0x6FC5, 0x6FC7, 0x6FC8, 0x6FCA,
/* index 12314 */
/* index 12126 */
0x6FDA, 0x6FDE, 0x6FE8, 0x6FE9, 0x6FF0, 0x6FF5, 0x6FF9,
0x6FFC, 0x6FFD, 0x7000, 0x7005, 0x7006, 0x7007, 0x700D, 0x7017,
0x7020, 0x7023, 0x702F, 0x7034, 0x7037, 0x7039, 0x703C, 0x7043,
@ -1867,7 +1801,7 @@ static const uint16_t gJapaneseMap[] = {
0x710C, 0x710F, 0x711E, 0x7120, 0x712B, 0x712D, 0x712F, 0x7130,
0x7131, 0x7138, 0x7141, 0x7145, 0x7146, 0x7147, 0x714A, 0x714B,
0x7150, 0x7152, 0x7157, 0x715A, 0x715C, 0x715E, 0x7160,
/* index 12408 */
/* index 12220 */
0x7168, 0x7179, 0x7180, 0x7185, 0x7187, 0x718C, 0x7192,
0x719A, 0x719B, 0x71A0, 0x71A2, 0x71AF, 0x71B0, 0x71B2, 0x71B3,
0x71BA, 0x71BF, 0x71C0, 0x71C1, 0x71C4, 0x71CB, 0x71CC, 0x71D3,
@ -1880,7 +1814,7 @@ static const uint16_t gJapaneseMap[] = {
0x728D, 0x728E, 0x7293, 0x729B, 0x72A8, 0x72AD, 0x72AE, 0x72B1,
0x72B4, 0x72BE, 0x72C1, 0x72C7, 0x72C9, 0x72CC, 0x72D5, 0x72D6,
0x72D8, 0x72DF, 0x72E5, 0x72F3, 0x72F4, 0x72FA, 0x72FB,
/* index 12502 */
/* index 12314 */
0x72FE, 0x7302, 0x7304, 0x7305, 0x7307, 0x730B, 0x730D,
0x7312, 0x7313, 0x7318, 0x7319, 0x731E, 0x7322, 0x7324, 0x7327,
0x7328, 0x732C, 0x7331, 0x7332, 0x7335, 0x733A, 0x733B, 0x733D,
@ -1893,7 +1827,7 @@ static const uint16_t gJapaneseMap[] = {
0x73C5, 0x73C6, 0x73C9, 0x73CB, 0x73CC, 0x73CF, 0x73D2, 0x73D3,
0x73D6, 0x73D9, 0x73DD, 0x73E1, 0x73E3, 0x73E6, 0x73E7, 0x73E9,
0x73F4, 0x73F5, 0x73F7, 0x73F9, 0x73FA, 0x73FB, 0x73FD,
/* index 12596 */
/* index 12408 */
0x73FF, 0x7400, 0x7401, 0x7404, 0x7407, 0x740A, 0x7411,
0x741A, 0x741B, 0x7424, 0x7426, 0x7428, 0x7429, 0x742A, 0x742B,
0x742C, 0x742D, 0x742E, 0x742F, 0x7430, 0x7431, 0x7439, 0x7440,
@ -1906,7 +1840,7 @@ static const uint16_t gJapaneseMap[] = {
0x74BB, 0x74BF, 0x74C8, 0x74C9, 0x74CC, 0x74D0, 0x74D3, 0x74D8,
0x74DA, 0x74DB, 0x74DE, 0x74DF, 0x74E4, 0x74E8, 0x74EA, 0x74EB,
0x74EF, 0x74F4, 0x74FA, 0x74FB, 0x74FC, 0x74FF, 0x7506,
/* index 12690 */
/* index 12502 */
0x7512, 0x7516, 0x7517, 0x7520, 0x7521, 0x7524, 0x7527,
0x7529, 0x752A, 0x752F, 0x7536, 0x7539, 0x753D, 0x753E, 0x753F,
0x7540, 0x7543, 0x7547, 0x7548, 0x754E, 0x7550, 0x7552, 0x7557,
@ -1919,7 +1853,7 @@ static const uint16_t gJapaneseMap[] = {
0x7608, 0x760A, 0x760C, 0x760F, 0x7612, 0x7613, 0x7615, 0x7616,
0x7619, 0x761B, 0x761C, 0x761D, 0x761E, 0x7623, 0x7625, 0x7626,
0x7629, 0x762D, 0x7632, 0x7633, 0x7635, 0x7638, 0x7639,
/* index 12784 */
/* index 12596 */
0x763A, 0x763C, 0x764A, 0x7640, 0x7641, 0x7643, 0x7644,
0x7645, 0x7649, 0x764B, 0x7655, 0x7659, 0x765F, 0x7664, 0x7665,
0x766D, 0x766E, 0x766F, 0x7671, 0x7674, 0x7681, 0x7685, 0x768C,
@ -1932,7 +1866,7 @@ static const uint16_t gJapaneseMap[] = {
0x772E, 0x772F, 0x7734, 0x7735, 0x7736, 0x7739, 0x773D, 0x773E,
0x7742, 0x7745, 0x7746, 0x774A, 0x774D, 0x774E, 0x774F, 0x7752,
0x7756, 0x7757, 0x775C, 0x775E, 0x775F, 0x7760, 0x7762,
/* index 12878 */
/* index 12690 */
0x7764, 0x7767, 0x776A, 0x776C, 0x7770, 0x7772, 0x7773,
0x7774, 0x777A, 0x777D, 0x7780, 0x7784, 0x778C, 0x778D, 0x7794,
0x7795, 0x7796, 0x779A, 0x779F, 0x77A2, 0x77A7, 0x77AA, 0x77AE,
@ -1945,7 +1879,7 @@ static const uint16_t gJapaneseMap[] = {
0x7863, 0x7864, 0x7868, 0x786A, 0x786E, 0x787A, 0x787E, 0x788A,
0x788F, 0x7894, 0x7898, 0x78A1, 0x789D, 0x789E, 0x789F, 0x78A4,
0x78A8, 0x78AC, 0x78AD, 0x78B0, 0x78B1, 0x78B2, 0x78B3,
/* index 12972 */
/* index 12784 */
0x78BB, 0x78BD, 0x78BF, 0x78C7, 0x78C8, 0x78C9, 0x78CC,
0x78CE, 0x78D2, 0x78D3, 0x78D5, 0x78D6, 0x78E4, 0x78DB, 0x78DF,
0x78E0, 0x78E1, 0x78E6, 0x78EA, 0x78F2, 0x78F3, 0x7900, 0x78F6,
@ -1958,7 +1892,7 @@ static const uint16_t gJapaneseMap[] = {
0x7998, 0x799B, 0x799C, 0x79A1, 0x79A8, 0x79A9, 0x79AB, 0x79AF,
0x79B1, 0x79B4, 0x79B8, 0x79BB, 0x79C2, 0x79C4, 0x79C7, 0x79C8,
0x79CA, 0x79CF, 0x79D4, 0x79D6, 0x79DA, 0x79DD, 0x79DE,
/* index 13066 */
/* index 12878 */
0x79E0, 0x79E2, 0x79E5, 0x79EA, 0x79EB, 0x79ED, 0x79F1,
0x79F8, 0x79FC, 0x7A02, 0x7A03, 0x7A07, 0x7A09, 0x7A0A, 0x7A0C,
0x7A11, 0x7A15, 0x7A1B, 0x7A1E, 0x7A21, 0x7A27, 0x7A2B, 0x7A2D,
@ -1971,7 +1905,7 @@ static const uint16_t gJapaneseMap[] = {
0x7AD1, 0x7ADB, 0x7AE8, 0x7AE9, 0x7AEB, 0x7AEC, 0x7AF1, 0x7AF4,
0x7AFB, 0x7AFD, 0x7AFE, 0x7B07, 0x7B14, 0x7B1F, 0x7B23, 0x7B27,
0x7B29, 0x7B2A, 0x7B2B, 0x7B2D, 0x7B2E, 0x7B2F, 0x7B30,
/* index 13160 */
/* index 12972 */
0x7B31, 0x7B34, 0x7B3D, 0x7B3F, 0x7B40, 0x7B41, 0x7B47,
0x7B4E, 0x7B55, 0x7B60, 0x7B64, 0x7B66, 0x7B69, 0x7B6A, 0x7B6D,
0x7B6F, 0x7B72, 0x7B73, 0x7B77, 0x7B84, 0x7B89, 0x7B8E, 0x7B90,
@ -1984,7 +1918,7 @@ static const uint16_t gJapaneseMap[] = {
0x7C20, 0x7C25, 0x7C26, 0x7C28, 0x7C2C, 0x7C31, 0x7C33, 0x7C34,
0x7C36, 0x7C39, 0x7C3A, 0x7C46, 0x7C4A, 0x7C55, 0x7C51, 0x7C52,
0x7C53, 0x7C59, 0x7C5A, 0x7C5B, 0x7C5C, 0x7C5D, 0x7C5E,
/* index 13254 */
/* index 13066 */
0x7C61, 0x7C63, 0x7C67, 0x7C69, 0x7C6D, 0x7C6E, 0x7C70,
0x7C72, 0x7C79, 0x7C7C, 0x7C7D, 0x7C86, 0x7C87, 0x7C8F, 0x7C94,
0x7C9E, 0x7CA0, 0x7CA6, 0x7CB0, 0x7CB6, 0x7CB7, 0x7CBA, 0x7CBB,
@ -1997,7 +1931,7 @@ static const uint16_t gJapaneseMap[] = {
0x7D5C, 0x7D5D, 0x7D65, 0x7D67, 0x7D6A, 0x7D70, 0x7D78, 0x7D7A,
0x7D7B, 0x7D7F, 0x7D81, 0x7D82, 0x7D83, 0x7D85, 0x7D86, 0x7D88,
0x7D8B, 0x7D8C, 0x7D8D, 0x7D91, 0x7D96, 0x7D97, 0x7D9D,
/* index 13348 */
/* index 13160 */
0x7D9E, 0x7DA6, 0x7DA7, 0x7DAA, 0x7DB3, 0x7DB6, 0x7DB7,
0x7DB9, 0x7DC2, 0x7DC3, 0x7DC4, 0x7DC5, 0x7DC6, 0x7DCC, 0x7DCD,
0x7DCE, 0x7DD7, 0x7DD9, 0x7E00, 0x7DE2, 0x7DE5, 0x7DE6, 0x7DEA,
@ -2010,7 +1944,7 @@ static const uint16_t gJapaneseMap[] = {
0x7E9A, 0x7E9D, 0x7E9E, 0x7F3C, 0x7F3B, 0x7F3D, 0x7F3E, 0x7F3F,
0x7F43, 0x7F44, 0x7F47, 0x7F4F, 0x7F52, 0x7F53, 0x7F5B, 0x7F5C,
0x7F5D, 0x7F61, 0x7F63, 0x7F64, 0x7F65, 0x7F66, 0x7F6D,
/* index 13442 */
/* index 13254 */
0x7F71, 0x7F7D, 0x7F7E, 0x7F7F, 0x7F80, 0x7F8B, 0x7F8D,
0x7F8F, 0x7F90, 0x7F91, 0x7F96, 0x7F97, 0x7F9C, 0x7FA1, 0x7FA2,
0x7FA6, 0x7FAA, 0x7FAD, 0x7FB4, 0x7FBC, 0x7FBF, 0x7FC0, 0x7FC3,
@ -2023,7 +1957,7 @@ static const uint16_t gJapaneseMap[] = {
0x8071, 0x8075, 0x8081, 0x8088, 0x808E, 0x809C, 0x809E, 0x80A6,
0x80A7, 0x80AB, 0x80B8, 0x80B9, 0x80C8, 0x80CD, 0x80CF, 0x80D2,
0x80D4, 0x80D5, 0x80D7, 0x80D8, 0x80E0, 0x80ED, 0x80EE,
/* index 13536 */
/* index 13348 */
0x80F0, 0x80F2, 0x80F3, 0x80F6, 0x80F9, 0x80FA, 0x80FE,
0x8103, 0x810B, 0x8116, 0x8117, 0x8118, 0x811C, 0x811E, 0x8120,
0x8124, 0x8127, 0x812C, 0x8130, 0x8135, 0x813A, 0x813C, 0x8145,
@ -2036,7 +1970,7 @@ static const uint16_t gJapaneseMap[] = {
0x81F6, 0x81F8, 0x81F9, 0x81FD, 0x81FF, 0x8200, 0x8203, 0x820F,
0x8213, 0x8214, 0x8219, 0x821A, 0x821D, 0x8221, 0x8222, 0x8228,
0x8232, 0x8234, 0x823A, 0x8243, 0x8244, 0x8245, 0x8246,
/* index 13630 */
/* index 13442 */
0x824B, 0x824E, 0x824F, 0x8251, 0x8256, 0x825C, 0x8260,
0x8263, 0x8267, 0x826D, 0x8274, 0x827B, 0x827D, 0x827F, 0x8280,
0x8281, 0x8283, 0x8284, 0x8287, 0x8289, 0x828A, 0x828E, 0x8291,
@ -2049,7 +1983,7 @@ static const uint16_t gJapaneseMap[] = {
0x8321, 0x8322, 0x832C, 0x832D, 0x832E, 0x8330, 0x8333, 0x8337,
0x833A, 0x833C, 0x833D, 0x8342, 0x8343, 0x8344, 0x8347, 0x834D,
0x834E, 0x8351, 0x8355, 0x8356, 0x8357, 0x8370, 0x8378,
/* index 13724 */
/* index 13536 */
0x837D, 0x837F, 0x8380, 0x8382, 0x8384, 0x8386, 0x838D,
0x8392, 0x8394, 0x8395, 0x8398, 0x8399, 0x839B, 0x839C, 0x839D,
0x83A6, 0x83A7, 0x83A9, 0x83AC, 0x83BE, 0x83BF, 0x83C0, 0x83C7,
@ -2062,7 +1996,7 @@ static const uint16_t gJapaneseMap[] = {
0x8481, 0x8485, 0x8492, 0x8493, 0x8495, 0x849E, 0x84A6, 0x84A8,
0x84A9, 0x84AA, 0x84AF, 0x84B1, 0x84B4, 0x84BA, 0x84BD, 0x84BE,
0x84C0, 0x84C2, 0x84C7, 0x84C8, 0x84CC, 0x84CF, 0x84D3,
/* index 13818 */
/* index 13630 */
0x84DC, 0x84E7, 0x84EA, 0x84EF, 0x84F0, 0x84F1, 0x84F2,
0x84F7, 0x8532, 0x84FA, 0x84FB, 0x84FD, 0x8502, 0x8503, 0x8507,
0x850C, 0x850E, 0x8510, 0x851C, 0x851E, 0x8522, 0x8523, 0x8524,
@ -2075,7 +2009,7 @@ static const uint16_t gJapaneseMap[] = {
0x85B6, 0x85B7, 0x85B8, 0x85BC, 0x85BD, 0x85BE, 0x85BF, 0x85C2,
0x85C7, 0x85CA, 0x85CB, 0x85CE, 0x85AD, 0x85D8, 0x85DA, 0x85DF,
0x85E0, 0x85E6, 0x85E8, 0x85ED, 0x85F3, 0x85F6, 0x85FC,
/* index 13912 */
/* index 13724 */
0x85FF, 0x8600, 0x8604, 0x8605, 0x860D, 0x860E, 0x8610,
0x8611, 0x8612, 0x8618, 0x8619, 0x861B, 0x861E, 0x8621, 0x8627,
0x8629, 0x8636, 0x8638, 0x863A, 0x863C, 0x863D, 0x8640, 0x8642,
@ -2088,7 +2022,7 @@ static const uint16_t gJapaneseMap[] = {
0x86DC, 0x86E0, 0x86E3, 0x86E5, 0x86E7, 0x8688, 0x86FA, 0x86FC,
0x86FD, 0x8704, 0x8705, 0x8707, 0x870B, 0x870E, 0x870F, 0x8710,
0x8713, 0x8714, 0x8719, 0x871E, 0x871F, 0x8721, 0x8723,
/* index 14006 */
/* index 13818 */
0x8728, 0x872E, 0x872F, 0x8731, 0x8732, 0x8739, 0x873A,
0x873C, 0x873D, 0x873E, 0x8740, 0x8743, 0x8745, 0x874D, 0x8758,
0x875D, 0x8761, 0x8764, 0x8765, 0x876F, 0x8771, 0x8772, 0x877B,
@ -2101,7 +2035,7 @@ static const uint16_t gJapaneseMap[] = {
0x8801, 0x8803, 0x8806, 0x8809, 0x880A, 0x880B, 0x8810, 0x8819,
0x8812, 0x8813, 0x8814, 0x8818, 0x881A, 0x881B, 0x881C, 0x881E,
0x881F, 0x8828, 0x882D, 0x882E, 0x8830, 0x8832, 0x8835,
/* index 14100 */
/* index 13912 */
0x883A, 0x883C, 0x8841, 0x8843, 0x8845, 0x8848, 0x8849,
0x884A, 0x884B, 0x884E, 0x8851, 0x8855, 0x8856, 0x8858, 0x885A,
0x885C, 0x885F, 0x8860, 0x8864, 0x8869, 0x8871, 0x8879, 0x887B,
@ -2114,7 +2048,7 @@ static const uint16_t gJapaneseMap[] = {
0x8939, 0x893A, 0x893E, 0x8940, 0x8942, 0x8945, 0x8946, 0x8949,
0x894F, 0x8952, 0x8957, 0x895A, 0x895B, 0x895C, 0x8961, 0x8962,
0x8963, 0x896B, 0x896E, 0x8970, 0x8973, 0x8975, 0x897A,
/* index 14194 */
/* index 14006 */
0x897B, 0x897C, 0x897D, 0x8989, 0x898D, 0x8990, 0x8994,
0x8995, 0x899B, 0x899C, 0x899F, 0x89A0, 0x89A5, 0x89B0, 0x89B4,
0x89B5, 0x89B6, 0x89B7, 0x89BC, 0x89D4, 0x89D5, 0x89D6, 0x89D7,
@ -2127,7 +2061,7 @@ static const uint16_t gJapaneseMap[] = {
0x8A76, 0x8A77, 0x8A79, 0x8A7A, 0x8A7B, 0x8A7E, 0x8A7F, 0x8A80,
0x8A83, 0x8A86, 0x8A8B, 0x8A8F, 0x8A90, 0x8A92, 0x8A96, 0x8A97,
0x8A99, 0x8A9F, 0x8AA7, 0x8AA9, 0x8AAE, 0x8AAF, 0x8AB3,
/* index 14288 */
/* index 14100 */
0x8AB6, 0x8AB7, 0x8ABB, 0x8ABE, 0x8AC3, 0x8AC6, 0x8AC8,
0x8AC9, 0x8ACA, 0x8AD1, 0x8AD3, 0x8AD4, 0x8AD5, 0x8AD7, 0x8ADD,
0x8ADF, 0x8AEC, 0x8AF0, 0x8AF4, 0x8AF5, 0x8AF6, 0x8AFC, 0x8AFF,
@ -2140,7 +2074,7 @@ static const uint16_t gJapaneseMap[] = {
0x8C49, 0x8C4B, 0x8C4F, 0x8C51, 0x8C53, 0x8C54, 0x8C57, 0x8C58,
0x8C5B, 0x8C5D, 0x8C59, 0x8C63, 0x8C64, 0x8C66, 0x8C68, 0x8C69,
0x8C6D, 0x8C73, 0x8C75, 0x8C76, 0x8C7B, 0x8C7E, 0x8C86,
/* index 14382 */
/* index 14194 */
0x8C87, 0x8C8B, 0x8C90, 0x8C92, 0x8C93, 0x8C99, 0x8C9B,
0x8C9C, 0x8CA4, 0x8CB9, 0x8CBA, 0x8CC5, 0x8CC6, 0x8CC9, 0x8CCB,
0x8CCF, 0x8CD6, 0x8CD5, 0x8CD9, 0x8CDD, 0x8CE1, 0x8CE8, 0x8CEC,
@ -2153,7 +2087,7 @@ static const uint16_t gJapaneseMap[] = {
0x8DD7, 0x8DD9, 0x8DE4, 0x8DE5, 0x8DE7, 0x8DEC, 0x8DF0, 0x8DBC,
0x8DF1, 0x8DF2, 0x8DF4, 0x8DFD, 0x8E01, 0x8E04, 0x8E05, 0x8E06,
0x8E0B, 0x8E11, 0x8E14, 0x8E16, 0x8E20, 0x8E21, 0x8E22,
/* index 14476 */
/* index 14288 */
0x8E23, 0x8E26, 0x8E27, 0x8E31, 0x8E33, 0x8E36, 0x8E37,
0x8E38, 0x8E39, 0x8E3D, 0x8E40, 0x8E41, 0x8E4B, 0x8E4D, 0x8E4E,
0x8E4F, 0x8E54, 0x8E5B, 0x8E5C, 0x8E5D, 0x8E5E, 0x8E61, 0x8E62,
@ -2166,7 +2100,7 @@ static const uint16_t gJapaneseMap[] = {
0x8F08, 0x8F0F, 0x8F10, 0x8F16, 0x8F17, 0x8F18, 0x8F1E, 0x8F20,
0x8F21, 0x8F23, 0x8F25, 0x8F27, 0x8F28, 0x8F2C, 0x8F2D, 0x8F2E,
0x8F34, 0x8F35, 0x8F36, 0x8F37, 0x8F3A, 0x8F40, 0x8F41,
/* index 14570 */
/* index 14382 */
0x8F43, 0x8F47, 0x8F4F, 0x8F51, 0x8F52, 0x8F53, 0x8F54,
0x8F55, 0x8F58, 0x8F5D, 0x8F5E, 0x8F65, 0x8F9D, 0x8FA0, 0x8FA1,
0x8FA4, 0x8FA5, 0x8FA6, 0x8FB5, 0x8FB6, 0x8FB8, 0x8FBE, 0x8FC0,
@ -2179,7 +2113,7 @@ static const uint16_t gJapaneseMap[] = {
0x9088, 0x908B, 0x908C, 0x908E, 0x9090, 0x9095, 0x9097, 0x9098,
0x9099, 0x909B, 0x90A0, 0x90A1, 0x90A2, 0x90A5, 0x90B0, 0x90B2,
0x90B3, 0x90B4, 0x90B6, 0x90BD, 0x90CC, 0x90BE, 0x90C3,
/* index 14664 */
/* index 14476 */
0x90C4, 0x90C5, 0x90C7, 0x90C8, 0x90D5, 0x90D7, 0x90D8,
0x90D9, 0x90DC, 0x90DD, 0x90DF, 0x90E5, 0x90D2, 0x90F6, 0x90EB,
0x90EF, 0x90F0, 0x90F4, 0x90FE, 0x90FF, 0x9100, 0x9104, 0x9105,
@ -2192,7 +2126,7 @@ static const uint16_t gJapaneseMap[] = {
0x918A, 0x918E, 0x9191, 0x9193, 0x9194, 0x9195, 0x9198, 0x919E,
0x91A1, 0x91A6, 0x91A8, 0x91AC, 0x91AD, 0x91AE, 0x91B0, 0x91B1,
0x91B2, 0x91B3, 0x91B6, 0x91BB, 0x91BC, 0x91BD, 0x91BF,
/* index 14758 */
/* index 14570 */
0x91C2, 0x91C3, 0x91C5, 0x91D3, 0x91D4, 0x91D7, 0x91D9,
0x91DA, 0x91DE, 0x91E4, 0x91E5, 0x91E9, 0x91EA, 0x91EC, 0x91ED,
0x91EE, 0x91EF, 0x91F0, 0x91F1, 0x91F7, 0x91F9, 0x91FB, 0x91FD,
@ -2205,7 +2139,7 @@ static const uint16_t gJapaneseMap[] = {
0x9265, 0x9267, 0x9268, 0x9269, 0x926E, 0x926F, 0x9270, 0x9275,
0x9276, 0x9277, 0x9278, 0x9279, 0x927B, 0x927C, 0x927D, 0x927F,
0x9288, 0x9289, 0x928A, 0x928D, 0x928E, 0x9292, 0x9297,
/* index 14852 */
/* index 14664 */
0x9299, 0x929F, 0x92A0, 0x92A4, 0x92A5, 0x92A7, 0x92A8,
0x92AB, 0x92AF, 0x92B2, 0x92B6, 0x92B8, 0x92BA, 0x92BB, 0x92BC,
0x92BD, 0x92BF, 0x92C0, 0x92C1, 0x92C2, 0x92C3, 0x92C5, 0x92C6,
@ -2218,7 +2152,7 @@ static const uint16_t gJapaneseMap[] = {
0x9347, 0x9348, 0x9349, 0x9350, 0x9351, 0x9352, 0x9355, 0x9357,
0x9358, 0x935A, 0x935E, 0x9364, 0x9365, 0x9367, 0x9369, 0x936A,
0x936D, 0x936F, 0x9370, 0x9371, 0x9373, 0x9374, 0x9376,
/* index 14946 */
/* index 14758 */
0x937A, 0x937D, 0x937F, 0x9380, 0x9381, 0x9382, 0x9388,
0x938A, 0x938B, 0x938D, 0x938F, 0x9392, 0x9395, 0x9398, 0x939B,
0x939E, 0x93A1, 0x93A3, 0x93A4, 0x93A6, 0x93A8, 0x93AB, 0x93B4,
@ -2231,7 +2165,7 @@ static const uint16_t gJapaneseMap[] = {
0x943D, 0x9443, 0x9445, 0x9448, 0x944A, 0x944C, 0x9455, 0x9459,
0x945C, 0x945F, 0x9461, 0x9463, 0x9468, 0x946B, 0x946D, 0x946E,
0x946F, 0x9471, 0x9472, 0x9484, 0x9483, 0x9578, 0x9579,
/* index 15040 */
/* index 14852 */
0x957E, 0x9584, 0x9588, 0x958C, 0x958D, 0x958E, 0x959D,
0x959E, 0x959F, 0x95A1, 0x95A6, 0x95A9, 0x95AB, 0x95AC, 0x95B4,
0x95B6, 0x95BA, 0x95BD, 0x95BF, 0x95C6, 0x95C8, 0x95C9, 0x95CB,
@ -2244,7 +2178,7 @@ static const uint16_t gJapaneseMap[] = {
0x969D, 0x969F, 0x96A4, 0x96A5, 0x96A6, 0x96A9, 0x96AE, 0x96AF,
0x96B3, 0x96BA, 0x96CA, 0x96D2, 0x5DB2, 0x96D8, 0x96DA, 0x96DD,
0x96DE, 0x96DF, 0x96E9, 0x96EF, 0x96F1, 0x96FA, 0x9702,
/* index 15134 */
/* index 14946 */
0x9703, 0x9705, 0x9709, 0x971A, 0x971B, 0x971D, 0x9721,
0x9722, 0x9723, 0x9728, 0x9731, 0x9733, 0x9741, 0x9743, 0x974A,
0x974E, 0x974F, 0x9755, 0x9757, 0x9758, 0x975A, 0x975B, 0x9763,
@ -2257,7 +2191,7 @@ static const uint16_t gJapaneseMap[] = {
0x97DE, 0x97E0, 0x97DB, 0x97E1, 0x97E4, 0x97EF, 0x97F1, 0x97F4,
0x97F7, 0x97F8, 0x97FA, 0x9807, 0x980A, 0x9819, 0x980D, 0x980E,
0x9814, 0x9816, 0x981C, 0x981E, 0x9820, 0x9823, 0x9826,
/* index 15228 */
/* index 15040 */
0x982B, 0x982E, 0x982F, 0x9830, 0x9832, 0x9833, 0x9835,
0x9825, 0x983E, 0x9844, 0x9847, 0x984A, 0x9851, 0x9852, 0x9853,
0x9856, 0x9857, 0x9859, 0x985A, 0x9862, 0x9863, 0x9865, 0x9866,
@ -2270,7 +2204,7 @@ static const uint16_t gJapaneseMap[] = {
0x9940, 0x9941, 0x9946, 0x9947, 0x9948, 0x994D, 0x994E, 0x9954,
0x9958, 0x9959, 0x995B, 0x995C, 0x995E, 0x995F, 0x9960, 0x999B,
0x999D, 0x999F, 0x99A6, 0x99B0, 0x99B1, 0x99B2, 0x99B5,
/* index 15322 */
/* index 15134 */
0x99B9, 0x99BA, 0x99BD, 0x99BF, 0x99C3, 0x99C9, 0x99D3,
0x99D4, 0x99D9, 0x99DA, 0x99DC, 0x99DE, 0x99E7, 0x99EA, 0x99EB,
0x99EC, 0x99F0, 0x99F4, 0x99F5, 0x99F9, 0x99FD, 0x99FE, 0x9A02,
@ -2283,7 +2217,7 @@ static const uint16_t gJapaneseMap[] = {
0x9AD2, 0x9AD5, 0x9AD6, 0x9AD7, 0x9ADB, 0x9ADC, 0x9AE0, 0x9AE4,
0x9AE5, 0x9AE7, 0x9AE9, 0x9AEC, 0x9AF2, 0x9AF3, 0x9AF5, 0x9AF9,
0x9AFA, 0x9AFD, 0x9AFF, 0x9B00, 0x9B01, 0x9B02, 0x9B03,
/* index 15416 */
/* index 15228 */
0x9B04, 0x9B05, 0x9B08, 0x9B09, 0x9B0B, 0x9B0C, 0x9B0D,
0x9B0E, 0x9B10, 0x9B12, 0x9B16, 0x9B19, 0x9B1B, 0x9B1C, 0x9B20,
0x9B26, 0x9B2B, 0x9B2D, 0x9B33, 0x9B34, 0x9B35, 0x9B37, 0x9B39,
@ -2296,7 +2230,7 @@ static const uint16_t gJapaneseMap[] = {
0x9BB7, 0x9BB8, 0x9BBB, 0x9BBC, 0x9BBE, 0x9BBF, 0x9BC1, 0x9BC7,
0x9BC8, 0x9BCE, 0x9BD0, 0x9BD7, 0x9BD8, 0x9BDD, 0x9BDF, 0x9BE5,
0x9BE7, 0x9BEA, 0x9BEB, 0x9BEF, 0x9BF3, 0x9BF7, 0x9BF8,
/* index 15510 */
/* index 15322 */
0x9BF9, 0x9BFA, 0x9BFD, 0x9BFF, 0x9C00, 0x9C02, 0x9C0B,
0x9C0F, 0x9C11, 0x9C16, 0x9C18, 0x9C19, 0x9C1A, 0x9C1C, 0x9C1E,
0x9C22, 0x9C23, 0x9C26, 0x9C27, 0x9C28, 0x9C29, 0x9C2A, 0x9C31,
@ -2309,7 +2243,7 @@ static const uint16_t gJapaneseMap[] = {
0x9D33, 0x9D34, 0x9D3A, 0x9D3C, 0x9D45, 0x9D3D, 0x9D42, 0x9D43,
0x9D47, 0x9D4A, 0x9D53, 0x9D54, 0x9D5F, 0x9D63, 0x9D62, 0x9D65,
0x9D69, 0x9D6A, 0x9D6B, 0x9D70, 0x9D76, 0x9D77, 0x9D7B,
/* index 15604 */
/* index 15416 */
0x9D7C, 0x9D7E, 0x9D83, 0x9D84, 0x9D86, 0x9D8A, 0x9D8D,
0x9D8E, 0x9D92, 0x9D93, 0x9D95, 0x9D96, 0x9D97, 0x9D98, 0x9DA1,
0x9DAA, 0x9DAC, 0x9DAE, 0x9DB1, 0x9DB5, 0x9DB9, 0x9DBC, 0x9DBF,
@ -2322,7 +2256,7 @@ static const uint16_t gJapaneseMap[] = {
0x9EA4, 0x9EA8, 0x9EAC, 0x9EAE, 0x9EAF, 0x9EB0, 0x9EB3, 0x9EB4,
0x9EB5, 0x9EC6, 0x9EC8, 0x9ECB, 0x9ED5, 0x9EDF, 0x9EE4, 0x9EE7,
0x9EEC, 0x9EED, 0x9EEE, 0x9EF0, 0x9EF1, 0x9EF2, 0x9EF5,
/* index 15698 */
/* index 15510 */
0x9EF8, 0x9EFF, 0x9F02, 0x9F03, 0x9F09, 0x9F0F, 0x9F10,
0x9F11, 0x9F12, 0x9F14, 0x9F16, 0x9F17, 0x9F19, 0x9F1A, 0x9F1B,
0x9F1F, 0x9F22, 0x9F26, 0x9F2A, 0x9F2B, 0x9F2F, 0x9F31, 0x9F32,

8
ipc/glue/MessageChannel.cpp
View File

@ -57,6 +57,7 @@ MessageChannel::MessageChannel(MessageListener *aListener)
mPendingRPCReplies(0),
mCurrentRPCTransaction(0),
mDispatchingSyncMessage(false),
mDispatchingUrgentMessageCount(0),
mRemoteStackDepthGuess(false),
mSawInterruptOutMsg(false)
{
@ -416,6 +417,7 @@ MessageChannel::Send(Message* aMsg, Message* aReply)
IPC_ASSERT(aMsg->is_sync(), "can only Send() sync messages here");
IPC_ASSERT(!DispatchingSyncMessage(), "violation of sync handler invariant");
IPC_ASSERT(!DispatchingUrgentMessage(), "sync messages forbidden while handling urgent message");
IPC_ASSERT(!AwaitingSyncReply(), "nested sync messages are not supported");
AutoEnterPendingReply replies(mPendingSyncReplies);
@ -937,7 +939,11 @@ MessageChannel::DispatchUrgentMessage(const Message& aMsg)
Message *reply = nullptr;
if (!MaybeHandleError(mListener->OnCallReceived(aMsg, reply), "DispatchUrgentMessage")) {
mDispatchingUrgentMessageCount++;
Result rv = mListener->OnCallReceived(aMsg, reply);
mDispatchingUrgentMessageCount--;
if (!MaybeHandleError(rv, "DispatchUrgentMessage")) {
delete reply;
reply = new Message();
reply->set_urgent();

8
ipc/glue/MessageChannel.h
View File

@ -384,6 +384,11 @@ class MessageChannel : HasResultCodes
return mDispatchingSyncMessage;
}
// Returns true if we're dispatching an urgent message's callback.
bool DispatchingUrgentMessage() const {
return mDispatchingUrgentMessageCount > 0;
}
bool Connected() const;
private:
@ -576,6 +581,9 @@ class MessageChannel : HasResultCodes
// Set while we are dispatching a synchronous message.
bool mDispatchingSyncMessage;
// Count of the recursion depth of dispatching urgent messages.
size_t mDispatchingUrgentMessageCount;
// Queue of all incoming messages, except for replies to sync and urgent
// messages, which are delivered directly to mRecvd, and any pending urgent
// incall, which is stored in mPendingUrgentRequest.

55
js/src/builtin/TestingFunctions.cpp
View File

@ -25,6 +25,7 @@
#include "vm/ProxyObject.h"
#include "jscntxtinlines.h"
#include "jsobjinlines.h"
using namespace js;
using namespace JS;
@ -988,22 +989,45 @@ js::testingFunc_inParallelSection(JSContext *cx, unsigned argc, jsval *vp)
return true;
}
static const char *ObjectMetadataPropertyName = "__objectMetadataFunction__";
static bool
ShellObjectMetadataCallback(JSContext *cx, JSObject **pmetadata)
{
RootedValue fun(cx);
if (!JS_GetProperty(cx, cx->global(), ObjectMetadataPropertyName, &fun))
RootedObject obj(cx, NewBuiltinClassInstance(cx, &JSObject::class_));
if (!obj)
return false;
RootedValue rval(cx);
if (!Invoke(cx, UndefinedValue(), fun, 0, nullptr, &rval))
RootedObject stack(cx, NewDenseEmptyArray(cx));
if (!stack)
return false;
if (rval.isObject())
*pmetadata = &rval.toObject();
static int createdIndex = 0;
createdIndex++;
if (!JS_DefineProperty(cx, obj, "index", Int32Value(createdIndex),
JS_PropertyStub, JS_StrictPropertyStub, 0))
{
return false;
}
if (!JS_DefineProperty(cx, obj, "stack", ObjectValue(*stack),
JS_PropertyStub, JS_StrictPropertyStub, 0))
{
return false;
}
int stackIndex = 0;
for (NonBuiltinScriptFrameIter iter(cx); !iter.done(); ++iter) {
if (iter.isFunctionFrame()) {
if (!JS_DefinePropertyById(cx, stack, INT_TO_JSID(stackIndex), ObjectValue(*iter.callee()),
JS_PropertyStub, JS_StrictPropertyStub, 0))
{
return false;
}
stackIndex++;
}
}
*pmetadata = obj;
return true;
}
@ -1012,19 +1036,10 @@ SetObjectMetadataCallback(JSContext *cx, unsigned argc, jsval *vp)
{
CallArgs args = CallArgsFromVp(argc, vp);
bool enabled = argc ? ToBoolean(args[0]) : false;
SetObjectMetadataCallback(cx, enabled ? ShellObjectMetadataCallback : nullptr);
args.rval().setUndefined();
if (argc == 0 || !args[0].isObject() || !args[0].toObject().is<JSFunction>()) {
if (!JS_DeleteProperty(cx, cx->global(), ObjectMetadataPropertyName))
return false;
js::SetObjectMetadataCallback(cx, nullptr);
return true;
}
if (!JS_DefineProperty(cx, cx->global(), ObjectMetadataPropertyName, args[0], nullptr, nullptr, 0))
return false;
js::SetObjectMetadataCallback(cx, ShellObjectMetadataCallback);
return true;
}

8
js/src/frontend/Parser.cpp
View File

@ -847,7 +847,7 @@ Parser<FullParseHandler>::standaloneFunctionBody(HandleFunction fun, const AutoN
generatorKind);
if (!funbox)
return null();
funbox->length = fun->nargs - fun->hasRest();
funbox->length = fun->nargs() - fun->hasRest();
handler.setFunctionBox(fn, funbox);
ParseContext<FullParseHandler> funpc(this, pc, fn, funbox, newDirectives,
@ -2212,7 +2212,7 @@ Parser<FullParseHandler>::standaloneLazyFunction(HandleFunction fun, unsigned st
generatorKind);
if (!funbox)
return null();
funbox->length = fun->nargs - fun->hasRest();
funbox->length = fun->nargs() - fun->hasRest();
Directives newDirectives = directives;
ParseContext<FullParseHandler> funpc(this, /* parent = */ nullptr, pn, funbox,
@ -2265,11 +2265,11 @@ Parser<ParseHandler>::functionArgsAndBodyGeneric(Node pn, HandleFunction fun, Fu
if (hasRest)
fun->setHasRest();
if (type == Getter && fun->nargs > 0) {
if (type == Getter && fun->nargs() > 0) {
report(ParseError, false, null(), JSMSG_ACCESSOR_WRONG_ARGS, "getter", "no", "s");
return false;
}
if (type == Setter && fun->nargs != 1) {
if (type == Setter && fun->nargs() != 1) {
report(ParseError, false, null(), JSMSG_ACCESSOR_WRONG_ARGS, "setter", "one", "");
return false;
}

2
js/src/frontend/SharedContext.h
View File

@ -289,7 +289,7 @@ class FunctionBox : public ObjectBox, public SharedContext
funCxFlags.definitelyNeedsArgsObj = true; }
bool hasDefaults() const {
return length != function()->nargs - function()->hasRest();
return length != function()->nargs() - function()->hasRest();
}
// Return whether this function has either specified "use asm" or is

48
js/src/jit-test/tests/basic/metadata-hook.js
View File

@ -3,46 +3,32 @@ x = [1,2,3];
setObjectMetadata(x, {y:0});
assertEq(getObjectMetadata(x).y, 0);
incallback = false;
count = 0;
function callback(obj) {
if (incallback)
return null;
incallback = true;
var res =
{
count: ++count,
location: Error().stack,
message: Error().message // no .message => Error.prototype.message => ""
};
incallback = false;
return res;
}
callback({});
setObjectMetadataCallback(callback);
setObjectMetadataCallback(true);
function Foo() {
this.x = 0;
this.y = 1;
}
function f() {
w = new Foo();
x = [1,2,3];
y = [2,3,5];
z = {a:0,b:1};
function hello() {
function there() {
w = new Foo();
x = [1,2,3];
y = [2,3,5];
z = {a:0,b:1};
}
callee = there;
callee();
}
f();
hello();
var wc = getObjectMetadata(w).count;
var xc = getObjectMetadata(x).count;
var yc = getObjectMetadata(y).count;
var zc = getObjectMetadata(z).count;
var wc = getObjectMetadata(w).index;
var xc = getObjectMetadata(x).index;
var yc = getObjectMetadata(y).index;
var zc = getObjectMetadata(z).index;
assertEq(xc > wc, true);
assertEq(yc > xc, true);
assertEq(zc > yc, true);
assertEq(/\.js/.test(getObjectMetadata(x).location), true);
assertEq(getObjectMetadata(x).message, "");
assertEq(getObjectMetadata(x).stack[0], callee);
assertEq(getObjectMetadata(x).stack[1], hello);

4
js/src/jit/AsmJS.cpp
View File

@ -5967,14 +5967,14 @@ TryEnablingIon(JSContext *cx, AsmJSModule &module, HandleFunction fun, uint32_t
return true;
// Currently we can't rectify arguments. Therefore disabling if argc is too low.
if (fun->nargs > argc)
if (fun->nargs() > size_t(argc))
return true;
// Normally the types should corresond, since we just ran with those types,
// but there are reports this is asserting. Therefore doing it as a check, instead of DEBUG only.
if (!types::TypeScript::ThisTypes(script)->hasType(types::Type::UndefinedType()))
return true;
for(uint32_t i = 0; i < fun->nargs; i++) {
for(uint32_t i = 0; i < fun->nargs(); i++) {
types::StackTypeSet *typeset = types::TypeScript::ArgTypes(script, i);
types::Type type = types::Type::DoubleType();
if (!argv[i].isDouble())

2
js/src/jit/AsmJSLink.cpp
View File

@ -682,7 +682,7 @@ JSFunction *
js::NewAsmJSModuleFunction(ExclusiveContext *cx, JSFunction *origFun, HandleObject moduleObj)
{
RootedPropertyName name(cx, origFun->name());
JSFunction *moduleFun = NewFunction(cx, NullPtr(), LinkAsmJS, origFun->nargs,
JSFunction *moduleFun = NewFunction(cx, NullPtr(), LinkAsmJS, origFun->nargs(),
JSFunction::NATIVE_FUN, NullPtr(), name,
JSFunction::ExtendedFinalizeKind, TenuredObject);
if (!moduleFun)

10
js/src/jit/BaselineBailouts.cpp
View File

@ -624,7 +624,7 @@ InitFromBailout(JSContext *cx, HandleScript caller, jsbytecode *callerPC,
JS_ASSERT(iter.slots() >= CountArgSlots(script, fun));
IonSpew(IonSpew_BaselineBailouts, " frame slots %u, nargs %u, nfixed %u",
iter.slots(), fun->nargs, script->nfixed());
iter.slots(), fun->nargs(), script->nfixed());
if (!callerPC) {
// This is the first frame. Store the formals in a Vector until we
@ -633,11 +633,11 @@ InitFromBailout(JSContext *cx, HandleScript caller, jsbytecode *callerPC,
// locals may still reference the original argument slot
// (MParameter/LArgument) and expect the original Value.
JS_ASSERT(startFrameFormals.empty());
if (!startFrameFormals.resize(fun->nargs))
if (!startFrameFormals.resize(fun->nargs()))
return false;
}
for (uint32_t i = 0; i < fun->nargs; i++) {
for (uint32_t i = 0; i < fun->nargs(); i++) {
Value arg = iter.read();
IonSpew(IonSpew_BaselineBailouts, " arg %d = %016llx",
(int) i, *((uint64_t *) &arg));
@ -1108,7 +1108,7 @@ InitFromBailout(JSContext *cx, HandleScript caller, jsbytecode *callerPC,
// If actualArgc >= fun->nargs, then we are done. Otherwise, we need to push on
// a reconstructed rectifier frame.
if (actualArgc >= calleeFun->nargs)
if (actualArgc >= calleeFun->nargs())
return true;
// Push a reconstructed rectifier frame.
@ -1147,7 +1147,7 @@ InitFromBailout(JSContext *cx, HandleScript caller, jsbytecode *callerPC,
#endif
// Push undefined for missing arguments.
for (unsigned i = 0; i < (calleeFun->nargs - actualArgc); i++) {
for (unsigned i = 0; i < (calleeFun->nargs() - actualArgc); i++) {
if (!builder.writeValue(UndefinedValue(), "FillerVal"))
return false;
}

2
js/src/jit/BaselineCompiler.cpp
View File

@ -668,7 +668,7 @@ BaselineCompiler::emitArgumentTypeChecks()
if (!emitNonOpIC(compiler.getStub(&stubSpace_)))
return false;
for (size_t i = 0; i < function()->nargs; i++) {
for (size_t i = 0; i < function()->nargs(); i++) {
frame.pushArg(i);
frame.popRegsAndSync(1);

2
js/src/jit/BaselineFrame.h
View File

@ -182,7 +182,7 @@ class BaselineFrame
offsetOfNumActualArgs());
}
unsigned numFormalArgs() const {
return script()->function()->nargs;
return script()->function()->nargs();
}
Value &thisValue() const {
return *(Value *)(reinterpret_cast<const uint8_t *>(this) +

2
js/src/jit/BaselineFrameInfo.h
View File

@ -182,7 +182,7 @@ class FrameInfo
return script->nfixed();
}
uint32_t nargs() const {
return script->function()->nargs;
return script->function()->nargs();
}
private:

12
js/src/jit/BaselineIC.cpp
View File

@ -4125,7 +4125,7 @@ ICGetElemNativeCompiler::emitCallScripted(MacroAssembler &masm, Register objReg)
// Handle arguments underflow.
Label noUnderflow;
masm.load16ZeroExtend(Address(callee, offsetof(JSFunction, nargs)), scratch);
masm.load16ZeroExtend(Address(callee, JSFunction::offsetOfNargs()), scratch);
masm.branch32(Assembler::Equal, scratch, Imm32(0), &noUnderflow);
{
// Call the arguments rectifier.
@ -6682,7 +6682,7 @@ ICGetProp_CallScripted::Compiler::generateStubCode(MacroAssembler &masm)
// Handle arguments underflow.
Label noUnderflow;
masm.load16ZeroExtend(Address(callee, offsetof(JSFunction, nargs)), scratch);
masm.load16ZeroExtend(Address(callee, JSFunction::offsetOfNargs()), scratch);
masm.branch32(Assembler::Equal, scratch, Imm32(0), &noUnderflow);
{
// Call the arguments rectifier.
@ -7591,7 +7591,7 @@ ICSetProp_CallScripted::Compiler::generateStubCode(MacroAssembler &masm)
// Handle arguments underflow.
Label noUnderflow;
masm.load16ZeroExtend(Address(callee, offsetof(JSFunction, nargs)), scratch);
masm.load16ZeroExtend(Address(callee, JSFunction::offsetOfNargs()), scratch);
masm.branch32(Assembler::BelowOrEqual, scratch, Imm32(1), &noUnderflow);
{
// Call the arguments rectifier.
@ -8538,7 +8538,7 @@ ICCallScriptedCompiler::generateStubCode(MacroAssembler &masm)
// Handle arguments underflow.
Label noUnderflow;
masm.load16ZeroExtend(Address(callee, offsetof(JSFunction, nargs)), callee);
masm.load16ZeroExtend(Address(callee, JSFunction::offsetOfNargs()), callee);
masm.branch32(Assembler::AboveOrEqual, argcReg, callee, &noUnderflow);
{
// Call the arguments rectifier.
@ -8794,7 +8794,7 @@ ICCall_ScriptedApplyArray::Compiler::generateStubCode(MacroAssembler &masm)
masm.Push(scratch);
// Load nargs into scratch for underflow check, and then load jitcode pointer into target.
masm.load16ZeroExtend(Address(target, offsetof(JSFunction, nargs)), scratch);
masm.load16ZeroExtend(Address(target, JSFunction::offsetOfNargs()), scratch);
masm.loadPtr(Address(target, JSFunction::offsetOfNativeOrScript()), target);
masm.loadBaselineOrIonRaw(target, target, SequentialExecution, nullptr);
@ -8905,7 +8905,7 @@ ICCall_ScriptedApplyArguments::Compiler::generateStubCode(MacroAssembler &masm)
masm.Push(scratch);
// Load nargs into scratch for underflow check, and then load jitcode pointer into target.
masm.load16ZeroExtend(Address(target, offsetof(JSFunction, nargs)), scratch);
masm.load16ZeroExtend(Address(target, JSFunction::offsetOfNargs()), scratch);
masm.loadPtr(Address(target, JSFunction::offsetOfNativeOrScript()), target);
masm.loadBaselineOrIonRaw(target, target, SequentialExecution, nullptr);

14
js/src/jit/CodeGenerator.cpp
View File

@ -826,11 +826,11 @@ CodeGenerator::emitLambdaInit(const Register &output, const Register &scopeChain
} s;
uint32_t word;
} u;
u.s.nargs = info.fun->nargs;
u.s.nargs = info.fun->nargs();
u.s.flags = info.flags & ~JSFunction::EXTENDED;
JS_STATIC_ASSERT(offsetof(JSFunction, flags) == offsetof(JSFunction, nargs) + 2);
masm.store32(Imm32(u.word), Address(output, offsetof(JSFunction, nargs)));
JS_ASSERT(JSFunction::offsetOfFlags() == JSFunction::offsetOfNargs() + 2);
masm.store32(Imm32(u.word), Address(output, JSFunction::offsetOfNargs()));
masm.storePtr(ImmGCPtr(info.scriptOrLazyScript),
Address(output, JSFunction::offsetOfNativeOrScript()));
masm.storePtr(scopeChain, Address(output, JSFunction::offsetOfEnvironment()));
@ -1953,7 +1953,7 @@ CodeGenerator::visitCallGeneric(LCallGeneric *call)
masm.Push(Imm32(descriptor));
// Check whether the provided arguments satisfy target argc.
masm.load16ZeroExtend(Address(calleereg, offsetof(JSFunction, nargs)), nargsreg);
masm.load16ZeroExtend(Address(calleereg, JSFunction::offsetOfNargs()), nargsreg);
masm.cmp32(nargsreg, Imm32(call->numStackArgs()));
masm.j(Assembler::Above, &thunk);
@ -2045,7 +2045,7 @@ CodeGenerator::visitCallKnown(LCallKnown *call)
// Native single targets are handled by LCallNative.
JS_ASSERT(!target->isNative());
// Missing arguments must have been explicitly appended by the IonBuilder.
JS_ASSERT(target->nargs <= call->numStackArgs());
JS_ASSERT(target->nargs() <= call->numStackArgs());
JS_ASSERT_IF(call->mir()->isConstructing(), target->isInterpretedConstructor());
@ -2285,11 +2285,11 @@ CodeGenerator::visitApplyArgsGeneric(LApplyArgsGeneric *apply)
// Check whether the provided arguments satisfy target argc.
if (!apply->hasSingleTarget()) {
masm.load16ZeroExtend(Address(calleereg, offsetof(JSFunction, nargs)), copyreg);
masm.load16ZeroExtend(Address(calleereg, JSFunction::offsetOfNargs()), copyreg);
masm.cmp32(argcreg, copyreg);
masm.j(Assembler::Below, &underflow);
} else {
masm.cmp32(argcreg, Imm32(apply->getSingleTarget()->nargs));
masm.cmp32(argcreg, Imm32(apply->getSingleTarget()->nargs()));
masm.j(Assembler::Below, &underflow);
}

4
js/src/jit/CompileInfo.h
View File

@ -37,7 +37,7 @@ CountArgSlots(JSScript *script, JSFunction *fun)
// Slot x + n: Argument n.
// Note: when updating this, please also update the assert in SnapshotWriter::startFrame
return StartArgSlot(script) + (fun ? fun->nargs + 1 : 0);
return StartArgSlot(script) + (fun ? fun->nargs() + 1 : 0);
}
// Contains information about the compilation source for IR being generated.
@ -60,7 +60,7 @@ class CompileInfo
nimplicit_ = StartArgSlot(script) /* scope chain and argument obj */
+ (fun ? 1 : 0); /* this */
nargs_ = fun ? fun->nargs : 0;
nargs_ = fun ? fun->nargs() : 0;
nlocals_ = script->nfixed();
nstack_ = script->nslots() - script->nfixed();
nslots_ = nimplicit_ + nargs_ + nlocals_ + nstack_;

8
js/src/jit/Ion.cpp
View File

@ -2018,7 +2018,7 @@ jit::CanEnter(JSContext *cx, RunState &state)
return Method_CantCompile;
}
if (TooManyArguments(invoke.args().callee().as<JSFunction>().nargs)) {
if (TooManyArguments(invoke.args().callee().as<JSFunction>().nargs())) {
IonSpew(IonSpew_Abort, "too many args");
ForbidCompilation(cx, script);
return Method_CantCompile;
@ -2165,7 +2165,7 @@ jit::CanEnterUsingFastInvoke(JSContext *cx, HandleScript script, uint32_t numAct
// Don't handle arguments underflow, to make this work we would have to pad
// missing arguments with |undefined|.
if (numActualArgs < script->function()->nargs)
if (numActualArgs < script->function()->nargs())
return Method_Skipped;
if (!cx->compartment()->ensureJitCompartmentExists(cx))
@ -2226,7 +2226,7 @@ jit::SetEnterJitData(JSContext *cx, EnterJitData &data, RunState &state, AutoVal
if (state.isInvoke()) {
CallArgs &args = state.asInvoke()->args();
unsigned numFormals = state.script()->function()->nargs;
unsigned numFormals = state.script()->function()->nargs();
data.constructing = state.asInvoke()->constructing();
data.numActualArgs = args.length();
data.maxArgc = Max(args.length(), numFormals) + 1;
@ -2309,7 +2309,7 @@ jit::FastInvoke(JSContext *cx, HandleFunction fun, CallArgs &args)
void *calleeToken = CalleeToToken(fun);
RootedValue result(cx, Int32Value(args.length()));
JS_ASSERT(args.length() >= fun->nargs);
JS_ASSERT(args.length() >= fun->nargs());
JSAutoResolveFlags rf(cx, RESOLVE_INFER);
enter(jitcode, args.length() + 1, args.array() - 1, nullptr, calleeToken,

8
js/src/jit/IonBuilder.cpp
View File

@ -361,7 +361,7 @@ IonBuilder::canInlineTarget(JSFunction *target, CallInfo &callInfo)
if (!inlineScript->hasBaselineScript())
return DontInline(inlineScript, "No baseline jitcode");
if (TooManyArguments(target->nargs))
if (TooManyArguments(target->nargs()))
return DontInline(inlineScript, "Too many args");
if (TooManyArguments(callInfo.argc()))
@ -5136,12 +5136,12 @@ IonBuilder::testNeedsArgumentCheck(JSFunction *target, CallInfo &callInfo)
if (!ArgumentTypesMatch(callInfo.thisArg(), types::TypeScript::ThisTypes(targetScript)))
return true;
uint32_t expected_args = Min<uint32_t>(callInfo.argc(), target->nargs);
uint32_t expected_args = Min<uint32_t>(callInfo.argc(), target->nargs());
for (size_t i = 0; i < expected_args; i++) {
if (!ArgumentTypesMatch(callInfo.getArg(i), types::TypeScript::ArgTypes(targetScript, i)))
return true;
}
for (size_t i = callInfo.argc(); i < target->nargs; i++) {
for (size_t i = callInfo.argc(); i < target->nargs(); i++) {
if (!types::TypeScript::ArgTypes(targetScript, i)->mightBeType(JSVAL_TYPE_UNDEFINED))
return true;
}
@ -5162,7 +5162,7 @@ IonBuilder::makeCallHelper(JSFunction *target, CallInfo &callInfo, bool cloneAtC
// Collect number of missing arguments provided that the target is
// scripted. Native functions are passed an explicit 'argc' parameter.
if (target && !target->isNative())
targetArgs = Max<uint32_t>(target->nargs, callInfo.argc());
targetArgs = Max<uint32_t>(target->nargs(), callInfo.argc());
MCall *call =
MCall::New(alloc(), target, targetArgs + 1, callInfo.argc(), callInfo.constructing());

2
js/src/jit/IonFrameIterator.h
View File

@ -398,7 +398,7 @@ class InlineFrameIteratorMaybeGC
count = nactual - start;
unsigned end = start + count;
unsigned nformal = callee()->nargs;
unsigned nformal = callee()->nargs();
JS_ASSERT(start <= end && end <= nactual);

8
js/src/jit/IonFrames.cpp
View File

@ -1659,15 +1659,15 @@ InlineFrameIteratorMaybeGC<allowGC>::dump() const
fprintf(stderr, " scope chain: ");
else if (i == 1)
fprintf(stderr, " this: ");
else if (i - 2 < callee()->nargs)
else if (i - 2 < callee()->nargs())
fprintf(stderr, " formal (arg %d): ", i - 2);
else {
if (i - 2 == callee()->nargs && numActualArgs() > callee()->nargs) {
DumpOp d(callee()->nargs);
if (i - 2 == callee()->nargs() && numActualArgs() > callee()->nargs()) {
DumpOp d(callee()->nargs());
forEachCanonicalActualArg(GetIonContext()->cx, d, d.i_, numActualArgs() - d.i_);
}
fprintf(stderr, " slot %d: ", i - 2 - callee()->nargs);
fprintf(stderr, " slot %d: ", int(i - 2 - callee()->nargs()));
}
} else
fprintf(stderr, " slot %u: ", i);

6
js/src/jit/IonMacroAssembler.cpp
View File

@ -1780,8 +1780,8 @@ MacroAssembler::branchIfNotInterpretedConstructor(Register fun, Register scratch
{
// 16-bit loads are slow and unaligned 32-bit loads may be too so
// perform an aligned 32-bit load and adjust the bitmask accordingly.
JS_STATIC_ASSERT(offsetof(JSFunction, nargs) % sizeof(uint32_t) == 0);
JS_STATIC_ASSERT(offsetof(JSFunction, flags) == offsetof(JSFunction, nargs) + 2);
JS_ASSERT(JSFunction::offsetOfNargs() % sizeof(uint32_t) == 0);
JS_ASSERT(JSFunction::offsetOfFlags() == JSFunction::offsetOfNargs() + 2);
JS_STATIC_ASSERT(IS_LITTLE_ENDIAN);
// Emit code for the following test:
@ -1792,7 +1792,7 @@ MacroAssembler::branchIfNotInterpretedConstructor(Register fun, Register scratch
// }
// First, ensure it's a scripted function.
load32(Address(fun, offsetof(JSFunction, nargs)), scratch);
load32(Address(fun, JSFunction::offsetOfNargs()), scratch);
branchTest32(Assembler::Zero, scratch, Imm32(JSFunction::INTERPRETED << 16), label);
// Common case: if both IS_FUN_PROTO and SELF_HOSTED are not set,

12
js/src/jit/IonMacroAssembler.h
View File

@ -490,20 +490,20 @@ class MacroAssembler : public MacroAssemblerSpecific
void branchIfFunctionHasNoScript(Register fun, Label *label) {
// 16-bit loads are slow and unaligned 32-bit loads may be too so
// perform an aligned 32-bit load and adjust the bitmask accordingly.
JS_STATIC_ASSERT(offsetof(JSFunction, nargs) % sizeof(uint32_t) == 0);
JS_STATIC_ASSERT(offsetof(JSFunction, flags) == offsetof(JSFunction, nargs) + 2);
JS_ASSERT(JSFunction::offsetOfNargs() % sizeof(uint32_t) == 0);
JS_ASSERT(JSFunction::offsetOfFlags() == JSFunction::offsetOfNargs() + 2);
JS_STATIC_ASSERT(IS_LITTLE_ENDIAN);
Address address(fun, offsetof(JSFunction, nargs));
Address address(fun, JSFunction::offsetOfNargs());
uint32_t bit = JSFunction::INTERPRETED << 16;
branchTest32(Assembler::Zero, address, Imm32(bit), label);
}
void branchIfInterpreted(Register fun, Label *label) {
// 16-bit loads are slow and unaligned 32-bit loads may be too so
// perform an aligned 32-bit load and adjust the bitmask accordingly.
JS_STATIC_ASSERT(offsetof(JSFunction, nargs) % sizeof(uint32_t) == 0);
JS_STATIC_ASSERT(offsetof(JSFunction, flags) == offsetof(JSFunction, nargs) + 2);
JS_ASSERT(JSFunction::offsetOfNargs() % sizeof(uint32_t) == 0);
JS_ASSERT(JSFunction::offsetOfFlags() == JSFunction::offsetOfNargs() + 2);
JS_STATIC_ASSERT(IS_LITTLE_ENDIAN);
Address address(fun, offsetof(JSFunction, nargs));
Address address(fun, JSFunction::offsetOfNargs());
uint32_t bit = JSFunction::INTERPRETED << 16;
branchTest32(Assembler::NonZero, address, Imm32(bit), label);
}

2
js/src/jit/MIR.h
View File

@ -4939,7 +4939,7 @@ struct LambdaFunctionInfo
bool useNewTypeForClone;
LambdaFunctionInfo(JSFunction *fun)
: fun(fun), flags(fun->flags),
: fun(fun), flags(fun->flags()),
scriptOrLazyScript(fun->hasScript()
? (gc::Cell *) fun->nonLazyScript()
: (gc::Cell *) fun->lazyScript()),

2
js/src/jit/arm/Trampoline-arm.cpp
View File

@ -423,7 +423,7 @@ JitRuntime::generateArgumentsRectifier(JSContext *cx, ExecutionMode mode, void *
// Load the number of |undefined|s to push into r6.
masm.ma_ldr(DTRAddr(sp, DtrOffImm(IonRectifierFrameLayout::offsetOfCalleeToken())), r1);
masm.ma_ldrh(EDtrAddr(r1, EDtrOffImm(offsetof(JSFunction, nargs))), r6);
masm.ma_ldrh(EDtrAddr(r1, EDtrOffImm(JSFunction::offsetOfNargs())), r6);
masm.ma_sub(r6, r8, r2);

2
js/src/jit/x64/Trampoline-x64.cpp
View File

@ -363,7 +363,7 @@ JitRuntime::generateArgumentsRectifier(JSContext *cx, ExecutionMode mode, void *
// Load the number of |undefined|s to push into %rcx.
masm.loadPtr(Address(rsp, IonRectifierFrameLayout::offsetOfCalleeToken()), rax);
masm.movzwl(Operand(rax, offsetof(JSFunction, nargs)), rcx);
masm.movzwl(Operand(rax, JSFunction::offsetOfNargs()), rcx);
masm.subq(r8, rcx);
// Copy the number of actual arguments

2
js/src/jit/x86/Trampoline-x86.cpp
View File

@ -353,7 +353,7 @@ JitRuntime::generateArgumentsRectifier(JSContext *cx, ExecutionMode mode, void *
// Load the number of |undefined|s to push into %ecx.
masm.loadPtr(Address(esp, IonRectifierFrameLayout::offsetOfCalleeToken()), eax);
masm.movzwl(Operand(eax, offsetof(JSFunction, nargs)), ecx);
masm.movzwl(Operand(eax, JSFunction::offsetOfNargs()), ecx);
masm.subl(esi, ecx);
// Copy the number of actual arguments.

2
js/src/jsanalyze.h
View File

@ -225,7 +225,7 @@ static inline uint32_t ArgSlot(uint32_t arg) {
return 1 + arg;
}
static inline uint32_t LocalSlot(JSScript *script, uint32_t local) {
return 1 + (script->function() ? script->function()->nargs : 0) + local;
return 1 + (script->function() ? script->function()->nargs() : 0) + local;
}
static inline uint32_t TotalSlots(JSScript *script) {
return LocalSlot(script, 0) + script->nfixed();

4
js/src/jsapi.cpp
View File

@ -4014,7 +4014,7 @@ JS_GetFunctionDisplayId(JSFunction *fun)
JS_PUBLIC_API(uint16_t)
JS_GetFunctionArity(JSFunction *fun)
{
return fun->nargs;
return fun->nargs();
}
JS_PUBLIC_API(bool)
@ -4249,7 +4249,7 @@ struct AutoLastFrameCheck
# define fast_getc getc
#endif
typedef Vector<char, 8, TempAllocPolicy> FileContents;
typedef js::Vector<char, 8, TempAllocPolicy> FileContents;
static bool
ReadCompleteFile(JSContext *cx, FILE *fp, FileContents &buffer)

44
js/src/jsfun.cpp
View File

@ -302,7 +302,7 @@ js::fun_resolve(JSContext *cx, HandleObject obj, HandleId id, unsigned flags,
if (fun->isInterpretedLazy() && !fun->getOrCreateScript(cx))
return false;
uint16_t length = fun->hasScript() ? fun->nonLazyScript()->funLength() :
fun->nargs - fun->hasRest();
fun->nargs() - fun->hasRest();
v.setInt32(length);
} else {
v.setString(fun->atom() == nullptr ? cx->runtime()->emptyString : fun->atom());
@ -387,7 +387,7 @@ js::XDRInterpretedFunction(XDRState<mode> *xdr, HandleObject enclosingScope, Han
if (!script)
return false;
atom = fun->atom();
flagsword = (fun->nargs << 16) | fun->flags;
flagsword = (fun->nargs() << 16) | fun->flags();
if (!xdr->codeUint32(&firstword))
return false;
@ -419,14 +419,14 @@ js::XDRInterpretedFunction(XDRState<mode> *xdr, HandleObject enclosingScope, Han
return false;
if (mode == XDR_DECODE) {
fun->nargs = flagsword >> 16;
fun->flags = uint16_t(flagsword);
fun->setArgCount(flagsword >> 16);
fun->setFlags(uint16_t(flagsword));
fun->initAtom(atom);
fun->initScript(script);
script->setFunction(fun);
if (!JSFunction::setTypeForScriptedFunction(cx, fun))
return false;
JS_ASSERT(fun->nargs == fun->nonLazyScript()->bindings.numArgs());
JS_ASSERT(fun->nargs() == fun->nonLazyScript()->bindings.numArgs());
RootedScript script(cx, fun->nonLazyScript());
CallNewScriptHook(cx, script, fun);
objp.set(fun);
@ -463,8 +463,8 @@ js::CloneFunctionAndScript(JSContext *cx, HandleObject enclosingScope, HandleFun
if (!clonedScript)
return nullptr;
clone->nargs = srcFun->nargs;
clone->flags = srcFun->flags;
clone->setArgCount(srcFun->nargs());
clone->setFlags(srcFun->flags());
clone->initAtom(srcFun->displayAtom());
clone->initScript(clonedScript);
clonedScript->setFunction(clone);
@ -717,9 +717,9 @@ js::FunctionToString(JSContext *cx, HandleFunction fun, bool bodyOnly, bool lamb
ScopedJSDeletePtr<BindingVector> freeNames(localNames);
if (!FillBindingVector(script, localNames))
return nullptr;
for (unsigned i = 0; i < fun->nargs; i++) {
for (unsigned i = 0; i < fun->nargs(); i++) {
if ((i && !out.append(", ")) ||
(i == unsigned(fun->nargs - 1) && fun->hasRest() && !out.append("...")) ||
(i == unsigned(fun->nargs() - 1) && fun->hasRest() && !out.append("...")) ||
!out.append((*localNames)[i].name())) {
return nullptr;
}
@ -1124,8 +1124,8 @@ JSFunction::createScriptForLazilyInterpretedFunction(JSContext *cx, HandleFuncti
// THING_ROOT_LAZY_SCRIPT).
AutoSuppressGC suppressGC(cx);
fun->flags &= ~INTERPRETED_LAZY;
fun->flags |= INTERPRETED;
fun->flags_ &= ~INTERPRETED_LAZY;
fun->flags_ |= INTERPRETED;
RootedScript script(cx, lazy->maybeScript());
@ -1333,7 +1333,7 @@ js_fun_bind(JSContext *cx, HandleObject target, HandleValue thisArg,
/* Steps 15-16. */
unsigned length = 0;
if (target->is<JSFunction>()) {
unsigned nargs = target->as<JSFunction>().nargs;
unsigned nargs = target->as<JSFunction>().nargs();
if (nargs > argslen)
length = nargs - argslen;
}
@ -1662,9 +1662,12 @@ js::NewFunctionWithProto(ExclusiveContext *cx, HandleObject funobjArg, Native na
}
RootedFunction fun(cx, &funobj->as<JSFunction>());
if (allocKind == JSFunction::ExtendedFinalizeKind)
flags = JSFunction::Flags(flags | JSFunction::EXTENDED);
/* Initialize all function members. */
fun->nargs = uint16_t(nargs);
fun->flags = flags;
fun->setArgCount(uint16_t(nargs));
fun->setFlags(flags);
if (fun->isInterpreted()) {
JS_ASSERT(!native);
fun->mutableScript().init(nullptr);
@ -1674,10 +1677,8 @@ js::NewFunctionWithProto(ExclusiveContext *cx, HandleObject funobjArg, Native na
JS_ASSERT(native);
fun->initNative(native, nullptr);
}
if (allocKind == JSFunction::ExtendedFinalizeKind) {
fun->flags |= JSFunction::EXTENDED;
if (allocKind == JSFunction::ExtendedFinalizeKind)
fun->initializeExtended();
}
fun->initAtom(atom);
return fun;
@ -1710,8 +1711,12 @@ js::CloneFunctionObject(JSContext *cx, HandleFunction fun, HandleObject parent,
return nullptr;
RootedFunction clone(cx, &cloneobj->as<JSFunction>());
clone->nargs = fun->nargs;
clone->flags = fun->flags & ~JSFunction::EXTENDED;
uint16_t flags = fun->flags() & ~JSFunction::EXTENDED;
if (allocKind == JSFunction::ExtendedFinalizeKind)
flags |= JSFunction::EXTENDED;
clone->setArgCount(fun->nargs());
clone->setFlags(flags);
if (fun->hasScript()) {
clone->initScript(fun->nonLazyScript());
clone->initEnvironment(parent);
@ -1725,7 +1730,6 @@ js::CloneFunctionObject(JSContext *cx, HandleFunction fun, HandleObject parent,
clone->initAtom(fun->displayAtom());
if (allocKind == JSFunction::ExtendedFinalizeKind) {
clone->flags |= JSFunction::EXTENDED;
if (fun->isExtended() && fun->compartment() == cx->compartment()) {
for (unsigned i = 0; i < FunctionExtended::NUM_EXTENDED_SLOTS; i++)
clone->initExtendedSlot(i, fun->getExtendedSlot(i));

82
js/src/jsfun.h
View File

@ -63,9 +63,10 @@ class JSFunction : public JSObject
"shadow interface must match actual interface");
}
uint16_t nargs; /* number of formal arguments
private:
uint16_t nargs_; /* number of formal arguments
(including defaults and the rest parameter unlike f.length) */
uint16_t flags; /* bitfield composed of the above Flags enum */
uint16_t flags_; /* bitfield composed of the above Flags enum */
union U {
class Native {
friend class JSFunction;
@ -85,7 +86,6 @@ class JSFunction : public JSObject
} i;
void *nativeOrScript;
} u;
private:
js::HeapPtrAtom atom_; /* name for diagnostics and decompiling */
public:
@ -104,26 +104,36 @@ class JSFunction : public JSObject
isGenerator();
}
size_t nargs() const {
js::AutoThreadSafeAccess ts(this);
return nargs_;
}
uint16_t flags() const {
js::AutoThreadSafeAccess ts(this);
return flags_;
}
/* A function can be classified as either native (C++) or interpreted (JS): */
bool isInterpreted() const { return flags & (INTERPRETED | INTERPRETED_LAZY); }
bool isInterpreted() const { return flags() & (INTERPRETED | INTERPRETED_LAZY); }
bool isNative() const { return !isInterpreted(); }
/* Possible attributes of a native function: */
bool isNativeConstructor() const { return flags & NATIVE_CTOR; }
bool isNativeConstructor() const { return flags() & NATIVE_CTOR; }
/* Possible attributes of an interpreted function: */
bool isFunctionPrototype() const { return flags & IS_FUN_PROTO; }
bool isInterpretedLazy() const { return flags & INTERPRETED_LAZY; }
bool hasScript() const { return flags & INTERPRETED; }
bool isExprClosure() const { return flags & EXPR_CLOSURE; }
bool hasGuessedAtom() const { return flags & HAS_GUESSED_ATOM; }
bool isLambda() const { return flags & LAMBDA; }
bool isSelfHostedBuiltin() const { return flags & SELF_HOSTED; }
bool isSelfHostedConstructor() const { return flags & SELF_HOSTED_CTOR; }
bool hasRest() const { return flags & HAS_REST; }
bool isFunctionPrototype() const { return flags() & IS_FUN_PROTO; }
bool isInterpretedLazy() const { return flags() & INTERPRETED_LAZY; }
bool hasScript() const { return flags() & INTERPRETED; }
bool isExprClosure() const { return flags() & EXPR_CLOSURE; }
bool hasGuessedAtom() const { return flags() & HAS_GUESSED_ATOM; }
bool isLambda() const { return flags() & LAMBDA; }
bool isSelfHostedBuiltin() const { return flags() & SELF_HOSTED; }
bool isSelfHostedConstructor() const { return flags() & SELF_HOSTED_CTOR; }
bool hasRest() const { return flags() & HAS_REST; }
bool isWrappable() const {
JS_ASSERT_IF(flags & SH_WRAPPABLE, isSelfHostedBuiltin());
return flags & SH_WRAPPABLE;
JS_ASSERT_IF(flags() & SH_WRAPPABLE, isSelfHostedBuiltin());
return flags() & SH_WRAPPABLE;
}
bool hasJITCode() const {
@ -144,7 +154,7 @@ class JSFunction : public JSObject
//
// isArrow() is true for all three of these Function objects.
// isBoundFunction() is true only for the last one.
bool isArrow() const { return flags & ARROW; }
bool isArrow() const { return flags() & ARROW; }
/* Compound attributes: */
bool isBuiltin() const {
@ -170,40 +180,48 @@ class JSFunction : public JSObject
return nonLazyScript()->strict();
}
void setFlags(uint16_t flags) {
this->flags_ = flags;
}
// Can be called multiple times by the parser.
void setArgCount(uint16_t nargs) {
this->nargs = nargs;
this->nargs_ = nargs;
}
// Can be called multiple times by the parser.
void setHasRest() {
flags |= HAS_REST;
flags_ |= HAS_REST;
}
void setIsSelfHostedBuiltin() {
JS_ASSERT(!isSelfHostedBuiltin());
flags |= SELF_HOSTED;
flags_ |= SELF_HOSTED;
}
void setIsSelfHostedConstructor() {
JS_ASSERT(!isSelfHostedConstructor());
flags |= SELF_HOSTED_CTOR;
flags_ |= SELF_HOSTED_CTOR;
}
void makeWrappable() {
JS_ASSERT(isSelfHostedBuiltin());
JS_ASSERT(!isWrappable());
flags |= SH_WRAPPABLE;
flags_ |= SH_WRAPPABLE;
}
void setIsFunctionPrototype() {
JS_ASSERT(!isFunctionPrototype());
flags |= IS_FUN_PROTO;
flags_ |= IS_FUN_PROTO;
}
// Can be called multiple times by the parser.
void setIsExprClosure() {
flags |= EXPR_CLOSURE;
flags_ |= EXPR_CLOSURE;
}
void setArrow() {
flags_ |= ARROW;
}
JSAtom *atom() const { return hasGuessedAtom() ? nullptr : atom_.get(); }
@ -216,7 +234,7 @@ class JSFunction : public JSObject
JS_ASSERT(atom != nullptr);
JS_ASSERT(!hasGuessedAtom());
atom_ = atom;
flags |= HAS_GUESSED_ATOM;
flags_ |= HAS_GUESSED_ATOM;
}
/* uint16_t representation bounds number of call object dynamic slots. */
@ -241,6 +259,8 @@ class JSFunction : public JSObject
((js::HeapPtrObject *)&u.i.env_)->init(obj);
}
static inline size_t offsetOfNargs() { return offsetof(JSFunction, nargs_); }
static inline size_t offsetOfFlags() { return offsetof(JSFunction, flags_); }
static inline size_t offsetOfEnvironment() { return offsetof(JSFunction, u.i.env_); }
static inline size_t offsetOfAtom() { return offsetof(JSFunction, atom_); }
@ -291,8 +311,8 @@ class JSFunction : public JSObject
if (shadowZone()->needsBarrier())
js::LazyScript::writeBarrierPre(lazy);
flags &= ~INTERPRETED_LAZY;
flags |= INTERPRETED;
flags_ &= ~INTERPRETED_LAZY;
flags_ |= INTERPRETED;
initScript(script);
}
JS_ASSERT(hasScript());
@ -348,8 +368,8 @@ class JSFunction : public JSObject
void initLazyScript(js::LazyScript *lazy) {
JS_ASSERT(isInterpreted());
flags &= ~INTERPRETED;
flags |= INTERPRETED_LAZY;
flags_ &= ~INTERPRETED;
flags_ |= INTERPRETED_LAZY;
u.i.s.lazy_ = lazy;
}
@ -426,8 +446,8 @@ class JSFunction : public JSObject
public:
inline bool isExtended() const {
JS_STATIC_ASSERT(FinalizeKind != ExtendedFinalizeKind);
JS_ASSERT_IF(isTenured(), !!(flags & EXTENDED) == (tenuredGetAllocKind() == ExtendedFinalizeKind));
return !!(flags & EXTENDED);
JS_ASSERT_IF(isTenured(), !!(flags() & EXTENDED) == (tenuredGetAllocKind() == ExtendedFinalizeKind));
return !!(flags() & EXTENDED);
}
/*

22
js/src/jsinfer.cpp
View File

@ -574,10 +574,10 @@ class types::CompilerConstraintList
// OOM during generation of some constraint.
bool failed_;
#ifdef JS_ION
// Allocator used for constraints.
LifoAlloc *alloc_;
#ifdef JS_ION
// Constraints generated on heap properties.
Vector<CompilerConstraint *, 0, jit::IonAllocPolicy> constraints;
@ -588,8 +588,8 @@ class types::CompilerConstraintList
public:
CompilerConstraintList(jit::TempAllocator &alloc)
: failed_(false)
, alloc_(alloc.lifoAlloc())
#ifdef JS_ION
, alloc_(alloc.lifoAlloc())
, constraints(alloc)
, frozenScripts(alloc)
#endif
@ -661,14 +661,22 @@ class types::CompilerConstraintList
failed_ = true;
}
LifoAlloc *alloc() const {
#ifdef JS_ION
return alloc_;
#else
MOZ_CRASH();
#endif
}
};
CompilerConstraintList *
types::NewCompilerConstraintList(jit::TempAllocator &alloc)
{
#ifdef JS_ION
return alloc.lifoAlloc()->new_<CompilerConstraintList>(alloc);
#else
MOZ_CRASH();
#endif
}
/* static */ bool
@ -692,7 +700,7 @@ TypeScript::FreezeTypeSets(CompilerConstraintList *constraints, JSScript *script
}
*pThisTypes = types + (ThisTypes(script) - existing);
*pArgTypes = (script->function() && script->function()->nargs)
*pArgTypes = (script->function() && script->function()->nargs())
? (types + (ArgTypes(script, 0) - existing))
: nullptr;
*pBytecodeTypes = types;
@ -972,7 +980,7 @@ types::FinishCompilation(JSContext *cx, HandleScript script, ExecutionMode execu
if (!CheckFrozenTypeSet(cx, entry.thisTypes, types::TypeScript::ThisTypes(entry.script)))
succeeded = false;
unsigned nargs = entry.script->function() ? entry.script->function()->nargs : 0;
unsigned nargs = entry.script->function() ? entry.script->function()->nargs() : 0;
for (size_t i = 0; i < nargs; i++) {
if (!CheckFrozenTypeSet(cx, &entry.argTypes[i], types::TypeScript::ArgTypes(entry.script, i)))
succeeded = false;
@ -3354,7 +3362,7 @@ void
types::TypeMonitorCallSlow(JSContext *cx, JSObject *callee, const CallArgs &args,
bool constructing)
{
unsigned nargs = callee->as<JSFunction>().nargs;
unsigned nargs = callee->as<JSFunction>().nargs();
JSScript *script = callee->as<JSFunction>().nonLazyScript();
if (!constructing)
@ -3505,7 +3513,7 @@ JSScript::makeTypes(JSContext *cx)
InferSpew(ISpewOps, "typeSet: %sT%p%s this #%u",
InferSpewColor(thisTypes), thisTypes, InferSpewColorReset(),
id());
unsigned nargs = function() ? function()->nargs : 0;
unsigned nargs = function() ? function()->nargs() : 0;
for (unsigned i = 0; i < nargs; i++) {
TypeSet *types = TypeScript::ArgTypes(this, i);
InferSpew(ISpewOps, "typeSet: %sT%p%s arg%u #%u",
@ -4385,7 +4393,7 @@ TypeScript::printTypes(JSContext *cx, HandleScript script) const
fprintf(stderr, "\n this:");
TypeScript::ThisTypes(script)->print();
for (unsigned i = 0; script->function() && i < script->function()->nargs; i++) {
for (unsigned i = 0; script->function() && i < script->function()->nargs(); i++) {
fprintf(stderr, "\n arg%u:", i);
TypeScript::ArgTypes(script, i)->print();
}

2
js/src/jsinferinlines.h
View File

@ -617,7 +617,7 @@ TypeScript::ThisTypes(JSScript *script)
/* static */ inline StackTypeSet *
TypeScript::ArgTypes(JSScript *script, unsigned i)
{
JS_ASSERT(i < script->function()->nargs);
JS_ASSERT(i < script->function()->nargs());
return script->types->typeArray() + script->nTypeSets() + js::analyze::ArgSlot(i);
}

11
js/src/jsobjinlines.h
View File

@ -1047,15 +1047,18 @@ static JS_ALWAYS_INLINE bool
NewObjectMetadata(ExclusiveContext *cxArg, JSObject **pmetadata)
{
// The metadata callback is invoked before each created object, except when
// analysis/compilation/parsing is active as the callback may reenter JS.
// analysis/compilation is active, to avoid recursion.
JS_ASSERT(!*pmetadata);
if (JSContext *cx = cxArg->maybeJSContext()) {
if (JS_UNLIKELY((size_t)cx->compartment()->hasObjectMetadataCallback()) &&
!cx->compartment()->activeAnalysis &&
!cx->runtime()->mainThread.activeCompilations)
!cx->compartment()->activeAnalysis)
{
JS::DisableGenerationalGC(cx->runtime());
gc::AutoSuppressGC suppress(cx);
// Use AutoEnterAnalysis to prohibit both any GC activity under the
// callback, and any reentering of JS via Invoke() etc.
types::AutoEnterAnalysis enter(cx);
bool status = cx->compartment()->callObjectMetadataCallback(cx, pmetadata);
JS::EnableGenerationalGC(cx->runtime());
return status;

4
js/src/jsopcode.cpp
View File

@ -410,7 +410,7 @@ class BytecodeParser
}
uint32_t numSlots() {
return 1 + (script_->function() ? script_->function()->nargs : 0) + script_->nfixed();
return 1 + (script_->function() ? script_->function()->nargs() : 0) + script_->nfixed();
}
uint32_t maximumStackDepth() {
@ -1688,7 +1688,7 @@ JSAtom *
ExpressionDecompiler::getVar(unsigned slot)
{
JS_ASSERT(fun);
slot += fun->nargs;
slot += fun->nargs();
JS_ASSERT(slot < script->bindings.count());
return (*localNames)[slot].name();
}

8
js/src/vm/ArgumentsObject.cpp
View File

@ -96,7 +96,7 @@ struct CopyIonJSFrameArgs
void copyArgs(JSContext *, HeapValue *dstBase, unsigned totalArgs) const {
unsigned numActuals = frame_->numActualArgs();
unsigned numFormals = jit::CalleeTokenToFunction(frame_->calleeToken())->nargs;
unsigned numFormals = jit::CalleeTokenToFunction(frame_->calleeToken())->nargs();
JS_ASSERT(numActuals <= totalArgs);
JS_ASSERT(numFormals <= totalArgs);
JS_ASSERT(Max(numActuals, numFormals) == totalArgs);
@ -144,7 +144,7 @@ struct CopyScriptFrameIterArgs
/* Define formals which are not part of the actuals. */
unsigned numActuals = iter_.numActualArgs();
unsigned numFormals = iter_.callee()->nargs;
unsigned numFormals = iter_.callee()->nargs();
JS_ASSERT(numActuals <= totalArgs);
JS_ASSERT(numFormals <= totalArgs);
JS_ASSERT(Max(numActuals, numFormals) == totalArgs);
@ -192,7 +192,7 @@ ArgumentsObject::create(JSContext *cx, HandleScript script, HandleFunction calle
if (!shape)
return nullptr;
unsigned numFormals = callee->nargs;
unsigned numFormals = callee->nargs();
unsigned numDeletedWords = NumWordsForBitArrayOfLength(numActuals);
unsigned numArgs = Max(numActuals, numFormals);
unsigned numBytes = offsetof(ArgumentsData, args) +
@ -341,7 +341,7 @@ ArgSetter(JSContext *cx, HandleObject obj, HandleId id, bool strict, MutableHand
unsigned arg = unsigned(JSID_TO_INT(id));
if (arg < argsobj.initialLength() && !argsobj.isElementDeleted(arg)) {
argsobj.setElement(cx, arg, vp);
if (arg < script->function()->nargs)
if (arg < script->function()->nargs())
types::TypeScript::SetArgument(cx, script, arg, vp);
return true;
}

12
js/src/vm/Debugger.cpp
View File

@ -4720,23 +4720,23 @@ DebuggerObject_getParameterNames(JSContext *cx, unsigned argc, Value *vp)
return true;
}
RootedObject result(cx, NewDenseAllocatedArray(cx, fun->nargs));
RootedObject result(cx, NewDenseAllocatedArray(cx, fun->nargs()));
if (!result)
return false;
result->ensureDenseInitializedLength(cx, 0, fun->nargs);
result->ensureDenseInitializedLength(cx, 0, fun->nargs());
if (fun->isInterpreted()) {
RootedScript script(cx, GetOrCreateFunctionScript(cx, fun));
if (!script)
return false;
JS_ASSERT(fun->nargs == script->bindings.numArgs());
JS_ASSERT(fun->nargs() == script->bindings.numArgs());
if (fun->nargs > 0) {
if (fun->nargs() > 0) {
BindingVector bindings(cx);
if (!FillBindingVector(script, &bindings))
return false;
for (size_t i = 0; i < fun->nargs; i++) {
for (size_t i = 0; i < fun->nargs(); i++) {
Value v;
if (bindings[i].name()->length() == 0)
v = UndefinedValue();
@ -4746,7 +4746,7 @@ DebuggerObject_getParameterNames(JSContext *cx, unsigned argc, Value *vp)
}
}
} else {
for (size_t i = 0; i < fun->nargs; i++)
for (size_t i = 0; i < fun->nargs(); i++)
result->setDenseElement(i, UndefinedValue());
}

2
js/src/vm/Interpreter.cpp
View File

@ -3609,7 +3609,7 @@ js::Lambda(JSContext *cx, HandleFunction fun, HandleObject parent)
clone = js_fun_bind(cx, clone, thisval, nullptr, 0);
if (!clone)
return nullptr;
clone->as<JSFunction>().flags |= JSFunction::ARROW;
clone->as<JSFunction>().setArrow();
}
JS_ASSERT(clone->global() == clone->global());

2
js/src/vm/OldDebugAPI.cpp
View File

@ -450,7 +450,7 @@ JS_GetLinePCs(JSContext *cx, JSScript *script,
JS_PUBLIC_API(unsigned)
JS_GetFunctionArgumentCount(JSContext *cx, JSFunction *fun)
{
return fun->nargs;
return fun->nargs();
}
JS_PUBLIC_API(bool)

4
js/src/vm/SelfHosting.cpp
View File

@ -960,8 +960,8 @@ JSRuntime::cloneSelfHostedFunctionScript(JSContext *cx, Handle<PropertyName*> na
return false;
targetFun->setScript(cscript);
cscript->setFunction(targetFun);
JS_ASSERT(sourceFun->nargs == targetFun->nargs);
targetFun->flags = sourceFun->flags | JSFunction::EXTENDED;
JS_ASSERT(sourceFun->nargs() == targetFun->nargs());
targetFun->setFlags(sourceFun->flags() | JSFunction::EXTENDED);
return true;
}

2
js/src/vm/Stack-inl.h
View File

@ -253,7 +253,7 @@ InterpreterStack::getCallFrame(JSContext *cx, const CallArgs &args, HandleScript
JSFunction *fun = &args.callee().as<JSFunction>();
JS_ASSERT(fun->nonLazyScript() == script);
unsigned nformal = fun->nargs;
unsigned nformal = fun->nargs();
unsigned nvals = script->nslots();
if (args.length() >= nformal) {

2
js/src/vm/Stack.cpp
View File

@ -165,7 +165,7 @@ JSObject *
StackFrame::createRestParameter(JSContext *cx)
{
JS_ASSERT(fun()->hasRest());
unsigned nformal = fun()->nargs - 1, nactual = numActualArgs();
unsigned nformal = fun()->nargs() - 1, nactual = numActualArgs();
unsigned nrest = (nactual > nformal) ? nactual - nformal : 0;
Value *restvp = argv() + nformal;
JSObject *obj = NewDenseCopiedArray(cx, nrest, restvp, nullptr);

4
js/src/vm/Stack.h
View File

@ -534,7 +534,7 @@ class StackFrame
bool copyRawFrameSlots(AutoValueVector *v);
unsigned numFormalArgs() const { JS_ASSERT(hasArgs()); return fun()->nargs; }
unsigned numFormalArgs() const { JS_ASSERT(hasArgs()); return fun()->nargs(); }
unsigned numActualArgs() const { JS_ASSERT(hasArgs()); return u.nactual; }
inline Value &canonicalActualArg(unsigned i) const;
@ -1563,7 +1563,7 @@ class ScriptFrameIter
JSFunction *callee() const;
Value calleev() const;
unsigned numActualArgs() const;
unsigned numFormalArgs() const { return script()->function()->nargs; }
unsigned numFormalArgs() const { return script()->function()->nargs(); }
Value unaliasedActual(unsigned i, MaybeCheckAliasing = CHECK_ALIASING) const;
JSObject *scopeChain() const;

2
layout/reftests/forms/fieldset/reftest.list
View File

@ -8,4 +8,4 @@ random-if(B2G) == fieldset-overflow-auto-1.html fieldset-overflow-auto-1-ref.htm
== positioned-container-1.html positioned-container-1-ref.html
== relpos-legend-1.html relpos-legend-1-ref.html
== relpos-legend-2.html relpos-legend-2-ref.html
== sticky-legend-1.html sticky-legend-1-ref.html
test-pref(layout.css.sticky.enabled,true) == sticky-legend-1.html sticky-legend-1-ref.html

23
memory/replace/dmd/DMD.cpp
View File

@ -15,6 +15,9 @@
#include <string.h>
#ifdef XP_WIN
#if defined(MOZ_OPTIMIZE) && !defined(MOZ_PROFILING)
#error "Optimized, DMD-enabled builds on Windows must be built with --enable-profiling"
#endif
#include <windows.h>
#include <process.h>
#else
@ -600,18 +603,17 @@ class LocationService
struct Entry
{
static const void* const kUnused;
const void* mPc; // if mPc==kUnused, the entry is unused
const void* mPc;
char* mFunction; // owned by the Entry; may be null
const char* mLibrary; // owned by mLibraryStrings; never null
// in a non-empty entry is in use
ptrdiff_t mLOffset;
char* mFileName; // owned by the Entry; may be null
unsigned long mLineNo;
uint32_t mLineNo:31;
uint32_t mInUse:1; // is the entry used?
Entry()
: mPc(kUnused), mFunction(nullptr), mLibrary(nullptr), mLOffset(0), mFileName(nullptr), mLineNo(0)
: mPc(0), mFunction(nullptr), mLibrary(nullptr), mLOffset(0), mFileName(nullptr), mLineNo(0), mInUse(0)
{}
~Entry()
@ -639,6 +641,8 @@ class LocationService
mLibrary = aLibrary;
mLOffset = aLOffset;
mLineNo = aLineNo;
mInUse = 1;
}
size_t SizeOfExcludingThis() {
@ -675,8 +679,7 @@ public:
MOZ_ASSERT(index < kNumEntries);
Entry& entry = mEntries[index];
MOZ_ASSERT(aPc != Entry::kUnused);
if (entry.mPc != aPc) {
if (!entry.mInUse || entry.mPc != aPc) {
mNumCacheMisses++;
// NS_DescribeCodeAddress can (on Linux) acquire a lock inside
@ -753,7 +756,7 @@ public:
{
size_t n = 0;
for (size_t i = 0; i < kNumEntries; i++) {
if (mEntries[i].mPc != Entry::kUnused) {
if (mEntries[i].mInUse) {
n++;
}
}
@ -764,10 +767,6 @@ public:
size_t NumCacheMisses() const { return mNumCacheMisses; }
};
// We can't use 0 because that sometimes shows up as a PC in stack traces.
const void* const LocationService::Entry::kUnused =
reinterpret_cast<const void* const>(intptr_t(-1));
//---------------------------------------------------------------------------
// Stack traces
//---------------------------------------------------------------------------

3
memory/replace/dmd/moz.build
View File

@ -23,3 +23,6 @@ LIBRARY_NAME = 'dmd'
FORCE_SHARED_LIB = True
DEFINES['MOZ_NO_MOZALLOC'] = True
if CONFIG['MOZ_OPTIMIZE']:
DEFINES['MOZ_OPTIMIZE'] = True

14
toolkit/mozapps/extensions/test/xpcshell/test_plugins.js
View File

@ -5,11 +5,25 @@
// This verifies that plugins exist and can be enabled and disabled.
var gID = null;
function setTestPluginState(state) {
let tags = AM_Cc["@mozilla.org/plugin/host;1"].getService(AM_Ci.nsIPluginHost)
.getPluginTags();
for (let tag of tags) {
if (tag.name == "Test Plug-in") {
tag.enabledState = state;
return;
}
}
throw Error("No plugin tag found for the test plugin");
}
function run_test() {
do_test_pending();
createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
Services.prefs.setBoolPref("plugins.click_to_play", true);
setTestPluginState(AM_Ci.nsIPluginTag.STATE_CLICKTOPLAY);
startupManager();
AddonManager.addAddonListener(AddonListener);
AddonManager.addInstallListener(InstallListener);