Skip to content

V
V8
Commit f088840a authored by Daniel Clifford's avatar Daniel Clifford Committed by Commit Bot
Browse files
Options

[torque] Improve formatting in format-torque 

Issues/problems addressed:

- Fix line-wrapping and indenting for long declarations including strings,
  e.g. generates and constexpr clauses.
- Implement proper formatting for typeswitch statements
- Fix formatting of operator declarations
- Fix formatting of constexpr if-clauses (the constexpr is now included on the
  same line as the if and it doesn't mess up the formatting that
- Fix formatting of label declarations on callables, the "label" keyword now
  always starts a new line with indentation.
- Remove space after identifier name in generic parameter declarations, e.g.
  "<a : T>" is now "<a: T>" which is consistent with type specification
  formatting elsewhere.
- Indent "otherwise" clauses that have been pushed to the next line.

Also ran the formatter over all existing .tq files.

Bug: v8:7793
Change-Id: I5adbb2ffa3d573deed062f9a5c1da57348c8fc71
Reviewed-on: https://chromium-review.googlesource.com/1238580
Commit-Queue: Daniel Clifford <danno@chromium.org>
Reviewed-by: 's avatarTobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#56158}
parent c0f871a1
Show whitespace changes
Inline Side-by-side
Showing with 621 additions and 639 deletions
src/builtins/array-foreach.tq
View file @ f088840a
......@@ -72,10 +72,10 @@ module array {
}
}
macro VisitAllElements<FixedArrayType : type>(
macro VisitAllElements<FixedArrayType: type>(
context: Context, a: JSArray, len: Smi, callbackfn: Callable,
thisArg: Object): void labels
Bailout(Smi) {
thisArg: Object): void
labels Bailout(Smi) {
let k: Smi = 0;
const map: Map = a.map;
......@@ -108,8 +108,8 @@ module array {
macro FastArrayForEach(
context: Context, o: JSReceiver, len: Number, callbackfn: Callable,
thisArg: Object): Object labels
Bailout(Smi) {
thisArg: Object): Object
labels Bailout(Smi) {
let k: Smi = 0;
try {
const smiLen: Smi = Cast<Smi>(len) otherwise Slow;
......
src/builtins/array-lastindexof.tq
View file @ f088840a
......@@ -3,7 +3,7 @@
// found in the LICENSE file.
module array {
macro LoadWithHoleCheck<Elements : type>(
macro LoadWithHoleCheck<Elements: type>(
elements: FixedArrayBase, index: Smi): Object
labels IfHole;
......@@ -15,8 +15,8 @@ module array {
return element;
}
LoadWithHoleCheck<FixedDoubleArray>(
elements: FixedArrayBase, index: Smi): Object
LoadWithHoleCheck<FixedDoubleArray>(elements: FixedArrayBase, index: Smi):
Object
labels IfHole {
const elements: FixedDoubleArray = UnsafeCast<FixedDoubleArray>(elements);
const element: float64 = LoadDoubleWithHoleCheck(elements, index)
......@@ -24,7 +24,7 @@ module array {
return AllocateHeapNumberWithValue(element);
}
macro FastArrayLastIndexOf<Elements : type>(
macro FastArrayLastIndexOf<Elements: type>(
context: Context, array: JSArray, length: Smi, from: Smi,
searchElement: Object): Smi {
const elements: FixedArrayBase = array.elements;
......
src/builtins/array-reverse.tq
View file @ f088840a
......@@ -3,7 +3,7 @@
// found in the LICENSE file.
module array {
macro LoadElement<ElementsAccessor : type, T : type>(
macro LoadElement<ElementsAccessor: type, T: type>(
elements: FixedArrayBase, index: Smi): T;
LoadElement<FastPackedSmiElements, Smi>(
......@@ -31,7 +31,7 @@ module array {
}
}
macro StoreElement<ElementsAccessor : type, T : type>(
macro StoreElement<ElementsAccessor: type, T: type>(
elements: FixedArrayBase, index: Smi, value: T);
StoreElement<FastPackedSmiElements, Smi>(
......@@ -57,7 +57,7 @@ module array {
// Fast-path for all PACKED_* elements kinds. These do not need to check
// whether a property is present, so we can simply swap them using fast
// FixedArray loads/stores.
macro FastPackedArrayReverse<Accessor : type, T : type>(
macro FastPackedArrayReverse<Accessor: type, T: type>(
elements: FixedArrayBase, length: Smi) {
let lower: Smi = 0;
let upper: Smi = length - 1;
......
src/builtins/array-splice.tq
View file @ f088840a
......@@ -7,7 +7,7 @@ module array {
// FixedArrayType. Most of this behavior is outsourced to ExtractFixedArray(),
// but the special case of wanting to have a FixedDoubleArray when given a
// zero-length input FixedArray is handled here.
macro Extract<FixedArrayType : type>(
macro Extract<FixedArrayType: type>(
elements: FixedArrayBase, first: Smi, count: Smi,
capacity: Smi): FixedArrayType {
return UnsafeCast<FixedArrayType>(
......@@ -24,10 +24,11 @@ module array {
ExtractFixedArray(elements, first, count, capacity));
}
macro FastSplice<FixedArrayType : type, ElementType : type>(
macro FastSplice<FixedArrayType: type, ElementType: type>(
args: constexpr Arguments, a: JSArray, length: Smi, newLength: Smi,
lengthDelta: Smi, actualStart: Smi, insertCount: Smi,
actualDeleteCount: Smi): void labels Bailout {
actualDeleteCount: Smi): void
labels Bailout {
const elements: FixedArrayBase = a.elements;
const elementsMap: Map = elements.map;
......
src/builtins/array-unshift.tq
View file @ f088840a
......@@ -6,7 +6,8 @@ module array {
extern builtin ArrayUnshift(Context, JSFunction, Object, int32);
macro TryFastArrayUnshift(
context: Context, receiver: Object, arguments: constexpr Arguments): never
context: Context, receiver: Object, arguments: constexpr Arguments):
never
labels Slow {
EnsureFastJSArray(context, receiver) otherwise Slow;
const array: JSArray = UnsafeCast<JSArray>(receiver);
......
src/builtins/array.tq
View file @ f088840a
......@@ -35,8 +35,8 @@ module array {
assert(IsFastSmiOrTaggedElementsKind(array.map.elements_kind));
const length: Smi = array.length_fast;
array.elements = ExtractFixedArray(
elements, 0, length, length, kFixedArrays);
array.elements =
ExtractFixedArray(elements, 0, length, length, kFixedArrays);
assert(array.elements.map != kCOWMap);
}
......
src/builtins/base.tq
View file @ f088840a
......@@ -42,27 +42,31 @@ type Callable = JSFunction|JSBoundFunction|JSProxy;
type Map extends HeapObject generates 'TNode<Map>';
type FixedArrayBase extends HeapObject generates 'TNode<FixedArrayBase>';
type FixedArray extends FixedArrayBase generates 'TNode<FixedArray>';
type FixedDoubleArray extends FixedArrayBase generates
'TNode<FixedDoubleArray>';
type FixedTypedArrayBase extends FixedArrayBase generates
'TNode<FixedTypedArrayBase>';
type FixedTypedArray extends FixedTypedArrayBase generates
'TNode<FixedTypedArray>';
type NumberDictionary extends HeapObject generates 'TNode<NumberDictionary>';
type FixedDoubleArray extends FixedArrayBase
generates 'TNode<FixedDoubleArray>';
type FixedTypedArrayBase extends FixedArrayBase
generates 'TNode<FixedTypedArrayBase>';
type FixedTypedArray extends FixedTypedArrayBase
generates 'TNode<FixedTypedArray>';
type NumberDictionary extends HeapObject
generates 'TNode<NumberDictionary>';
type JSArrayBuffer extends JSObject generates 'TNode<JSArrayBuffer>';
type JSArrayBufferView extends JSObject generates 'TNode<JSArrayBufferView>';
type JSTypedArray extends JSArrayBufferView generates 'TNode<JSTypedArray>';
type JSArrayBufferView extends JSObject
generates 'TNode<JSArrayBufferView>';
type JSTypedArray extends JSArrayBufferView
generates 'TNode<JSTypedArray>';
type JSDataView extends JSArrayBufferView generates 'TNode<JSDataView>';
type InstanceType generates 'TNode<Int32T>' constexpr 'InstanceType';
type ElementsKind generates 'TNode<Int32T>' constexpr 'ElementsKind';
type LanguageMode generates 'TNode<Smi>' constexpr 'LanguageMode';
type ExtractFixedArrayFlags generates
'TNode<Smi>' constexpr 'ExtractFixedArrayFlags';
type ExtractFixedArrayFlags
generates 'TNode<Smi>' constexpr 'ExtractFixedArrayFlags';
type ParameterMode generates 'TNode<Int32T>' constexpr 'ParameterMode';
type RootIndex generates 'TNode<Int32T>' constexpr 'RootIndex';
type WriteBarrierMode generates 'TNode<Int32T>' constexpr 'WriteBarrierMode';
type WriteBarrierMode
generates 'TNode<Int32T>' constexpr 'WriteBarrierMode';
type MessageTemplate constexpr 'MessageTemplate::Template';
......@@ -70,17 +74,18 @@ type ToIntegerTruncationMode constexpr 'ToIntegerTruncationMode';
const NO_ELEMENTS: constexpr ElementsKind generates 'NO_ELEMENTS';
const PACKED_SMI_ELEMENTS: constexpr ElementsKind generates
'PACKED_SMI_ELEMENTS';
const HOLEY_SMI_ELEMENTS: constexpr ElementsKind generates 'HOLEY_SMI_ELEMENTS';
const PACKED_SMI_ELEMENTS:
constexpr ElementsKind generates 'PACKED_SMI_ELEMENTS';
const HOLEY_SMI_ELEMENTS:
constexpr ElementsKind generates 'HOLEY_SMI_ELEMENTS';
const PACKED_ELEMENTS: constexpr ElementsKind generates 'PACKED_ELEMENTS';
const HOLEY_ELEMENTS: constexpr ElementsKind generates 'HOLEY_ELEMENTS';
const PACKED_DOUBLE_ELEMENTS: constexpr ElementsKind generates
'PACKED_DOUBLE_ELEMENTS';
const HOLEY_DOUBLE_ELEMENTS: constexpr ElementsKind generates
'HOLEY_DOUBLE_ELEMENTS';
const DICTIONARY_ELEMENTS: constexpr ElementsKind generates
'DICTIONARY_ELEMENTS';
const PACKED_DOUBLE_ELEMENTS:
constexpr ElementsKind generates 'PACKED_DOUBLE_ELEMENTS';
const HOLEY_DOUBLE_ELEMENTS:
constexpr ElementsKind generates 'HOLEY_DOUBLE_ELEMENTS';
const DICTIONARY_ELEMENTS:
constexpr ElementsKind generates 'DICTIONARY_ELEMENTS';
const UINT8_ELEMENTS: constexpr ElementsKind generates 'UINT8_ELEMENTS';
const INT8_ELEMENTS: constexpr ElementsKind generates 'INT8_ELEMENTS';
......@@ -90,10 +95,12 @@ const UINT32_ELEMENTS: constexpr ElementsKind generates 'UINT32_ELEMENTS';
const INT32_ELEMENTS: constexpr ElementsKind generates 'INT32_ELEMENTS';
const FLOAT32_ELEMENTS: constexpr ElementsKind generates 'FLOAT32_ELEMENTS';
const FLOAT64_ELEMENTS: constexpr ElementsKind generates 'FLOAT64_ELEMENTS';
const UINT8_CLAMPED_ELEMENTS: constexpr ElementsKind generates
'UINT8_CLAMPED_ELEMENTS';
const BIGUINT64_ELEMENTS: constexpr ElementsKind generates 'BIGUINT64_ELEMENTS';
const BIGINT64_ELEMENTS: constexpr ElementsKind generates 'BIGINT64_ELEMENTS';
const UINT8_CLAMPED_ELEMENTS:
constexpr ElementsKind generates 'UINT8_CLAMPED_ELEMENTS';
const BIGUINT64_ELEMENTS:
constexpr ElementsKind generates 'BIGUINT64_ELEMENTS';
const BIGINT64_ELEMENTS:
constexpr ElementsKind generates 'BIGINT64_ELEMENTS';
type FixedUint8Array extends FixedTypedArray;
type FixedInt8Array extends FixedTypedArray;
......@@ -107,42 +114,42 @@ type FixedUint8ClampedArray extends FixedTypedArray;
type FixedBigUint64Array extends FixedTypedArray;
type FixedBigInt64Array extends FixedTypedArray;
const kFixedDoubleArrays: constexpr ExtractFixedArrayFlags generates
'ExtractFixedArrayFlag::kFixedDoubleArrays';
const kAllFixedArrays: constexpr ExtractFixedArrayFlags generates
'ExtractFixedArrayFlag::kAllFixedArrays';
const kFixedArrays: constexpr ExtractFixedArrayFlags generates
'ExtractFixedArrayFlag::kFixedArrays';
const kFixedCOWArrayMapRootIndex: constexpr RootIndex generates
'RootIndex::kFixedCOWArrayMap';
const kEmptyFixedArrayRootIndex: constexpr RootIndex generates
'RootIndex::kEmptyFixedArray';
const kInvalidArrayLength: constexpr MessageTemplate generates
'MessageTemplate::kInvalidArrayLength';
const kCalledNonCallable: constexpr MessageTemplate generates
'MessageTemplate::kCalledNonCallable';
const kCalledOnNullOrUndefined: constexpr MessageTemplate generates
'MessageTemplate::kCalledOnNullOrUndefined';
const kFixedDoubleArrays: constexpr ExtractFixedArrayFlags
generates 'ExtractFixedArrayFlag::kFixedDoubleArrays';
const kAllFixedArrays: constexpr ExtractFixedArrayFlags
generates 'ExtractFixedArrayFlag::kAllFixedArrays';
const kFixedArrays: constexpr ExtractFixedArrayFlags
generates 'ExtractFixedArrayFlag::kFixedArrays';
const kFixedCOWArrayMapRootIndex:
constexpr RootIndex generates 'RootIndex::kFixedCOWArrayMap';
const kEmptyFixedArrayRootIndex:
constexpr RootIndex generates 'RootIndex::kEmptyFixedArray';
const kInvalidArrayLength: constexpr MessageTemplate
generates 'MessageTemplate::kInvalidArrayLength';
const kCalledNonCallable: constexpr MessageTemplate
generates 'MessageTemplate::kCalledNonCallable';
const kCalledOnNullOrUndefined: constexpr MessageTemplate
generates 'MessageTemplate::kCalledOnNullOrUndefined';
const kMaxSafeInteger: constexpr float64 generates 'kMaxSafeInteger';
const kTruncateMinusZero: constexpr ToIntegerTruncationMode generates
'ToIntegerTruncationMode::kTruncateMinusZero';
const kNotTypedArray: constexpr MessageTemplate generates
'MessageTemplate::kNotTypedArray';
const kDetachedOperation: constexpr MessageTemplate generates
'MessageTemplate::kDetachedOperation';
const kBadSortComparisonFunction: constexpr MessageTemplate generates
'MessageTemplate::kBadSortComparisonFunction';
const kIncompatibleMethodReceiver: constexpr MessageTemplate generates
'MessageTemplate::kIncompatibleMethodReceiver';
const kInvalidDataViewAccessorOffset: constexpr MessageTemplate generates
'MessageTemplate::kInvalidDataViewAccessorOffset';
const kStrictReadOnlyProperty: constexpr MessageTemplate generates
'MessageTemplate::kStrictReadOnlyProperty';
const kTruncateMinusZero: constexpr ToIntegerTruncationMode
generates 'ToIntegerTruncationMode::kTruncateMinusZero';
const kNotTypedArray:
constexpr MessageTemplate generates 'MessageTemplate::kNotTypedArray';
const kDetachedOperation: constexpr MessageTemplate
generates 'MessageTemplate::kDetachedOperation';
const kBadSortComparisonFunction: constexpr MessageTemplate
generates 'MessageTemplate::kBadSortComparisonFunction';
const kIncompatibleMethodReceiver: constexpr MessageTemplate
generates 'MessageTemplate::kIncompatibleMethodReceiver';
const kInvalidDataViewAccessorOffset: constexpr MessageTemplate
generates 'MessageTemplate::kInvalidDataViewAccessorOffset';
const kStrictReadOnlyProperty: constexpr MessageTemplate
generates 'MessageTemplate::kStrictReadOnlyProperty';
extern macro TheHoleConstant(): Oddball;
extern macro NullConstant(): Oddball;
......@@ -167,10 +174,11 @@ const kStrict: constexpr LanguageMode generates 'LanguageMode::kStrict';
const kSloppy: constexpr LanguageMode generates 'LanguageMode::kSloppy';
const SMI_PARAMETERS: constexpr ParameterMode generates 'SMI_PARAMETERS';
const INTPTR_PARAMETERS: constexpr ParameterMode generates 'INTPTR_PARAMETERS';
const INTPTR_PARAMETERS:
constexpr ParameterMode generates 'INTPTR_PARAMETERS';
const SKIP_WRITE_BARRIER: constexpr WriteBarrierMode
generates 'SKIP_WRITE_BARRIER';
const SKIP_WRITE_BARRIER:
constexpr WriteBarrierMode generates 'SKIP_WRITE_BARRIER';
extern macro Is64(): constexpr bool;
......@@ -200,7 +208,8 @@ extern macro ThrowTypeError(
Context, constexpr MessageTemplate, Object, Object, Object): never;
extern macro ArraySpeciesCreate(Context, Object, Number): JSReceiver;
extern macro InternalArrayCreate(Context, Number): JSArray;
extern macro EnsureArrayPushable(Map): ElementsKind labels Bailout;
extern macro EnsureArrayPushable(Map): ElementsKind
labels Bailout;
extern macro EnsureArrayLengthWritable(Map) labels Bailout;
extern builtin ToObject(Context, Object): JSReceiver;
......@@ -263,20 +272,18 @@ extern operator '==' macro Float64Equal(float64, float64): bool;
extern operator '!=' macro Float64NotEqual(float64, float64): bool;
extern operator '>' macro Float64GreaterThan(float64, float64): bool;
extern operator
'==' macro BranchIfNumberEqual(Number, Number): never labels Taken, NotTaken;
extern operator
'<' macro BranchIfNumberLessThan(Number, Number): never labels Taken, NotTaken;
extern operator
'<=' macro BranchIfNumberLessThanOrEqual(Number, Number): never labels Taken,
NotTaken;
extern operator
'>' macro BranchIfNumberGreaterThan(Number, Number): never labels Taken,
NotTaken;
extern operator '==' macro BranchIfNumberEqual(Number, Number): never
labels Taken, NotTaken;
extern operator '<' macro BranchIfNumberLessThan(Number, Number): never
labels Taken, NotTaken;
extern operator '<=' macro BranchIfNumberLessThanOrEqual(Number, Number): never
labels Taken, NotTaken;
extern operator '>' macro BranchIfNumberGreaterThan(Number, Number): never
labels Taken, NotTaken;
extern operator '>=' macro BranchIfNumberGreaterThanOrEqual(Number, Number):
never labels Taken,
NotTaken;
never
labels Taken, NotTaken;
extern operator '==' macro WordEqual(Object, Object): bool;
extern operator '!=' macro WordNotEqual(Object, Object): bool;
......@@ -337,64 +344,81 @@ extern operator '!' macro IsFalse(Boolean): bool;
extern operator '.map' macro LoadMap(HeapObject): Map;
extern operator '.map=' macro StoreMap(HeapObject, Map);
extern operator
'.instanceType' macro LoadInstanceType(HeapObject): InstanceType;
extern operator '.instanceType' macro LoadInstanceType(HeapObject):
InstanceType;
extern operator '.length' macro LoadStringLengthAsWord(String): intptr;
extern operator '.length' macro GetArgumentsLength(constexpr Arguments): intptr;
extern operator
'[]' macro GetArgumentValue(constexpr Arguments, intptr): Object;
extern operator '[]' macro GetArgumentValue(
constexpr Arguments, intptr): Object;
extern macro TaggedIsSmi(Object): bool;
extern macro TaggedIsNotSmi(Object): bool;
extern macro TaggedIsPositiveSmi(Object): bool;
extern macro HeapObjectToJSDataView(HeapObject): JSDataView labels CastError;
extern macro TaggedToHeapObject(Object): HeapObject labels CastError;
extern macro TaggedToSmi(Object): Smi labels CastError;
extern macro HeapObjectToJSArray(HeapObject): JSArray labels CastError;
extern macro HeapObjectToCallable(HeapObject): Callable labels CastError;
extern macro HeapObjectToFixedArray(HeapObject): FixedArray labels CastError;
extern macro HeapObjectToFixedDoubleArray(HeapObject):
FixedDoubleArray labels CastError;
extern macro TaggedToNumber(Object): Number labels CastError;
macro CastHeapObject<A : type>(o: HeapObject): A labels CastError;
CastHeapObject<HeapObject>(o: HeapObject): HeapObject labels CastError {
extern macro HeapObjectToJSDataView(HeapObject): JSDataView
labels CastError;
extern macro TaggedToHeapObject(Object): HeapObject
labels CastError;
extern macro TaggedToSmi(Object): Smi
labels CastError;
extern macro HeapObjectToJSArray(HeapObject): JSArray
labels CastError;
extern macro HeapObjectToCallable(HeapObject): Callable
labels CastError;
extern macro HeapObjectToFixedArray(HeapObject): FixedArray
labels CastError;
extern macro HeapObjectToFixedDoubleArray(HeapObject): FixedDoubleArray
labels CastError;
extern macro TaggedToNumber(Object): Number
labels CastError;
macro CastHeapObject<A: type>(o: HeapObject): A
labels CastError;
CastHeapObject<HeapObject>(o: HeapObject): HeapObject
labels CastError {
return o;
}
CastHeapObject<FixedArray>(o: HeapObject): FixedArray labels CastError {
CastHeapObject<FixedArray>(o: HeapObject): FixedArray
labels CastError {
return HeapObjectToFixedArray(o) otherwise CastError;
}
CastHeapObject<FixedDoubleArray>(o: HeapObject):
FixedDoubleArray labels CastError {
CastHeapObject<FixedDoubleArray>(o: HeapObject): FixedDoubleArray
labels CastError {
return HeapObjectToFixedDoubleArray(o) otherwise CastError;
}
CastHeapObject<JSDataView>(o: HeapObject): JSDataView labels CastError {
CastHeapObject<JSDataView>(o: HeapObject): JSDataView
labels CastError {
return HeapObjectToJSDataView(o) otherwise CastError;
}
CastHeapObject<Callable>(o: HeapObject): Callable labels CastError {
CastHeapObject<Callable>(o: HeapObject): Callable
labels CastError {
return HeapObjectToCallable(o) otherwise CastError;
}
CastHeapObject<JSArray>(o: HeapObject): JSArray labels CastError {
CastHeapObject<JSArray>(o: HeapObject): JSArray
labels CastError {
return HeapObjectToJSArray(o) otherwise CastError;
}
macro Cast<A : type>(o: HeapObject): A labels CastError {
macro Cast<A: type>(o: HeapObject): A
labels CastError {
return CastHeapObject<A>(o) otherwise CastError;
}
// CastHeapObject allows this default-implementation to be non-recursive.
// Otherwise the generated CSA code might run into infinite recursion.
macro Cast<A : type>(o: Object): A labels CastError {
macro Cast<A: type>(o: Object): A
labels CastError {
return CastHeapObject<A>(TaggedToHeapObject(o) otherwise CastError)
otherwise CastError;
}
Cast<Smi>(o: Object): Smi labels CastError {
Cast<Smi>(o: Object): Smi
labels CastError {
return TaggedToSmi(o) otherwise CastError;
}
Cast<Number>(o: Object): Number labels CastError {
Cast<Number>(o: Object): Number
labels CastError {
return TaggedToNumber(o) otherwise CastError;
}
......@@ -435,7 +459,7 @@ extern macro StringConstant(constexpr string): String;
extern macro LanguageModeConstant(constexpr LanguageMode): LanguageMode;
extern macro Int32Constant(constexpr ElementsKind): ElementsKind;
macro FromConstexpr<A : type>(o: constexpr int31): A;
macro FromConstexpr<A: type>(o: constexpr int31): A;
FromConstexpr<intptr>(i: constexpr int31): intptr {
return IntPtrConstant(i);
}
......@@ -460,7 +484,7 @@ FromConstexpr<Number>(i: constexpr int31): Number {
FromConstexpr<float64>(i: constexpr int31): float64 {
return Float64Constant(i);
}
macro FromConstexpr<A : type>(o: constexpr int32): A;
macro FromConstexpr<A: type>(o: constexpr int32): A;
FromConstexpr<intptr>(i: constexpr int32): intptr {
return IntPtrConstant(i);
}
......@@ -470,23 +494,23 @@ FromConstexpr<int32>(i: constexpr int32): int32 {
FromConstexpr<Number>(i: constexpr int32): Number {
return NumberConstant(i);
}
macro FromConstexpr<A : type>(o: constexpr float64): A;
macro FromConstexpr<A: type>(o: constexpr float64): A;
FromConstexpr<Number>(f: constexpr float64): Number {
return NumberConstant(f);
}
macro FromConstexpr<A : type>(b: constexpr bool): A;
macro FromConstexpr<A: type>(b: constexpr bool): A;
FromConstexpr<bool>(b: constexpr bool): bool {
return BoolConstant(b);
}
macro FromConstexpr<A : type>(l: constexpr LanguageMode): A;
macro FromConstexpr<A: type>(l: constexpr LanguageMode): A;
FromConstexpr<LanguageMode>(b: constexpr LanguageMode): LanguageMode {
return LanguageModeConstant(b);
}
macro FromConstexpr<A : type>(e: constexpr ElementsKind): A;
macro FromConstexpr<A: type>(e: constexpr ElementsKind): A;
FromConstexpr<ElementsKind>(e: constexpr ElementsKind): ElementsKind {
return Int32Constant(e);
}
macro FromConstexpr<A : type>(s: constexpr string): A;
macro FromConstexpr<A: type>(s: constexpr string): A;
FromConstexpr<String>(s: constexpr string): String {
return StringConstant(s);
}
......@@ -494,17 +518,17 @@ FromConstexpr<Object>(s: constexpr string): Object {
return StringConstant(s);
}
macro Convert<A : type>(i: constexpr int31): A {
macro Convert<A: type>(i: constexpr int31): A {
return i;
}
extern macro ConvertElementsKindToInt(ElementsKind): int32;
macro Convert<A : type>(elementsKind: ElementsKind): A;
macro Convert<A: type>(elementsKind: ElementsKind): A;
Convert<int32>(elementsKind: ElementsKind): int32 {
return ConvertElementsKindToInt(elementsKind);
}
macro Convert<A : type>(i: int32): A;
macro Convert<A: type>(i: int32): A;
Convert<Number>(i: int32): Number {
return ChangeInt32ToTagged(i);
}
......@@ -514,7 +538,7 @@ Convert<intptr>(i: int32): intptr {
Convert<Smi>(i: int32): Smi {
return SmiFromInt32(i);
}
macro Convert<A : type>(ui: uint32): A;
macro Convert<A: type>(ui: uint32): A;
Convert<Number>(ui: uint32): Number {
return ChangeUint32ToTagged(ui);
}
......@@ -524,37 +548,37 @@ Convert<Smi>(ui: uint32): Smi {
Convert<uintptr>(ui: uint32): uintptr {
return ChangeUint32ToWord(ui);
}
macro Convert<A : type>(i: intptr): A;
macro Convert<A: type>(i: intptr): A;
Convert<int32>(i: intptr): int32 {
return TruncateIntPtrToInt32(i);
}
Convert<Smi>(i: intptr): Smi {
return SmiTag(i);
}
macro Convert<A : type>(ui: uintptr): A;
macro Convert<A: type>(ui: uintptr): A;
Convert<uint32>(ui: uintptr): uint32 {
return Unsigned(TruncateIntPtrToInt32(Signed(ui)));
}
macro Convert<A : type>(s: Smi): A;
macro Convert<A: type>(s: Smi): A;
Convert<intptr>(s: Smi): intptr {
return SmiUntag(s);
}
Convert<int32>(s: Smi): int32 {
return SmiToInt32(s);
}
macro Convert<A : type>(h: HeapNumber): A;
macro Convert<A: type>(h: HeapNumber): A;
Convert<float64>(h: HeapNumber): float64 {
return LoadHeapNumberValue(h);
}
macro Convert<A : type>(n: Number): A;
macro Convert<A: type>(n: Number): A;
Convert<float64>(n: Number): float64 {
return ChangeNumberToFloat64(n);
}
macro Convert<A : type>(f: float32): A;
macro Convert<A: type>(f: float32): A;
Convert<float64>(f: float32): float64 {
return ChangeFloat32ToFloat64(f);
}
macro Convert<A : type>(d: float64): A;
macro Convert<A: type>(d: float64): A;
Convert<Number>(d: float64): Number {
return AllocateHeapNumberWithValue(d);
}
......@@ -567,7 +591,7 @@ Convert<Number>(ui: uintptr): Number {
Convert<uintptr>(d: float64): uintptr {
return ChangeFloat64ToUintPtr(d);
}
macro Convert<A : type>(r: RawPtr): A;
macro Convert<A: type>(r: RawPtr): A;
Convert<uintptr>(r: RawPtr): uintptr {
return Unsigned(r);
}
......@@ -591,11 +615,11 @@ extern macro UnsafeCastObjectToJSReceiver(Object): JSReceiver;
extern macro UnsafeCastObjectToJSObject(Object): JSObject;
extern macro UnsafeCastObjectToMap(Object): Map;
macro UnsafeCast<A : type>(n: Number): A;
macro UnsafeCast<A: type>(n: Number): A;
UnsafeCast<HeapNumber>(n: Number): HeapNumber {
return UnsafeCastNumberToHeapNumber(n);
}
macro UnsafeCast<A : type>(o: Object): A;
macro UnsafeCast<A: type>(o: Object): A;
UnsafeCast<Object>(o: Object): Object {
return o;
}
......@@ -646,9 +670,10 @@ const kCOWMap: Map = UnsafeCast<Map>(LoadRoot(kFixedCOWArrayMapRootIndex));
const kEmptyFixedArray: FixedArrayBase =
UnsafeCast<FixedArrayBase>(LoadRoot(kEmptyFixedArrayRootIndex));
extern macro BranchIfFastJSArray(Object, Context): never labels Taken, NotTaken;
extern macro BranchIfNotFastJSArray(Object, Context): never labels Taken,
NotTaken;
extern macro BranchIfFastJSArray(Object, Context): never
labels Taken, NotTaken;
extern macro BranchIfNotFastJSArray(Object, Context): never
labels Taken, NotTaken;
macro EnsureFastJSArray(context: Context, object: Object) labels Bailout {
if (BranchIfNotFastJSArray(object, context)) goto Bailout;
......@@ -660,14 +685,14 @@ extern macro IsArraySpeciesProtectorCellInvalid(): bool;
extern macro IsTypedArraySpeciesProtectorCellInvalid(): bool;
extern macro IsPromiseSpeciesProtectorCellInvalid(): bool;
extern operator
'.buffer' macro LoadTypedArrayBuffer(JSTypedArray): JSArrayBuffer;
extern operator '.buffer' macro LoadTypedArrayBuffer(JSTypedArray):
JSArrayBuffer;
extern operator '.data_ptr' macro LoadDataPtr(JSTypedArray): RawPtr;
extern operator '.elements_kind' macro LoadMapElementsKind(Map): ElementsKind;
extern operator
'.elements_kind' macro LoadElementsKind(JSTypedArray): ElementsKind;
extern operator '.elements_kind' macro LoadElementsKind(JSTypedArray):
ElementsKind;
extern operator '.elements' macro LoadElements(JSObject): FixedArrayBase;
extern operator '.elements=' macro StoreElements(JSObject, FixedArrayBase);
......@@ -680,14 +705,14 @@ extern operator '.length=' macro StoreJSArrayLength(JSArray, Smi);
extern operator '.length' macro LoadFixedArrayBaseLength(FixedArrayBase): Smi;
extern operator '[]' macro LoadFixedArrayElement(FixedArray, intptr): Object;
extern operator '[]' macro LoadFixedArrayElement(FixedArray, Smi): Object;
extern operator
'[]' macro LoadFixedArrayElement(FixedArray, constexpr int31): Object;
extern operator
'[]=' macro StoreFixedArrayElement(FixedArray, intptr, Object): void;
extern operator
'[]=' macro StoreFixedArrayElement(FixedArray, constexpr int31, Object): void;
extern operator
'[]=' macro StoreFixedArrayElementSmi(FixedArray, Smi, Object): void;
extern operator '[]' macro LoadFixedArrayElement(
FixedArray, constexpr int31): Object;
extern operator '[]=' macro StoreFixedArrayElement(
FixedArray, intptr, Object): void;
extern operator '[]=' macro StoreFixedArrayElement(
FixedArray, constexpr int31, Object): void;
extern operator '[]=' macro StoreFixedArrayElementSmi(
FixedArray, Smi, Object): void;
operator '[]=' macro StoreFixedDoubleArrayNumber(
a: FixedDoubleArray, index: Smi, value: Number): void {
a[index] = Convert<float64>(value);
......@@ -708,9 +733,8 @@ macro StoreFixedDoubleArrayElementWithSmiIndex(
StoreFixedDoubleArrayElement(array, index, value, SMI_PARAMETERS);
}
extern macro BasicLoadNumberDictionaryElement(NumberDictionary, intptr):
Object labels NotData,
IfHole;
extern macro BasicLoadNumberDictionaryElement(NumberDictionary, intptr): Object
labels NotData, IfHole;
extern macro BasicStoreNumberDictionaryElement(NumberDictionary, intptr, Object)
labels NotData, IfHole, ReadOnly;
......@@ -757,12 +781,11 @@ extern macro AllocateJSArray(constexpr ElementsKind, Map, Smi, Smi): JSArray;
extern macro IsElementsKindGreaterThan(
ElementsKind, constexpr ElementsKind): bool;
extern operator
'[]=' macro StoreFixedDoubleArrayElementSmi(
extern operator '[]=' macro StoreFixedDoubleArrayElementSmi(
FixedDoubleArray, Smi, float64): void;
extern macro LoadDoubleWithHoleCheck(FixedDoubleArray, Smi): float64
labels IfHole;
labels IfHole;
extern macro StoreFixedDoubleArrayHoleSmi(FixedDoubleArray, Smi): void;
extern macro Call(Context, Callable, Object): Object;
......@@ -775,15 +798,17 @@ extern macro Call(
Context, Callable, Object, Object, Object, Object, Object, Object): Object;
extern macro ExtractFixedArray(FixedArrayBase, Smi, Smi, Smi): FixedArrayBase;
extern macro ExtractFixedArray(FixedArrayBase, Smi, Smi, Smi,
extern macro ExtractFixedArray(
FixedArrayBase, Smi, Smi, Smi,
constexpr ExtractFixedArrayFlags): FixedArrayBase;
extern builtin ExtractFastJSArray(Context, JSArray, Smi, Smi): JSArray;
macro LoadElementNoHole<T : type>(a: JSArray, index: Smi): Object labels IfHole;
macro LoadElementNoHole<T: type>(a: JSArray, index: Smi): Object
labels IfHole;
LoadElementNoHole<FixedArray>(a: JSArray, index: Smi): Object
labels IfHole {
labels IfHole {
try {
let elements: FixedArray =
Cast<FixedArray>(a.elements) otherwise Unexpected;
......@@ -799,7 +824,7 @@ labels IfHole {
}
LoadElementNoHole<FixedDoubleArray>(a: JSArray, index: Smi): Object
labels IfHole {
labels IfHole {
try {
let elements: FixedDoubleArray =
Cast<FixedDoubleArray>(a.elements) otherwise Unexpected;
......@@ -811,8 +836,9 @@ labels IfHole {
}
}
extern macro TransitionElementsKind(
JSObject, Map, ElementsKind, ElementsKind): void labels Bailout;
extern macro TransitionElementsKind(JSObject, Map, ElementsKind, ElementsKind):
void
labels Bailout;
extern macro IsCallable(HeapObject): bool;
extern macro IsJSArray(HeapObject): bool;
......@@ -830,17 +856,19 @@ extern macro LoadTargetFromFrame(): JSFunction;
// Return true iff number is NaN.
macro NumberIsNaN(number: Number): bool {
typeswitch(number) {
case (Smi) {
typeswitch (number) {
case (Smi): {
return false;
} case (hn : HeapNumber) {
}
case (hn: HeapNumber): {
let value: float64 = Convert<float64>(hn);
return value != value;
}
}
}
extern macro BranchIfToBooleanIsTrue(Object): never labels Taken, NotTaken;
extern macro BranchIfToBooleanIsTrue(Object): never
labels Taken, NotTaken;
macro ToBoolean(obj: Object): bool {
if (BranchIfToBooleanIsTrue(obj)) {
......@@ -850,7 +878,8 @@ macro ToBoolean(obj: Object): bool {
}
}
macro ToIndex(input: Object, context: Context): Number labels RangeError {
macro ToIndex(input: Object, context: Context): Number
labels RangeError {
if (input == Undefined) {
return 0;
}
......
src/builtins/data-view.tq
View file @ f088840a
......@@ -3,7 +3,6 @@
// found in the LICENSE file.
module data_view {
extern operator '.buffer'
macro LoadJSArrayBufferViewBuffer(JSArrayBufferView): JSArrayBuffer;
extern operator '.byte_length'
......@@ -69,8 +68,8 @@ module data_view {
return IsDetachedBuffer(view.buffer);
}
macro ValidateDataView(context: Context,
o: Object, method: String): JSDataView {
macro ValidateDataView(
context: Context, o: Object, method: String): JSDataView {
try {
return Cast<JSDataView>(o) otherwise CastError;
}
......@@ -82,8 +81,8 @@ module data_view {
// ES6 section 24.2.4.1 get DataView.prototype.buffer
javascript builtin DataViewPrototypeGetBuffer(
context: Context, receiver: Object, ...arguments): JSArrayBuffer {
let dataView: JSDataView = ValidateDataView(
context, receiver, 'get DataView.prototype.buffer');
let dataView: JSDataView =
ValidateDataView(context, receiver, 'get DataView.prototype.buffer');
return dataView.buffer;
}
......@@ -123,8 +122,8 @@ module data_view {
extern macro LoadUint8(RawPtr, uintptr): uint32;
extern macro LoadInt8(RawPtr, uintptr): int32;
macro LoadDataView8(buffer: JSArrayBuffer, offset: uintptr,
signed: constexpr bool): Smi {
macro LoadDataView8(
buffer: JSArrayBuffer, offset: uintptr, signed: constexpr bool): Smi {
if constexpr (signed) {
return Convert<Smi>(LoadInt8(buffer.backing_store, offset));
} else {
......@@ -132,8 +131,8 @@ module data_view {
}
}
macro LoadDataView16(buffer: JSArrayBuffer, offset: uintptr,
requestedLittleEndian: bool,
macro LoadDataView16(
buffer: JSArrayBuffer, offset: uintptr, requestedLittleEndian: bool,
signed: constexpr bool): Number {
let dataPointer: RawPtr = buffer.backing_store;
......@@ -159,8 +158,8 @@ module data_view {
}
}
macro LoadDataView32(buffer: JSArrayBuffer, offset: uintptr,
requestedLittleEndian: bool,
macro LoadDataView32(
buffer: JSArrayBuffer, offset: uintptr, requestedLittleEndian: bool,
kind: constexpr ElementsKind): Number {
let dataPointer: RawPtr = buffer.backing_store;
......@@ -188,7 +187,8 @@ module data_view {
}
}
macro LoadDataViewFloat64(buffer: JSArrayBuffer, offset: uintptr,
macro LoadDataViewFloat64(
buffer: JSArrayBuffer, offset: uintptr,
requestedLittleEndian: bool): Number {
let dataPointer: RawPtr = buffer.backing_store;
......@@ -221,8 +221,8 @@ module data_view {
extern macro AllocateBigInt(intptr): BigInt;
extern macro StoreBigIntBitfield(BigInt, intptr): void;
extern macro StoreBigIntDigit(BigInt, constexpr int31, uintptr): void;
extern macro DataViewEncodeBigIntBits(constexpr bool,
constexpr int31): intptr;
extern macro DataViewEncodeBigIntBits(
constexpr bool, constexpr int31): intptr;
const kPositiveBigInt: constexpr bool = false;
const kNegativeBigInt: constexpr bool = true;
......@@ -236,20 +236,19 @@ module data_view {
// Write the desired sign and length to the BigInt bitfield.
if (isPositive) {
StoreBigIntBitfield(result,
DataViewEncodeBigIntBits(kPositiveBigInt, length));
StoreBigIntBitfield(
result, DataViewEncodeBigIntBits(kPositiveBigInt, length));
} else {
StoreBigIntBitfield(result,
DataViewEncodeBigIntBits(kNegativeBigInt, length));
StoreBigIntBitfield(
result, DataViewEncodeBigIntBits(kNegativeBigInt, length));
}
return result;
}
// Create a BigInt on a 64-bit architecture from two 32-bit values.
macro MakeBigIntOn64Bit(lowWord: uint32, highWord: uint32,
signed: constexpr bool): BigInt {
macro MakeBigIntOn64Bit(
lowWord: uint32, highWord: uint32, signed: constexpr bool): BigInt {
// 0n is represented by a zero-length BigInt.
if (lowWord == 0 && highWord == 0) {
return AllocateBigInt(kZeroDigitBigInt);
......@@ -277,9 +276,8 @@ module data_view {
}
// Create a BigInt on a 32-bit architecture from two 32-bit values.
macro MakeBigIntOn32Bit(lowWord: uint32, highWord: uint32,
signed: constexpr bool): BigInt {
macro MakeBigIntOn32Bit(
lowWord: uint32, highWord: uint32, signed: constexpr bool): BigInt {
// 0n is represented by a zero-length BigInt.
if (lowWord == 0 && highWord == 0) {
return AllocateBigInt(kZeroDigitBigInt);
......@@ -299,7 +297,6 @@ module data_view {
// Otherwise, all cases are possible.
if (highWord != 0) {
if constexpr (signed) {
// If highPart < 0, the number is always negative.
if (highPart < 0) {
isPositive = false;
......@@ -348,8 +345,8 @@ module data_view {
return result;
}
macro MakeBigInt(lowWord: uint32, highWord: uint32,
signed: constexpr bool): BigInt {
macro MakeBigInt(
lowWord: uint32, highWord: uint32, signed: constexpr bool): BigInt {
// A BigInt digit has the platform word size, so we only need one digit
// on 64-bit platforms but may need two on 32-bit.
if constexpr (Is64()) {
......@@ -359,8 +356,8 @@ module data_view {
}
}
macro LoadDataViewBigInt(buffer: JSArrayBuffer, offset: uintptr,
requestedLittleEndian: bool,
macro LoadDataViewBigInt(
buffer: JSArrayBuffer, offset: uintptr, requestedLittleEndian: bool,
signed: constexpr bool): BigInt {
let dataPointer: RawPtr = buffer.backing_store;
......@@ -386,17 +383,15 @@ module data_view {
return MakeBigInt(lowWord, highWord, signed);
}
extern macro ToSmiIndex(Object, Context): Smi labels RangeError;
extern macro ToSmiIndex(Object, Context): Smi
labels RangeError;
extern macro DataViewElementSize(constexpr ElementsKind): constexpr int31;
macro DataViewGet(context: Context,
receiver: Object,
offset: Object,
requestedLittleEndian: Object,
kind: constexpr ElementsKind): Numeric {
let dataView: JSDataView = ValidateDataView(
context, receiver, MakeDataViewGetterNameString(kind));
macro DataViewGet(
context: Context, receiver: Object, offset: Object,
requestedLittleEndian: Object, kind: constexpr ElementsKind): Numeric {
let dataView: JSDataView =
ValidateDataView(context, receiver, MakeDataViewGetterNameString(kind));
let getIndex: Number;
try {
......@@ -410,8 +405,8 @@ module data_view {
let buffer: JSArrayBuffer = dataView.buffer;
if (IsDetachedBuffer(buffer)) {
ThrowTypeError(context, kDetachedOperation,
MakeDataViewGetterNameString(kind));
ThrowTypeError(
context, kDetachedOperation, MakeDataViewGetterNameString(kind));
}
let getIndexFloat: float64 = Convert<float64>(getIndex);
......@@ -454,114 +449,86 @@ module data_view {
javascript builtin DataViewPrototypeGetUint8(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
return DataViewGet(context, receiver, offset, Undefined, UINT8_ELEMENTS);
}
javascript builtin DataViewPrototypeGetInt8(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
return DataViewGet(context, receiver, offset, Undefined, INT8_ELEMENTS);
}
javascript builtin DataViewPrototypeGetUint16(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let isLittleEndian : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
return DataViewGet(context, receiver, offset, isLittleEndian,
UINT16_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let isLittleEndian: Object =
arguments.length > 1 ? arguments[1] : Undefined;
return DataViewGet(
context, receiver, offset, isLittleEndian, UINT16_ELEMENTS);
}
javascript builtin DataViewPrototypeGetInt16(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let isLittleEndian : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
return DataViewGet(context, receiver, offset, isLittleEndian,
INT16_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let isLittleEndian: Object =
arguments.length > 1 ? arguments[1] : Undefined;
return DataViewGet(
context, receiver, offset, isLittleEndian, INT16_ELEMENTS);
}
javascript builtin DataViewPrototypeGetUint32(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let isLittleEndian : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
return DataViewGet(context, receiver, offset, isLittleEndian,
UINT32_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let isLittleEndian: Object =
arguments.length > 1 ? arguments[1] : Undefined;
return DataViewGet(
context, receiver, offset, isLittleEndian, UINT32_ELEMENTS);
}
javascript builtin DataViewPrototypeGetInt32(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let isLittleEndian : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
return DataViewGet(context, receiver, offset, isLittleEndian,
INT32_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let isLittleEndian: Object =
arguments.length > 1 ? arguments[1] : Undefined;
return DataViewGet(
context, receiver, offset, isLittleEndian, INT32_ELEMENTS);
}
javascript builtin DataViewPrototypeGetFloat32(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let isLittleEndian : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
return DataViewGet(context, receiver, offset, isLittleEndian,
FLOAT32_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let isLittleEndian: Object =
arguments.length > 1 ? arguments[1] : Undefined;
return DataViewGet(
context, receiver, offset, isLittleEndian, FLOAT32_ELEMENTS);
}
javascript builtin DataViewPrototypeGetFloat64(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let isLittleEndian : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
return DataViewGet(context, receiver, offset, isLittleEndian,
FLOAT64_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let isLittleEndian: Object =
arguments.length > 1 ? arguments[1] : Undefined;
return DataViewGet(
context, receiver, offset, isLittleEndian, FLOAT64_ELEMENTS);
}
javascript builtin DataViewPrototypeGetBigUint64(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let isLittleEndian : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
return DataViewGet(context, receiver, offset, isLittleEndian,
BIGUINT64_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let isLittleEndian: Object =
arguments.length > 1 ? arguments[1] : Undefined;
return DataViewGet(
context, receiver, offset, isLittleEndian, BIGUINT64_ELEMENTS);
}
javascript builtin DataViewPrototypeGetBigInt64(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let isLittleEndian : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
return DataViewGet(context, receiver, offset, isLittleEndian,
BIGINT64_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let isLittleEndian: Object =
arguments.length > 1 ? arguments[1] : Undefined;
return DataViewGet(
context, receiver, offset, isLittleEndian, BIGINT64_ELEMENTS);
}
extern macro ToNumber(Context, Object): Number;
......@@ -571,12 +538,12 @@ module data_view {
extern macro StoreWord8(RawPtr, uintptr, uint32): void;
macro StoreDataView8(buffer: JSArrayBuffer, offset: uintptr,
value: uint32) {
macro StoreDataView8(buffer: JSArrayBuffer, offset: uintptr, value: uint32) {
StoreWord8(buffer.backing_store, offset, value & 0xFF);
}
macro StoreDataView16(buffer: JSArrayBuffer, offset: uintptr, value: uint32,
macro StoreDataView16(
buffer: JSArrayBuffer, offset: uintptr, value: uint32,
requestedLittleEndian: bool) {
let dataPointer: RawPtr = buffer.backing_store;
......@@ -592,7 +559,8 @@ module data_view {
}
}
macro StoreDataView32(buffer: JSArrayBuffer, offset: uintptr, value: uint32,
macro StoreDataView32(
buffer: JSArrayBuffer, offset: uintptr, value: uint32,
requestedLittleEndian: bool) {
let dataPointer: RawPtr = buffer.backing_store;
......@@ -614,8 +582,8 @@ module data_view {
}
}
macro StoreDataView64(buffer: JSArrayBuffer, offset: uintptr,
lowWord: uint32, highWord: uint32,
macro StoreDataView64(
buffer: JSArrayBuffer, offset: uintptr, lowWord: uint32, highWord: uint32,
requestedLittleEndian: bool) {
let dataPointer: RawPtr = buffer.backing_store;
......@@ -629,7 +597,6 @@ module data_view {
let b6: uint32 = (highWord >>> 16) & 0xFF;
let b7: uint32 = highWord >>> 24;
if (requestedLittleEndian) {
StoreWord8(dataPointer, offset, b0);
StoreWord8(dataPointer, offset + 1, b1);
......@@ -658,10 +625,9 @@ module data_view {
// We might get here a BigInt that is bigger than 64 bits, but we're only
// interested in the 64 lowest ones. This means the lowest BigInt digit
// on 64-bit platforms, and the 2 lowest BigInt digits on 32-bit ones.
macro StoreDataViewBigInt(buffer: JSArrayBuffer, offset: uintptr,
bigIntValue: BigInt,
macro StoreDataViewBigInt(
buffer: JSArrayBuffer, offset: uintptr, bigIntValue: BigInt,
requestedLittleEndian: bool) {
let length: uintptr = DataViewDecodeBigIntLength(bigIntValue);
let sign: uintptr = DataViewDecodeBigIntSign(bigIntValue);
......@@ -677,8 +643,7 @@ module data_view {
let value: uintptr = LoadBigIntDigit(bigIntValue, 0);
lowWord = Convert<uint32>(value); // Truncates value to 32 bits.
highWord = Convert<uint32>(value >>> 32);
}
else { // There might be either 1 or 2 BigInt digits we need to load.
} else { // There might be either 1 or 2 BigInt digits we need to load.
lowWord = Convert<uint32>(LoadBigIntDigit(bigIntValue, 0));
if (length >= 2) { // Only load the second digit if there is one.
highWord = Convert<uint32>(LoadBigIntDigit(bigIntValue, 1));
......@@ -694,19 +659,14 @@ module data_view {
lowWord = Unsigned(0 - Signed(lowWord));
}
StoreDataView64(buffer, offset, lowWord, highWord,
requestedLittleEndian);
StoreDataView64(buffer, offset, lowWord, highWord, requestedLittleEndian);
}
macro DataViewSet(context: Context,
receiver: Object,
offset: Object,
value: Object,
requestedLittleEndian: Object,
kind: constexpr ElementsKind): Object {
let dataView: JSDataView = ValidateDataView(
context, receiver, MakeDataViewSetterNameString(kind));
macro DataViewSet(
context: Context, receiver: Object, offset: Object, value: Object,
requestedLittleEndian: Object, kind: constexpr ElementsKind): Object {
let dataView: JSDataView =
ValidateDataView(context, receiver, MakeDataViewSetterNameString(kind));
let getIndex: Number;
try {
......@@ -730,8 +690,8 @@ module data_view {
}
if (IsDetachedBuffer(buffer)) {
ThrowTypeError(context, kDetachedOperation,
MakeDataViewSetterNameString(kind));
ThrowTypeError(
context, kDetachedOperation, MakeDataViewSetterNameString(kind));
}
let getIndexFloat: float64 = Convert<float64>(getIndex);
......@@ -748,34 +708,30 @@ module data_view {
let bufferIndex: uintptr = getIndexWord + viewOffsetWord;
if constexpr (kind == BIGUINT64_ELEMENTS || kind == BIGINT64_ELEMENTS) {
StoreDataViewBigInt(buffer, bufferIndex, bigIntValue,
littleEndian);
}
else {
StoreDataViewBigInt(buffer, bufferIndex, bigIntValue, littleEndian);
} else {
let doubleValue: float64 = ChangeNumberToFloat64(numValue);
if constexpr (kind == UINT8_ELEMENTS || kind == INT8_ELEMENTS) {
StoreDataView8(buffer, bufferIndex,
TruncateFloat64ToWord32(doubleValue));
}
else if constexpr (kind == UINT16_ELEMENTS || kind == INT16_ELEMENTS) {
StoreDataView16(buffer, bufferIndex,
TruncateFloat64ToWord32(doubleValue), littleEndian);
}
else if constexpr (kind == UINT32_ELEMENTS || kind == INT32_ELEMENTS) {
StoreDataView32(buffer, bufferIndex,
TruncateFloat64ToWord32(doubleValue), littleEndian);
}
else if constexpr (kind == FLOAT32_ELEMENTS) {
StoreDataView8(
buffer, bufferIndex, TruncateFloat64ToWord32(doubleValue));
} else if constexpr (kind == UINT16_ELEMENTS || kind == INT16_ELEMENTS) {
StoreDataView16(
buffer, bufferIndex, TruncateFloat64ToWord32(doubleValue),
littleEndian);
} else if constexpr (kind == UINT32_ELEMENTS || kind == INT32_ELEMENTS) {
StoreDataView32(
buffer, bufferIndex, TruncateFloat64ToWord32(doubleValue),
littleEndian);
} else if constexpr (kind == FLOAT32_ELEMENTS) {
let floatValue: float32 = TruncateFloat64ToFloat32(doubleValue);
StoreDataView32(buffer, bufferIndex,
BitcastFloat32ToInt32(floatValue), littleEndian);
}
else if constexpr (kind == FLOAT64_ELEMENTS) {
StoreDataView32(
buffer, bufferIndex, BitcastFloat32ToInt32(floatValue),
littleEndian);
} else if constexpr (kind == FLOAT64_ELEMENTS) {
let lowWord: uint32 = Float64ExtractLowWord32(doubleValue);
let highWord: uint32 = Float64ExtractHighWord32(doubleValue);
StoreDataView64(buffer, bufferIndex, lowWord, highWord,
littleEndian);
StoreDataView64(buffer, bufferIndex, lowWord, highWord, littleEndian);
}
}
return Undefined;
......@@ -783,146 +739,97 @@ module data_view {
javascript builtin DataViewPrototypeSetUint8(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let value : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
return DataViewSet(context, receiver, offset, value, Undefined,
UINT8_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
return DataViewSet(
context, receiver, offset, value, Undefined, UINT8_ELEMENTS);
}
javascript builtin DataViewPrototypeSetInt8(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let value : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
return DataViewSet(context, receiver, offset, value, Undefined,
INT8_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
return DataViewSet(
context, receiver, offset, value, Undefined, INT8_ELEMENTS);
}
javascript builtin DataViewPrototypeSetUint16(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let value : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
let isLittleEndian : Object = arguments.length > 2 ?
arguments[2] :
Undefined;
return DataViewSet(context, receiver, offset, value,
isLittleEndian, UINT16_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
let isLittleEndian: Object =
arguments.length > 2 ? arguments[2] : Undefined;
return DataViewSet(
context, receiver, offset, value, isLittleEndian, UINT16_ELEMENTS);
}
javascript builtin DataViewPrototypeSetInt16(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let value : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
let isLittleEndian : Object = arguments.length > 2 ?
arguments[2] :
Undefined;
return DataViewSet(context, receiver, offset, value,
isLittleEndian, INT16_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
let isLittleEndian: Object =
arguments.length > 2 ? arguments[2] : Undefined;
return DataViewSet(
context, receiver, offset, value, isLittleEndian, INT16_ELEMENTS);
}
javascript builtin DataViewPrototypeSetUint32(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let value : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
let isLittleEndian : Object = arguments.length > 2 ?
arguments[2] :
Undefined;
return DataViewSet(context, receiver, offset, value,
isLittleEndian, UINT32_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
let isLittleEndian: Object =
arguments.length > 2 ? arguments[2] : Undefined;
return DataViewSet(
context, receiver, offset, value, isLittleEndian, UINT32_ELEMENTS);
}
javascript builtin DataViewPrototypeSetInt32(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let value : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
let isLittleEndian : Object = arguments.length > 2 ?
arguments[2] :
Undefined;
return DataViewSet(context, receiver, offset, value,
isLittleEndian, INT32_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
let isLittleEndian: Object =
arguments.length > 2 ? arguments[2] : Undefined;
return DataViewSet(
context, receiver, offset, value, isLittleEndian, INT32_ELEMENTS);
}
javascript builtin DataViewPrototypeSetFloat32(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let value : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
let isLittleEndian : Object = arguments.length > 2 ?
arguments[2] :
Undefined;
return DataViewSet(context, receiver, offset, value,
isLittleEndian, FLOAT32_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
let isLittleEndian: Object =
arguments.length > 2 ? arguments[2] : Undefined;
return DataViewSet(
context, receiver, offset, value, isLittleEndian, FLOAT32_ELEMENTS);
}
javascript builtin DataViewPrototypeSetFloat64(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let value : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
let isLittleEndian : Object = arguments.length > 2 ?
arguments[2] :
Undefined;
return DataViewSet(context, receiver, offset, value,
isLittleEndian, FLOAT64_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
let isLittleEndian: Object =
arguments.length > 2 ? arguments[2] : Undefined;
return DataViewSet(
context, receiver, offset, value, isLittleEndian, FLOAT64_ELEMENTS);
}
javascript builtin DataViewPrototypeSetBigUint64(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let value : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
let isLittleEndian : Object = arguments.length > 2 ?
arguments[2] :
Undefined;
return DataViewSet(context, receiver, offset, value,
isLittleEndian, BIGUINT64_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
let isLittleEndian: Object =
arguments.length > 2 ? arguments[2] : Undefined;
return DataViewSet(
context, receiver, offset, value, isLittleEndian, BIGUINT64_ELEMENTS);
}
javascript builtin DataViewPrototypeSetBigInt64(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let value : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
let isLittleEndian : Object = arguments.length > 2 ?
arguments[2] :
Undefined;
return DataViewSet(context, receiver, offset, value,
isLittleEndian, BIGINT64_ELEMENTS);
let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
let isLittleEndian: Object =
arguments.length > 2 ? arguments[2] : Undefined;
return DataViewSet(
context, receiver, offset, value, isLittleEndian, BIGINT64_ELEMENTS);
}
}
src/torque/torque-parser.cc
View file @ f088840a
......@@ -1265,7 +1265,7 @@ struct TorqueGrammar : Grammar {
Symbol typeswitchCase = {
Rule({Token("case"), Token("("),
Optional<std::string>(Sequence({&identifier, Token(":")})), &type,
Token(")"), &block},
Token(")"), Token(":"), &block},
MakeTypeswitchCase)};
// Result: base::Optional<Statement*>
......
test/torque/test-torque.tq
View file @ f088840a
......@@ -4,10 +4,9 @@
module test {
macro ElementsKindTestHelper1(kind: constexpr ElementsKind): bool {
if constexpr((kind == UINT8_ELEMENTS) || (kind == UINT16_ELEMENTS)) {
if constexpr ((kind == UINT8_ELEMENTS) || (kind == UINT16_ELEMENTS)) {
return true;
}
else {
} else {
return false;
}
}
......@@ -82,7 +81,7 @@ module test {
}
}
builtin GenericBuiltinTest<T : type>(c: Context, param: T): Object {
builtin GenericBuiltinTest<T: type>(c: Context, param: T): Object {
return Null;
}
......@@ -97,8 +96,9 @@ module test {
check(GenericBuiltinTest<Object>(c, Undefined) == Undefined);
}
macro LabelTestHelper4(flag: constexpr bool): never labels Label4, Label5 {
if constexpr(flag) {
macro LabelTestHelper4(flag: constexpr bool): never
labels Label4, Label5 {
if constexpr (flag) {
goto Label4;
} else {
goto Label5;
......@@ -128,7 +128,7 @@ module test {
}
}
macro GenericMacroTest<T : type>(param: T): Object {
macro GenericMacroTest<T: type>(param: T): Object {
return Undefined;
}
......@@ -136,11 +136,13 @@ module test {
return param2;
}
macro GenericMacroTestWithLabels<T : type>(param: T): Object labels X {
macro GenericMacroTestWithLabels<T: type>(param: T): Object
labels X {
return Undefined;
}
GenericMacroTestWithLabels<Object>(param2: Object): Object labels Y {
GenericMacroTestWithLabels<Object>(param2: Object): Object
labels Y {
return param2;
}
......@@ -244,12 +246,12 @@ module test {
}
macro TestLocalConstBindings() {
const x : constexpr int31 = 3;
const xSmi : Smi = x;
const x: constexpr int31 = 3;
const xSmi: Smi = x;
{
const x : Smi = x + FromConstexpr<Smi>(1);
const x: Smi = x + FromConstexpr<Smi>(1);
check(x == xSmi + 1);
const xSmi : Smi = x;
const xSmi: Smi = x;
check(x == xSmi);
check(x == 4);
}
......@@ -287,14 +289,15 @@ module test {
d.x = a;
d = TestStructB{a, 7};
let e: TestStructA = d.x;
let f: Smi = TestStructA{UnsafeCast<FixedArray>(kEmptyFixedArray), 27, 31}.i;
let f: Smi =
TestStructA{UnsafeCast<FixedArray>(kEmptyFixedArray), 27, 31}.i;
f = TestStruct2().i;
return a;
}
struct TestStructC {
x : TestStructA;
y : TestStructA;
x: TestStructA;
y: TestStructA;
}
macro TestStruct4(): TestStructC {
......@@ -387,38 +390,42 @@ module test {
check(sum == 7);
}
macro TestSubtyping(x : Smi) {
const foo : Object = x;
macro TestSubtyping(x: Smi) {
const foo: Object = x;
}
macro IncrementIfSmi<A : type>(x : A) : A {
macro IncrementIfSmi<A: type>(x: A): A {
typeswitch (x) {
case (x : Smi) {
case (x: Smi): {
return x + 1;
} case (o : A) {
}
case (o: A): {
return o;
}
}
}
macro TypeswitchExample(x : Number | FixedArray) : int32 {
let result : int32 = 0;
typeswitch (IncrementIfSmi<(Number|FixedArray)>(x)) {
case (x : FixedArray) {
macro TypeswitchExample(x: Number | FixedArray): int32 {
let result: int32 = 0;
typeswitch (IncrementIfSmi<(Number | FixedArray)>(x)) {
case (x: FixedArray): {
result = result + 1;
} case (Number) {
}
case (Number): {
result = result + 2;
}
}
result = result * 10;
typeswitch (IncrementIfSmi<(Number|FixedArray)>(x)) {
case (x : Smi) {
typeswitch (IncrementIfSmi<(Number | FixedArray)>(x)) {
case (x: Smi): {
result = result + Convert<int32>(x);
} case (a : FixedArray) {
}
case (a: FixedArray): {
result = result + Convert<int32>(a.length);
} case (x : HeapNumber) {
}
case (x: HeapNumber): {
result = result + 7;
}
}
......@@ -428,26 +435,27 @@ module test {
macro TestTypeswitch() {
check(TypeswitchExample(FromConstexpr<Smi>(5)) == 26);
const a : FixedArray = AllocateZeroedFixedArray(3);
const a: FixedArray = AllocateZeroedFixedArray(3);
check(TypeswitchExample(a) == 13);
check(TypeswitchExample(FromConstexpr<Number>(0.5)) == 27);
}
macro ExampleGenericOverload<A: type>(o : Object) : A {
macro ExampleGenericOverload<A: type>(o: Object): A {
return o;
}
macro ExampleGenericOverload<A: type>(o : Smi) : A {
macro ExampleGenericOverload<A: type>(o: Smi): A {
return o + 1;
}
macro TestGenericOverload() {
const xSmi : Smi = 5;
const xObject : Object = xSmi;
const xSmi: Smi = 5;
const xObject: Object = xSmi;
check(ExampleGenericOverload<Smi>(xSmi) == 6);
check(UnsafeCast<Smi>(ExampleGenericOverload<Object>(xObject)) == 5);
}
macro BoolToBranch(x : bool) : never labels Taken, NotTaken {
macro BoolToBranch(x: bool): never
labels Taken, NotTaken {
if (x) {
goto Taken;
} else {
......@@ -455,27 +463,27 @@ module test {
}
}
macro TestOrAnd1(x : bool, y : bool, z : bool) : bool {
macro TestOrAnd1(x: bool, y: bool, z: bool): bool {
return BoolToBranch(x) || y && z ? true : false;
}
macro TestOrAnd2(x : bool, y : bool, z : bool) : bool {
macro TestOrAnd2(x: bool, y: bool, z: bool): bool {
return x || BoolToBranch(y) && z ? true : false;
}
macro TestOrAnd3(x : bool, y : bool, z : bool) : bool {
macro TestOrAnd3(x: bool, y: bool, z: bool): bool {
return x || y && BoolToBranch(z) ? true : false;
}
macro TestAndOr1(x : bool, y : bool, z : bool) : bool {
macro TestAndOr1(x: bool, y: bool, z: bool): bool {
return BoolToBranch(x) && y || z ? true : false;
}
macro TestAndOr2(x : bool, y : bool, z : bool) : bool {
macro TestAndOr2(x: bool, y: bool, z: bool): bool {
return x && BoolToBranch(y) || z ? true : false;
}
macro TestAndOr3(x : bool, y : bool, z : bool) : bool {
macro TestAndOr3(x: bool, y: bool, z: bool): bool {
return x && y || BoolToBranch(z) ? true : false;
}
......@@ -529,5 +537,4 @@ module test {
check(!TestOrAnd2(false, false, false));
check(!TestOrAnd3(false, false, false));
}
}
third_party/v8/builtins/array-sort.tq
View file @ f088840a
......@@ -124,7 +124,7 @@ module array {
// copied values from the prototype chain to the receiver if they were visible
// through a hole.
builtin Load<ElementsAccessor : type>(
builtin Load<ElementsAccessor: type>(
context: Context, sortState: FixedArray, elements: HeapObject,
index: Smi): Object {
return GetProperty(context, elements, index);
......@@ -193,7 +193,7 @@ module array {
return elems[index];
}
builtin Store<ElementsAccessor : type>(
builtin Store<ElementsAccessor: type>(
context: Context, sortState: FixedArray, elements: HeapObject, index: Smi,
value: Object): Smi {
SetProperty(context, elements, index, value);
......@@ -230,8 +230,7 @@ module array {
Store<DictionaryElements>(
context: Context, sortState: FixedArray, elements: HeapObject, index: Smi,
value: Object): Smi {
const dictionary: NumberDictionary =
UnsafeCast<NumberDictionary>(elements);
const dictionary: NumberDictionary = UnsafeCast<NumberDictionary>(elements);
const intptrIndex: intptr = Convert<intptr>(index);
try {
BasicStoreNumberDictionaryElement(dictionary, intptrIndex, value)
......@@ -323,7 +322,7 @@ module array {
return v;
}
builtin CanUseSameAccessor<ElementsAccessor : type>(
builtin CanUseSameAccessor<ElementsAccessor: type>(
context: Context, receiver: JSReceiver, initialReceiverMap: Object,
initialReceiverLength: Number): Boolean {
assert(IsJSArray(receiver));
......@@ -488,7 +487,8 @@ module array {
macro CallLoad(
context: Context, sortState: FixedArray, load: LoadFn,
elements: HeapObject, index: Smi): Object labels Bailout {
elements: HeapObject, index: Smi): Object
labels Bailout {
const result: Object = load(context, sortState, elements, index);
EnsureSuccess(sortState) otherwise Bailout;
return result;
......@@ -751,10 +751,10 @@ module array {
let runLength: Smi = 2;
const elementLow: Object =
CallLoad(context, sortState, load, elements, low) otherwise Bailout;
const elementLowPred: Object =
CallLoad(context, sortState, load, elements, low - 1) otherwise Bailout;
const elementLow: Object = CallLoad(
context, sortState, load, elements, low) otherwise Bailout;
const elementLowPred: Object = CallLoad(
context, sortState, load, elements, low - 1) otherwise Bailout;
let order: Number =
CallCompareFn(context, sortState, elementLow, elementLowPred)
otherwise Bailout;
......@@ -767,8 +767,8 @@ module array {
let previousElement: Object = elementLow;
for (let idx: Smi = low + 1; idx < high; ++idx) {
const currentElement: Object =
CallLoad(context, sortState, load, elements, idx) otherwise Bailout;
const currentElement: Object = CallLoad(
context, sortState, load, elements, idx) otherwise Bailout;
order = CallCompareFn(context, sortState, currentElement, previousElement)
otherwise Bailout;
elements = ReloadElements(sortState);
......@@ -800,10 +800,10 @@ module array {
let high: Smi = to - 1;
while (low < high) {
const elementLow: Object =
CallLoad(context, sortState, load, elements, low) otherwise Bailout;
const elementHigh: Object =
CallLoad(context, sortState, load, elements, high) otherwise Bailout;
const elementLow: Object = CallLoad(
context, sortState, load, elements, low) otherwise Bailout;
const elementHigh: Object = CallLoad(
context, sortState, load, elements, high) otherwise Bailout;
CallStore(context, sortState, store, elements, low++, elementHigh)
otherwise Bailout;
CallStore(context, sortState, store, elements, high--, elementLow)
......@@ -1632,7 +1632,7 @@ module array {
sortState[kPendingRunsIdx] = pendingRuns;
}
macro InitializeSortStateAccessor<Accessor : type>(sortState: FixedArray) {
macro InitializeSortStateAccessor<Accessor: type>(sortState: FixedArray) {
sortState[kAccessorIdx] = kFastElementsAccessorId;
sortState[kLoadFnIdx] = Load<Accessor>;
sortState[kStoreFnIdx] = Store<Accessor>;
......
tools/torque/format-torque.py
View file @ f088840a
......@@ -11,6 +11,42 @@ import sys
import re
from subprocess import Popen, PIPE
def preprocess(input):
input = re.sub(r'(if\s+)constexpr(\s*\()', r'\1/*COxp*/\2', input)
input = re.sub(r'(\)\s*\:\s*\S+\s+)labels\s+',
r'\1,\n/*_LABELS_HOLD_*/ ', input)
input = re.sub(r'(\s+)operator\s*(\'[^\']+\')', r'\1/*_OPE \2*/', input)
input = re.sub(r'(\s+)typeswitch\s*\(', r'\1/*_TYPE*/switch (', input)
input = re.sub(r'(\s+)case\s*\(([^\s]+)\s+\:\s*([^\:]+)\)(\s*)\:',
r'\1case \3: /*_TSV\2:*/', input)
input = re.sub(r'(\s+)case\s*\(([^\:]+)\)(\s*)\:',
r'\1case \2: /*_TSX*/', input)
input = re.sub(r'\sgenerates\s+\'([^\']+)\'\s*',
r' _GeNeRaT_/*\1@*/', input)
input = re.sub(r'\sconstexpr\s+\'([^\']+)\'\s*',
r' _CoNsExP_/*\1@*/', input)
return input
def postprocess(output):
output = re.sub(r'\/\*COxp\*\/', r'constexpr', output)
output = re.sub(r'(\S+)\s*: type([,>])', r'\1: type\2', output)
output = re.sub(r',([\n ]*)\/\*_LABELS_HOLD_\*\/', r'\1labels', output)
output = re.sub(r'\/\*_OPE \'([^\']+)\'\*\/', r"operator '\1'", output)
output = re.sub(r'\/\*_TYPE\*\/(\s*)switch', r'typeswitch', output)
output = re.sub(r'case ([^\:]+)\:\s*\/\*_TSX\*\/',
r'case (\1):', output)
output = re.sub(r'case ([^\:]+)\:\s*\/\*_TSV([^\:]+)\:\*\/',
r'case (\2: \1):', output)
output = re.sub(r'(\n\s*)_GeNeRaT_\s*\/\*([^@]+)@\*\/',
r"\1 generates '\2'", output)
output = re.sub(r'_GeNeRaT_\s*\/\*([^@]+)@\*\/',
r"generates '\1'", output)
output = re.sub(r'_CoNsExP_\s*\/\*([^@]+)@\*\/',
r"constexpr '\1'", output)
output = re.sub(r'(\n\s*)otherwise(\s+\S+\s*[\(\;])',
r"\1 otherwise\2", output)
return output
if len(sys.argv) < 2 or len(sys.argv) > 3:
print "invalid number of arguments"
sys.exit(-1)
......@@ -24,7 +60,8 @@ filename = sys.argv[len(sys.argv) - 1]
with open(filename, 'r') as content_file:
content = content_file.read()
p = Popen(['clang-format', '-assume-filename=.ts'], stdin=PIPE, stdout=PIPE, stderr=PIPE)
output, err = p.communicate(content)
output, err = p.communicate(preprocess(content))
output = postprocess(output)
rc = p.returncode
if (rc <> 0):
sys.exit(rc);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment