mirror of
https://code.forgejo.org/actions/setup-node.git
synced 2025-05-22 22:04:45 +00:00
.
This commit is contained in:
eric sciple
parent
beb1329f9f
commit
2b95e76931
7736 changed files with 1874747 additions and 51184 deletions
412
node_modules/nan/tools/1to2.js
generated
vendored
Executable file
412
node_modules/nan/tools/1to2.js
generated
vendored
Executable file
|
|
@ -0,0 +1,412 @@
|
|||
#!/usr/bin/env node
|
||||
/*********************************************************************
|
||||
* NAN - Native Abstractions for Node.js
|
||||
*
|
||||
* Copyright (c) 2018 NAN contributors
|
||||
*
|
||||
* MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
|
||||
********************************************************************/
|
||||
|
||||
var commander = require('commander'),
|
||||
fs = require('fs'),
|
||||
glob = require('glob'),
|
||||
groups = [],
|
||||
total = 0,
|
||||
warning1 = '/* ERROR: Rewrite using Buffer */\n',
|
||||
warning2 = '\\/\\* ERROR\\: Rewrite using Buffer \\*\\/\\n',
|
||||
length,
|
||||
i;
|
||||
|
||||
fs.readFile(__dirname + '/package.json', 'utf8', function (err, data) {
|
||||
if (err) {
|
||||
throw err;
|
||||
}
|
||||
|
||||
commander
|
||||
.version(JSON.parse(data).version)
|
||||
.usage('[options] <file ...>')
|
||||
.parse(process.argv);
|
||||
|
||||
if (!process.argv.slice(2).length) {
|
||||
commander.outputHelp();
|
||||
}
|
||||
});
|
||||
|
||||
/* construct strings representing regular expressions
|
||||
each expression contains a unique group allowing for identification of the match
|
||||
the index of this key group, relative to the regular expression in question,
|
||||
is indicated by the first array member */
|
||||
|
||||
/* simple substistutions, key group is the entire match, 0 */
|
||||
groups.push([0, [
|
||||
'_NAN_',
|
||||
'NODE_SET_METHOD',
|
||||
'NODE_SET_PROTOTYPE_METHOD',
|
||||
'NanAsciiString',
|
||||
'NanEscapeScope',
|
||||
'NanReturnValue',
|
||||
'NanUcs2String'].join('|')]);
|
||||
|
||||
/* substitutions of parameterless macros, key group is 1 */
|
||||
groups.push([1, ['(', [
|
||||
'NanEscapableScope',
|
||||
'NanReturnNull',
|
||||
'NanReturnUndefined',
|
||||
'NanScope'].join('|'), ')\\(\\)'].join('')]);
|
||||
|
||||
/* replace TryCatch with NanTryCatch once, gobbling possible namespace, key group 2 */
|
||||
groups.push([2, '(?:(?:v8\\:\\:)?|(Nan)?)(TryCatch)']);
|
||||
|
||||
/* NanNew("string") will likely not fail a ToLocalChecked(), key group 1 */
|
||||
groups.push([1, ['(NanNew)', '(\\("[^\\"]*"[^\\)]*\\))(?!\\.ToLocalChecked\\(\\))'].join('')]);
|
||||
|
||||
/* Removed v8 APIs, warn that the code needs rewriting using node::Buffer, key group 2 */
|
||||
groups.push([2, ['(', warning2, ')?', '^.*?(', [
|
||||
'GetIndexedPropertiesExternalArrayDataLength',
|
||||
'GetIndexedPropertiesExternalArrayData',
|
||||
'GetIndexedPropertiesExternalArrayDataType',
|
||||
'GetIndexedPropertiesPixelData',
|
||||
'GetIndexedPropertiesPixelDataLength',
|
||||
'HasIndexedPropertiesInExternalArrayData',
|
||||
'HasIndexedPropertiesInPixelData',
|
||||
'SetIndexedPropertiesToExternalArrayData',
|
||||
'SetIndexedPropertiesToPixelData'].join('|'), ')'].join('')]);
|
||||
|
||||
/* No need for NanScope in V8-exposed methods, key group 2 */
|
||||
groups.push([2, ['((', [
|
||||
'NAN_METHOD',
|
||||
'NAN_GETTER',
|
||||
'NAN_SETTER',
|
||||
'NAN_PROPERTY_GETTER',
|
||||
'NAN_PROPERTY_SETTER',
|
||||
'NAN_PROPERTY_ENUMERATOR',
|
||||
'NAN_PROPERTY_DELETER',
|
||||
'NAN_PROPERTY_QUERY',
|
||||
'NAN_INDEX_GETTER',
|
||||
'NAN_INDEX_SETTER',
|
||||
'NAN_INDEX_ENUMERATOR',
|
||||
'NAN_INDEX_DELETER',
|
||||
'NAN_INDEX_QUERY'].join('|'), ')\\([^\\)]*\\)\\s*\\{)\\s*NanScope\\(\\)\\s*;'].join('')]);
|
||||
|
||||
/* v8::Value::ToXXXXXXX returns v8::MaybeLocal<T>, key group 3 */
|
||||
groups.push([3, ['([\\s\\(\\)])([^\\s\\(\\)]+)->(', [
|
||||
'Boolean',
|
||||
'Number',
|
||||
'String',
|
||||
'Object',
|
||||
'Integer',
|
||||
'Uint32',
|
||||
'Int32'].join('|'), ')\\('].join('')]);
|
||||
|
||||
/* v8::Value::XXXXXXXValue returns v8::Maybe<T>, key group 3 */
|
||||
groups.push([3, ['([\\s\\(\\)])([^\\s\\(\\)]+)->((?:', [
|
||||
'Boolean',
|
||||
'Number',
|
||||
'Integer',
|
||||
'Uint32',
|
||||
'Int32'].join('|'), ')Value)\\('].join('')]);
|
||||
|
||||
/* NAN_WEAK_CALLBACK macro was removed, write out callback definition, key group 1 */
|
||||
groups.push([1, '(NAN_WEAK_CALLBACK)\\(([^\\s\\)]+)\\)']);
|
||||
|
||||
/* node::ObjectWrap and v8::Persistent have been replaced with Nan implementations, key group 1 */
|
||||
groups.push([1, ['(', [
|
||||
'NanDisposePersistent',
|
||||
'NanObjectWrapHandle'].join('|'), ')\\s*\\(\\s*([^\\s\\)]+)'].join('')]);
|
||||
|
||||
/* Since NanPersistent there is no need for NanMakeWeakPersistent, key group 1 */
|
||||
groups.push([1, '(NanMakeWeakPersistent)\\s*\\(\\s*([^\\s,]+)\\s*,\\s*']);
|
||||
|
||||
/* Many methods of v8::Object and others now return v8::MaybeLocal<T>, key group 3 */
|
||||
groups.push([3, ['([\\s])([^\\s]+)->(', [
|
||||
'GetEndColumn',
|
||||
'GetFunction',
|
||||
'GetLineNumber',
|
||||
'NewInstance',
|
||||
'GetPropertyNames',
|
||||
'GetOwnPropertyNames',
|
||||
'GetSourceLine',
|
||||
'GetStartColumn',
|
||||
'ObjectProtoToString',
|
||||
'ToArrayIndex',
|
||||
'ToDetailString',
|
||||
'CallAsConstructor',
|
||||
'CallAsFunction',
|
||||
'CloneElementAt',
|
||||
'Delete',
|
||||
'ForceSet',
|
||||
'Get',
|
||||
'GetPropertyAttributes',
|
||||
'GetRealNamedProperty',
|
||||
'GetRealNamedPropertyInPrototypeChain',
|
||||
'Has',
|
||||
'HasOwnProperty',
|
||||
'HasRealIndexedProperty',
|
||||
'HasRealNamedCallbackProperty',
|
||||
'HasRealNamedProperty',
|
||||
'Set',
|
||||
'SetAccessor',
|
||||
'SetIndexedPropertyHandler',
|
||||
'SetNamedPropertyHandler',
|
||||
'SetPrototype'].join('|'), ')\\('].join('')]);
|
||||
|
||||
/* You should get an error if any of these fail anyways,
|
||||
or handle the error better, it is indicated either way, key group 2 */
|
||||
groups.push([2, ['NanNew(<(?:v8\\:\\:)?(', ['Date', 'String', 'RegExp'].join('|'), ')>)(\\([^\\)]*\\))(?!\\.ToLocalChecked\\(\\))'].join('')]);
|
||||
|
||||
/* v8::Value::Equals now returns a v8::Maybe, key group 3 */
|
||||
groups.push([3, '([\\s\\(\\)])([^\\s\\(\\)]+)->(Equals)\\(([^\\s\\)]+)']);
|
||||
|
||||
/* NanPersistent makes this unnecessary, key group 1 */
|
||||
groups.push([1, '(NanAssignPersistent)(?:<v8\\:\\:[^>]+>)?\\(([^,]+),\\s*']);
|
||||
|
||||
/* args has been renamed to info, key group 2 */
|
||||
groups.push([2, '(\\W)(args)(\\W)'])
|
||||
|
||||
/* node::ObjectWrap was replaced with NanObjectWrap, key group 2 */
|
||||
groups.push([2, '(\\W)(?:node\\:\\:)?(ObjectWrap)(\\W)']);
|
||||
|
||||
/* v8::Persistent was replaced with NanPersistent, key group 2 */
|
||||
groups.push([2, '(\\W)(?:v8\\:\\:)?(Persistent)(\\W)']);
|
||||
|
||||
/* counts the number of capturing groups in a well-formed regular expression,
|
||||
ignoring non-capturing groups and escaped parentheses */
|
||||
function groupcount(s) {
|
||||
var positive = s.match(/\((?!\?)/g),
|
||||
negative = s.match(/\\\(/g);
|
||||
return (positive ? positive.length : 0) - (negative ? negative.length : 0);
|
||||
}
|
||||
|
||||
/* compute the absolute position of each key group in the joined master RegExp */
|
||||
for (i = 1, length = groups.length; i < length; i++) {
|
||||
total += groupcount(groups[i - 1][1]);
|
||||
groups[i][0] += total;
|
||||
}
|
||||
|
||||
/* create the master RegExp, whis is the union of all the groups' expressions */
|
||||
master = new RegExp(groups.map(function (a) { return a[1]; }).join('|'), 'gm');
|
||||
|
||||
/* replacement function for String.replace, receives 21 arguments */
|
||||
function replace() {
|
||||
/* simple expressions */
|
||||
switch (arguments[groups[0][0]]) {
|
||||
case '_NAN_':
|
||||
return 'NAN_';
|
||||
case 'NODE_SET_METHOD':
|
||||
return 'NanSetMethod';
|
||||
case 'NODE_SET_PROTOTYPE_METHOD':
|
||||
return 'NanSetPrototypeMethod';
|
||||
case 'NanAsciiString':
|
||||
return 'NanUtf8String';
|
||||
case 'NanEscapeScope':
|
||||
return 'scope.Escape';
|
||||
case 'NanReturnNull':
|
||||
return 'info.GetReturnValue().SetNull';
|
||||
case 'NanReturnValue':
|
||||
return 'info.GetReturnValue().Set';
|
||||
case 'NanUcs2String':
|
||||
return 'v8::String::Value';
|
||||
default:
|
||||
}
|
||||
|
||||
/* macros without arguments */
|
||||
switch (arguments[groups[1][0]]) {
|
||||
case 'NanEscapableScope':
|
||||
return 'NanEscapableScope scope'
|
||||
case 'NanReturnUndefined':
|
||||
return 'return';
|
||||
case 'NanScope':
|
||||
return 'NanScope scope';
|
||||
default:
|
||||
}
|
||||
|
||||
/* TryCatch, emulate negative backref */
|
||||
if (arguments[groups[2][0]] === 'TryCatch') {
|
||||
return arguments[groups[2][0] - 1] ? arguments[0] : 'NanTryCatch';
|
||||
}
|
||||
|
||||
/* NanNew("foo") --> NanNew("foo").ToLocalChecked() */
|
||||
if (arguments[groups[3][0]] === 'NanNew') {
|
||||
return [arguments[0], '.ToLocalChecked()'].join('');
|
||||
}
|
||||
|
||||
/* insert warning for removed functions as comment on new line above */
|
||||
switch (arguments[groups[4][0]]) {
|
||||
case 'GetIndexedPropertiesExternalArrayData':
|
||||
case 'GetIndexedPropertiesExternalArrayDataLength':
|
||||
case 'GetIndexedPropertiesExternalArrayDataType':
|
||||
case 'GetIndexedPropertiesPixelData':
|
||||
case 'GetIndexedPropertiesPixelDataLength':
|
||||
case 'HasIndexedPropertiesInExternalArrayData':
|
||||
case 'HasIndexedPropertiesInPixelData':
|
||||
case 'SetIndexedPropertiesToExternalArrayData':
|
||||
case 'SetIndexedPropertiesToPixelData':
|
||||
return arguments[groups[4][0] - 1] ? arguments[0] : [warning1, arguments[0]].join('');
|
||||
default:
|
||||
}
|
||||
|
||||
/* remove unnecessary NanScope() */
|
||||
switch (arguments[groups[5][0]]) {
|
||||
case 'NAN_GETTER':
|
||||
case 'NAN_METHOD':
|
||||
case 'NAN_SETTER':
|
||||
case 'NAN_INDEX_DELETER':
|
||||
case 'NAN_INDEX_ENUMERATOR':
|
||||
case 'NAN_INDEX_GETTER':
|
||||
case 'NAN_INDEX_QUERY':
|
||||
case 'NAN_INDEX_SETTER':
|
||||
case 'NAN_PROPERTY_DELETER':
|
||||
case 'NAN_PROPERTY_ENUMERATOR':
|
||||
case 'NAN_PROPERTY_GETTER':
|
||||
case 'NAN_PROPERTY_QUERY':
|
||||
case 'NAN_PROPERTY_SETTER':
|
||||
return arguments[groups[5][0] - 1];
|
||||
default:
|
||||
}
|
||||
|
||||
/* Value converstion */
|
||||
switch (arguments[groups[6][0]]) {
|
||||
case 'Boolean':
|
||||
case 'Int32':
|
||||
case 'Integer':
|
||||
case 'Number':
|
||||
case 'Object':
|
||||
case 'String':
|
||||
case 'Uint32':
|
||||
return [arguments[groups[6][0] - 2], 'NanTo<v8::', arguments[groups[6][0]], '>(', arguments[groups[6][0] - 1]].join('');
|
||||
default:
|
||||
}
|
||||
|
||||
/* other value conversion */
|
||||
switch (arguments[groups[7][0]]) {
|
||||
case 'BooleanValue':
|
||||
return [arguments[groups[7][0] - 2], 'NanTo<bool>(', arguments[groups[7][0] - 1]].join('');
|
||||
case 'Int32Value':
|
||||
return [arguments[groups[7][0] - 2], 'NanTo<int32_t>(', arguments[groups[7][0] - 1]].join('');
|
||||
case 'IntegerValue':
|
||||
return [arguments[groups[7][0] - 2], 'NanTo<int64_t>(', arguments[groups[7][0] - 1]].join('');
|
||||
case 'Uint32Value':
|
||||
return [arguments[groups[7][0] - 2], 'NanTo<uint32_t>(', arguments[groups[7][0] - 1]].join('');
|
||||
default:
|
||||
}
|
||||
|
||||
/* NAN_WEAK_CALLBACK */
|
||||
if (arguments[groups[8][0]] === 'NAN_WEAK_CALLBACK') {
|
||||
return ['template<typename T>\nvoid ',
|
||||
arguments[groups[8][0] + 1], '(const NanWeakCallbackInfo<T> &data)'].join('');
|
||||
}
|
||||
|
||||
/* use methods on NAN classes instead */
|
||||
switch (arguments[groups[9][0]]) {
|
||||
case 'NanDisposePersistent':
|
||||
return [arguments[groups[9][0] + 1], '.Reset('].join('');
|
||||
case 'NanObjectWrapHandle':
|
||||
return [arguments[groups[9][0] + 1], '->handle('].join('');
|
||||
default:
|
||||
}
|
||||
|
||||
/* use method on NanPersistent instead */
|
||||
if (arguments[groups[10][0]] === 'NanMakeWeakPersistent') {
|
||||
return arguments[groups[10][0] + 1] + '.SetWeak(';
|
||||
}
|
||||
|
||||
/* These return Maybes, the upper ones take no arguments */
|
||||
switch (arguments[groups[11][0]]) {
|
||||
case 'GetEndColumn':
|
||||
case 'GetFunction':
|
||||
case 'GetLineNumber':
|
||||
case 'GetOwnPropertyNames':
|
||||
case 'GetPropertyNames':
|
||||
case 'GetSourceLine':
|
||||
case 'GetStartColumn':
|
||||
case 'NewInstance':
|
||||
case 'ObjectProtoToString':
|
||||
case 'ToArrayIndex':
|
||||
case 'ToDetailString':
|
||||
return [arguments[groups[11][0] - 2], 'Nan', arguments[groups[11][0]], '(', arguments[groups[11][0] - 1]].join('');
|
||||
case 'CallAsConstructor':
|
||||
case 'CallAsFunction':
|
||||
case 'CloneElementAt':
|
||||
case 'Delete':
|
||||
case 'ForceSet':
|
||||
case 'Get':
|
||||
case 'GetPropertyAttributes':
|
||||
case 'GetRealNamedProperty':
|
||||
case 'GetRealNamedPropertyInPrototypeChain':
|
||||
case 'Has':
|
||||
case 'HasOwnProperty':
|
||||
case 'HasRealIndexedProperty':
|
||||
case 'HasRealNamedCallbackProperty':
|
||||
case 'HasRealNamedProperty':
|
||||
case 'Set':
|
||||
case 'SetAccessor':
|
||||
case 'SetIndexedPropertyHandler':
|
||||
case 'SetNamedPropertyHandler':
|
||||
case 'SetPrototype':
|
||||
return [arguments[groups[11][0] - 2], 'Nan', arguments[groups[11][0]], '(', arguments[groups[11][0] - 1], ', '].join('');
|
||||
default:
|
||||
}
|
||||
|
||||
/* Automatic ToLocalChecked(), take it or leave it */
|
||||
switch (arguments[groups[12][0]]) {
|
||||
case 'Date':
|
||||
case 'String':
|
||||
case 'RegExp':
|
||||
return ['NanNew', arguments[groups[12][0] - 1], arguments[groups[12][0] + 1], '.ToLocalChecked()'].join('');
|
||||
default:
|
||||
}
|
||||
|
||||
/* NanEquals is now required for uniformity */
|
||||
if (arguments[groups[13][0]] === 'Equals') {
|
||||
return [arguments[groups[13][0] - 1], 'NanEquals(', arguments[groups[13][0] - 1], ', ', arguments[groups[13][0] + 1]].join('');
|
||||
}
|
||||
|
||||
/* use method on replacement class instead */
|
||||
if (arguments[groups[14][0]] === 'NanAssignPersistent') {
|
||||
return [arguments[groups[14][0] + 1], '.Reset('].join('');
|
||||
}
|
||||
|
||||
/* args --> info */
|
||||
if (arguments[groups[15][0]] === 'args') {
|
||||
return [arguments[groups[15][0] - 1], 'info', arguments[groups[15][0] + 1]].join('');
|
||||
}
|
||||
|
||||
/* ObjectWrap --> NanObjectWrap */
|
||||
if (arguments[groups[16][0]] === 'ObjectWrap') {
|
||||
return [arguments[groups[16][0] - 1], 'NanObjectWrap', arguments[groups[16][0] + 1]].join('');
|
||||
}
|
||||
|
||||
/* Persistent --> NanPersistent */
|
||||
if (arguments[groups[17][0]] === 'Persistent') {
|
||||
return [arguments[groups[17][0] - 1], 'NanPersistent', arguments[groups[17][0] + 1]].join('');
|
||||
}
|
||||
|
||||
/* This should not happen. A switch is probably missing a case if it does. */
|
||||
throw 'Unhandled match: ' + arguments[0];
|
||||
}
|
||||
|
||||
/* reads a file, runs replacement and writes it back */
|
||||
function processFile(file) {
|
||||
fs.readFile(file, {encoding: 'utf8'}, function (err, data) {
|
||||
if (err) {
|
||||
throw err;
|
||||
}
|
||||
|
||||
/* run replacement twice, might need more runs */
|
||||
fs.writeFile(file, data.replace(master, replace).replace(master, replace), function (err) {
|
||||
if (err) {
|
||||
throw err;
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/* process file names from command line and process the identified files */
|
||||
for (i = 2, length = process.argv.length; i < length; i++) {
|
||||
glob(process.argv[i], function (err, matches) {
|
||||
if (err) {
|
||||
throw err;
|
||||
}
|
||||
matches.forEach(processFile);
|
||||
});
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue