From 3ee06ac9c0fe0ea74ac65f067a68e3b1571c6717 Mon Sep 17 00:00:00 2001 From: BorysLevytskyi Date: Mon, 8 May 2023 17:27:38 +0200 Subject: [PATCH] Rename NumberType to JsNumber --- src/core/calc.ts | 14 +++++++------- src/core/formatter.ts | 8 ++++---- src/core/types.ts | 2 +- src/core/utils.tsx | 4 ++-- src/expression/ScalarValue.ts | 10 +++++----- src/expression/engine.ts | 16 ++++++++-------- src/expression/numberParser.ts | 8 ++++---- 7 files changed, 31 insertions(+), 31 deletions(-) diff --git a/src/core/calc.ts b/src/core/calc.ts index 16f3903..c945f9b 100644 --- a/src/core/calc.ts +++ b/src/core/calc.ts @@ -1,19 +1,19 @@ import { type } from "os"; import { Expression } from "../expression/expression-interfaces"; import formatter from "./formatter"; -import { NumberType } from "./types"; +import { JsNumber } from "./types"; import { asIntN } from "./utils"; export default { - abs (num : NumberType) : NumberType { + abs (num : JsNumber) : JsNumber { return num >= 0 ? num : -num; }, - maxBitSize(num : NumberType) : number { + maxBitSize(num : JsNumber) : number { return typeof num == "bigint" ? 64 : 32; }, - numberOfBitsDisplayed: function (num: NumberType) : number { + numberOfBitsDisplayed: function (num: JsNumber) : number { if(num < 0) { return typeof num == 'bigint' ? 64 : 32 @@ -33,7 +33,7 @@ export default { return Math.max.apply(null, counts); }, - flipBit: function(num: NumberType, index: number): NumberType { + flipBit: function(num: JsNumber, index: number): JsNumber { const is64bit = typeof num == 'bigint'; const size = typeof num == "bigint" ? 64 : 32; @@ -80,7 +80,7 @@ export default { return bin.split('').map(b => b=="1"?"0":"1").join(""); }, - binaryRepresentation(num : NumberType, bitSize?: number) : string { + binaryRepresentation(num : JsNumber, bitSize?: number) : string { bitSize = bitSize || typeof num == "bigint" ? 64 : 32; const bin = this.abs(num).toString(2); @@ -93,7 +93,7 @@ export default { : bin; }, - rshift (num: NumberType, numBytes : NumberType, bitSize: number) : NumberType { + rshift (num: JsNumber, numBytes : JsNumber, bitSize: number) : JsNumber { const bytes = asIntN(numBytes); diff --git a/src/core/formatter.ts b/src/core/formatter.ts index 8c138f5..d1ebfde 100644 --- a/src/core/formatter.ts +++ b/src/core/formatter.ts @@ -1,9 +1,9 @@ import calc from "./calc"; -import { NumberType } from "./types"; +import { JsNumber } from "./types"; export type NumberBase = 'dec' | 'hex' | 'bin'; const formatter = { - numberToString: function(num: NumberType, base: NumberBase) : string { + numberToString: function(num: JsNumber, base: NumberBase) : string { switch(base) { case 'hex': @@ -30,10 +30,10 @@ const formatter = { return sb.join(''); }, - bin(number: NumberType) { + bin(number: JsNumber) { return this.numberToString(number, 'bin'); }, - emBin(number: NumberType) { + emBin(number: JsNumber) { return this.padLeft(this.bin(number), 8, '0'); }, diff --git a/src/core/types.ts b/src/core/types.ts index 8abfb79..4073784 100644 --- a/src/core/types.ts +++ b/src/core/types.ts @@ -1 +1 @@ -export type NumberType = number | bigint; \ No newline at end of file +export type JsNumber = number | bigint; \ No newline at end of file diff --git a/src/core/utils.tsx b/src/core/utils.tsx index cdf69ca..ab58064 100644 --- a/src/core/utils.tsx +++ b/src/core/utils.tsx @@ -1,4 +1,4 @@ -import { NumberType } from "./types"; +import { JsNumber } from "./types"; function chunkifyString(input: string, chunkSize: number) : string[] { @@ -11,7 +11,7 @@ function chunkifyString(input: string, chunkSize: number) : string[] { return result; } -function asIntN(num: NumberType) : number { +function asIntN(num: JsNumber) : number { return typeof num == "bigint" ? parseInt(num.toString()): num as number; } diff --git a/src/expression/ScalarValue.ts b/src/expression/ScalarValue.ts index c765864..2b3a269 100644 --- a/src/expression/ScalarValue.ts +++ b/src/expression/ScalarValue.ts @@ -2,7 +2,7 @@ import {numberParser} from './numberParser'; import { ExpressionElement as ExpressionElement } from './expression-interfaces'; import { NumberBase } from '../core/formatter'; import { INT32_MAX_VALUE, INT32_MIN_VALUE, INT64_MAX_VALUE, INT64_MIN_VALUE } from '../core/const'; -import { NumberType } from '../core/types'; +import { JsNumber } from '../core/types'; var globalId : number = 1; @@ -10,11 +10,11 @@ var globalId : number = 1; // Represents scalar numeric value export default class ScalarValue implements ExpressionElement { id: number; - value: NumberType; + value: JsNumber; base: NumberBase; isOperator: boolean; - constructor(value : NumberType, base?: NumberBase, is32Limit?: boolean) { + constructor(value : JsNumber, base?: NumberBase, is32Limit?: boolean) { ScalarValue.validateSupported(value); @@ -32,7 +32,7 @@ export default class ScalarValue implements ExpressionElement { return typeof this.value === 'bigint'; } - setValue(value : NumberType) { + setValue(value : JsNumber) { this.value = value; } @@ -44,7 +44,7 @@ export default class ScalarValue implements ExpressionElement { return this } - static validateSupported(num : NumberType) { + static validateSupported(num : JsNumber) { if(typeof num == "bigint" && (num < INT64_MIN_VALUE || num > INT64_MAX_VALUE)) { throw new Error(`64-bit numbers are supported in range from ${INT64_MIN_VALUE} to ${INT64_MAX_VALUE}`); diff --git a/src/expression/engine.ts b/src/expression/engine.ts index 2a2c718..7915b49 100644 --- a/src/expression/engine.ts +++ b/src/expression/engine.ts @@ -1,5 +1,5 @@ import calc from "../core/calc"; -import { NumberType } from "../core/types"; +import { JsNumber } from "../core/types"; import ScalarValue from "./ScalarValue"; const engine = { @@ -14,22 +14,22 @@ const engine = { } }; -function evalute(op1 : NumberType, operator: string, op2 : NumberType) : NumberType{ +function evalute(op1 : JsNumber, operator: string, op2 : JsNumber) : JsNumber{ const a = equalizeType(op2, op1) as any; const b = equalizeType(op1, op2) as any; switch(operator) { - case ">>": return (a >> b) as (NumberType); - case ">>>": return (a >>> b) as (NumberType); + case ">>": return (a >> b) as (JsNumber); + case ">>>": return (a >>> b) as (JsNumber); case "<<": return calc.rshift(a, b, calc.maxBitSize(a)); - case "&": return (b & a) as (NumberType); - case "|": return (b | a) as (NumberType); - case "^": return (b ^ a) as (NumberType); + case "&": return (b & a) as (JsNumber); + case "|": return (b | a) as (JsNumber); + case "^": return (b ^ a) as (JsNumber); default: throw new Error(operator + " operator is not supported"); } } -function equalizeType(source : NumberType, dest : NumberType) : NumberType { +function equalizeType(source : JsNumber, dest : JsNumber) : JsNumber { return typeof source == 'bigint' && typeof dest != 'bigint' ? BigInt(dest) diff --git a/src/expression/numberParser.ts b/src/expression/numberParser.ts index d0b6d41..f65dbdc 100644 --- a/src/expression/numberParser.ts +++ b/src/expression/numberParser.ts @@ -1,6 +1,6 @@ import { INT32_MAX_VALUE, INT32_MIN_VALUE } from "../core/const"; import { NumberBase } from "../core/formatter"; -import { NumberType } from "../core/types"; +import { JsNumber } from "../core/types"; const decimalRegex = /^-?\d+[l,L]?$/; const hexRegex = /^-?0x[0-9,a-f]+[l,L]?$/i; @@ -9,11 +9,11 @@ const binRegex = /^-?0b[0-1]+[l,L]?$/i; interface ParserConfig { regex: RegExp, base: NumberBase, - parse: (input: string) => NumberType + parse: (input: string) => JsNumber } export interface ParsedNumber { - value: NumberType; + value: JsNumber; base: NumberBase; input: string; } @@ -66,7 +66,7 @@ class NumberParser { const MAX_SAFE_INTn = BigInt(INT32_MAX_VALUE); const MIN_SAFE_INTn = BigInt(INT32_MIN_VALUE); -function parseIntSafe(input : string, radix: number) : NumberType { +function parseIntSafe(input : string, radix: number) : JsNumber { const bigIntStr = input.replace('-', '').replace('l', '').replace('L', ''); let bigInt = BigInt(bigIntStr);