chore: initial script

Author: gunjjoshi

lib/node_modules/@stdlib/math/special/abs/scripts/generate_addon.js

@@ -0,0 +1,387 @@
+/* eslint-disable */
+
+var resolve = require( 'path' ).resolve;
+var writeFile = require( '@stdlib/fs/write-file' ).sync;
+var readFile = require( '@stdlib/fs/read-file' ).sync;
+var replace = require( '@stdlib/string/replace' );
+var dtypeChar = require( '@stdlib/ndarray/base/dtype-char' );
+var dtypeEnum2Str = require( '@stdlib/ndarray/base/dtype-enum2str' );
+var uppercase = require( '@stdlib/string/uppercase' );
+var currentYear = require( '@stdlib/time/current-year' );
+var supportedTypes = require( './../lib/types.js' );
+
+// VARIABLES //
+
+var OPTS = {
+	'encoding': 'utf8'
+};
+
+// Define paths
+var SRC_PATH = resolve( __dirname, '..', 'src', 'addon.c.txt' );
+var OUT_PATH = resolve( __dirname, '..', 'src', 'addon.c' );
+
+// Define constants for the abs function
+var FCN_BASENAME = 'abs';
+var FCN_DESCRIPTION = 'Computes the absolute value.';
+var INTERFACE_NAME = 'stdlib_ndarray_abs';
+
+// Define a note
+var NOTE = 'NOTE: Do not edit this file directly. This file is auto-generated.';
+var YEAR = currentYear();
+var COPYRIGHT = 'The Stdlib Authors';
+
+// FUNCTIONS //
+
+/**
+* Generates function mappings based on the existing types.js file.
+*
+* @private
+* @returns {Object} object containing functions, types, and data arrays
+*/
+function generateFunctionMappings() {
+	var functions = [];
+	var typeEnums = [];
+	var data = [];
+	var i, inputDtype, outputDtype, inputChar, outputChar;
+	var functionName, typePair, dataFunction;
+
+	// Process the supportedTypes array (which contains pairs: input, output, input, output, ...)
+	for ( i = 0; i < supportedTypes.length; i += 2 ) {
+		// Convert numeric dtype constants to string names
+		inputDtype = dtypeEnum2Str( supportedTypes[ i ] );
+		outputDtype = dtypeEnum2Str( supportedTypes[ i + 1 ] );
+
+		// Handle generic types specially
+		if ( inputDtype === 'generic' || outputDtype === 'generic' ) {
+			// For generic types, we use a special function name pattern
+			if ( inputDtype === 'generic' && outputDtype === 'generic' ) {
+				functionName = 'stdlib_ndarray_v_v';
+			} else if ( outputDtype === 'generic' ) {
+				inputChar = dtypeChar( inputDtype );
+				functionName = 'stdlib_ndarray_' + inputChar + '_v';
+			} else {
+				// This case shouldn't occur in the current types.js
+				continue;
+			}
+		} else {
+			// Get dtype characters for non-generic types
+			inputChar = dtypeChar( inputDtype );
+			outputChar = dtypeChar( outputDtype );
+
+			if ( inputChar === 'a' ) {
+				inputChar = 'b';
+			}
+			if ( outputChar === 'a' ) {
+				outputChar = 'b';
+			}
+
+			// Generate function name
+			functionName = generateFunctionName( inputChar, outputChar );
+		}
+
+		functions.push( functionName );
+
+		// Generate type pair
+		typePair = generateTypePair( inputDtype, outputDtype );
+		typeEnums.push( typePair );
+
+		// Generate data function (generic types also use abs)
+		dataFunction = generateDataFunction( inputDtype );
+		data.push( dataFunction );
+	}
+
+	return {
+		'functions': functions,
+		'types': typeEnums,
+		'data': data
+	};
+}
+
+/**
+* Generates the ndarray function name for given input and output dtype characters.
+*
+* @private
+* @param {string} inputChar - input dtype character
+* @param {string} outputChar - output dtype character
+* @returns {string} function name
+*/
+function generateFunctionName( inputChar, outputChar ) {
+	// Use simple naming convention without casting suffix (matches original)
+	var functionName = 'stdlib_ndarray_' + inputChar + '_' + outputChar;
+	return functionName;
+}
+
+/**
+* Generates the type pair string for given input and output dtypes.
+*
+* @private
+* @param {string} inputDtype - input data type
+* @param {string} outputDtype - output data type
+* @returns {string} type pair string
+*/
+function generateTypePair( inputDtype, outputDtype ) {
+	var inputEnum, outputEnum;
+
+	// Handle generic type specially
+	if ( inputDtype === 'generic' ) {
+		inputEnum = 'STDLIB_NDARRAY_GENERIC';
+	} else {
+		inputEnum = 'STDLIB_NDARRAY_' + uppercase( inputDtype );
+	}
+
+	if ( outputDtype === 'generic' ) {
+		outputEnum = 'STDLIB_NDARRAY_GENERIC';
+	} else {
+		outputEnum = 'STDLIB_NDARRAY_' + uppercase( outputDtype );
+	}
+
+	return inputEnum + ', ' + outputEnum;
+}
+
+/**
+* Generates the data function pointer for given input dtype.
+*
+* @private
+* @param {string} inputDtype - input data type
+* @returns {string} data function pointer
+*/
+function generateDataFunction( inputDtype ) {
+	var functionPtr;
+
+	// Map dtypes to appropriate C functions
+	if ( inputDtype === 'float64' ) {
+		functionPtr = '(void *)stdlib_base_abs';
+	} else if ( inputDtype === 'float32' ) {
+		functionPtr = '(void *)stdlib_base_absf';
+	} else if ( inputDtype === 'int32' ) {
+		functionPtr = '(void *)stdlib_base_labs';
+	} else if ( inputDtype === 'int16' ) {
+		functionPtr = '(void *)abs_k';  // Custom int16 abs function
+	} else if ( inputDtype === 'int8' ) {
+		functionPtr = '(void *)abs_s';  // Custom int8 abs function
+	} else if ( inputDtype === 'uint32' ) {
+		functionPtr = '(void *)identity_u';  // Identity for unsigned types
+	} else if ( inputDtype === 'uint16' ) {
+		functionPtr = '(void *)identity_t';
+	} else if ( inputDtype === 'uint8' || inputDtype === 'uint8c' ) {
+		functionPtr = '(void *)identity_b';
+	} else if ( inputDtype === 'generic' ) {
+		functionPtr = '(void *)stdlib_base_abs';  // Generic uses regular abs
+	} else {
+		// Default fallback
+		functionPtr = '(void *)stdlib_base_abs';
+	}
+
+	return functionPtr;
+}
+
+/**
+* Creates a basic addon.c template if it doesn't exist.
+*
+* @private
+*/
+function createTemplate() {
+	var template = `/**
+* @license Apache-2.0
+*
+* Copyright (c) {{YEAR}} {{COPYRIGHT}}.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* {{NOTE}} */
+
+#include "stdlib/math/base/special/abs.h"
+#include "stdlib/math/base/special/absf.h"
+#include "stdlib/math/base/special/labs.h"
+#include "stdlib/ndarray/base/function_object.h"
+#include "stdlib/ndarray/base/napi/unary.h"
+#include "stdlib/ndarray/base/unary.h"
+#include "stdlib/ndarray/dtypes.h"
+#include <stdint.h>
+
+/**
+* Evaluates the identity function for an unsigned 32-bit integer.
+*
+* @param x   input value
+* @return    input value
+*/
+static uint32_t identity_u( const uint32_t x ) {
+	return x;
+}
+
+/**
+* Evaluates the identity function for an unsigned 16-bit integer.
+*
+* @param x   input value
+* @return    input value
+*/
+static uint16_t identity_t( const uint16_t x ) {
+	return x;
+}
+
+/**
+* Evaluates the identity function for an unsigned 8-bit integer.
+*
+* @param x   input value
+* @return    input value
+*/
+static uint8_t identity_b( const uint8_t x ) {
+	return x;
+}
+
+/**
+* Computes the absolute value of a signed 16-bit integer.
+*
+* @param x   input value
+* @return    absolute value
+*/
+static int16_t abs_k( const int16_t x ) {
+	if ( x < 0 ) {
+		return -x;
+	}
+	return x;
+}
+
+/**
+* Computes the absolute value of a signed 8-bit integer.
+*
+* @param x   input value
+* @return    absolute value
+*/
+static int8_t abs_s( const int8_t x ) {
+	if ( x < 0 ) {
+		return -x;
+	}
+	return x;
+}
+
+// Define an interface name:
+static const char name[] = "{{INTERFACE_NAME}}";
+
+// Define a list of ndarray functions:
+static ndarrayFcn functions[] = {
+	{{FUNCTIONS}}
+};
+
+// Define the **ndarray** argument types for each ndarray function:
+static int32_t types[] = {
+	{{TYPES}}
+};
+
+// Define a list of ndarray function "data" (in this case, callbacks):
+static void *data[] = {
+	{{DATA}}
+};
+
+// Create an ndarray function object:
+static const struct ndarrayFunctionObject obj = {
+	// ndarray function name:
+	name,
+
+	// Number of input ndarrays:
+	1,
+
+	// Number of output ndarrays:
+	1,
+
+	// Total number of ndarray arguments (nin + nout):
+	2,
+
+	// Array containing ndarray functions:
+	functions,
+
+	// Number of ndarray functions:
+	{{NUM_FUNCTIONS}},
+
+	// Array of type "numbers" (as enumerated elsewhere), where the total number of types equals \`narrays * nfunctions\` and where each set of \`narrays\` consecutive types (non-overlapping) corresponds to the set of ndarray argument types for a corresponding ndarray function:
+	types,
+
+	// Array of void pointers corresponding to the "data" (e.g., callbacks) which should be passed to a respective ndarray function (note: the number of pointers should match the number of ndarray functions):
+	data
+};
+
+STDLIB_NDARRAY_NAPI_MODULE_UNARY( obj )
+`;
+
+	var err = writeFile( SRC_PATH, template, OPTS );
+	if ( err ) {
+		throw err;
+	}
+	console.log( 'Created template file: ' + SRC_PATH );
+}
+
+/**
+* Generates the addon.c file for the abs function.
+*
+* @private
+* @throws {Error} unexpected error
+*/
+function generateAddonC() {
+	var template;
+	var functions;
+	var types;
+	var data;
+	var err;
+
+	// Read the template file
+	template = readFile( SRC_PATH, OPTS );
+	if ( template instanceof Error ) {
+		throw template;
+	}
+
+	// Generate function signatures, types, and data arrays
+	var result = generateFunctionMappings();
+	functions = result.functions;
+	types = result.types;
+	data = result.data;
+
+	// Replace template placeholders
+	template = replace( template, '{{YEAR}}', YEAR.toString() );
+	template = replace( template, '{{COPYRIGHT}}', COPYRIGHT );
+	template = replace( template, '{{NOTE}}', NOTE );
+	template = replace( template, '{{FCN_BASENAME}}', FCN_BASENAME );
+	template = replace( template, '{{FCN_DESCRIPTION}}', FCN_DESCRIPTION );
+	template = replace( template, '{{INTERFACE_NAME}}', INTERFACE_NAME );
+	template = replace( template, '{{FUNCTIONS}}', functions.join( ',\n\t' ) );
+	template = replace( template, '{{TYPES}}', types.join( ',\n\t' ) );
+	template = replace( template, '{{DATA}}', data.join( ',\n\t' ) );
+	template = replace( template, '{{NUM_FUNCTIONS}}', functions.length.toString() );
+
+	// Write the generated file
+	err = writeFile( OUT_PATH, template, OPTS );
+	if ( err ) {
+		throw err;
+	}
+
+	console.log( 'Generated addon.c with ' + functions.length + ' function mappings.' );
+}
+
+
+
+// MAIN //
+
+console.log( 'Generating addon.c for stdlib abs function...' );
+
+// Create template if it doesn't exist, then generate the addon.c file
+try {
+	generateAddonC();
+} catch ( error ) {
+	if ( error.code === 'ENOENT' ) {
+		console.log( 'Template file not found. Creating template...' );
+		createTemplate();
+		generateAddonC();
+	} else {
+		throw error;
+	}
+}