AdrianV

# ranges.nim
type   
  TDownSlice* {.final, pure.}[T] = object 
    a*, b*: T
  TCountUpRange* [T] = ref RCountUpRange[T]
  RCountUpRange [T] = object
    cur: T
    a: T
    last: T
  TCountDownRange* [T] = ref RCountDownRange[T]    

AdrianV

import math
import sequtils
import sdl

const 
  width  = 1280
  height = 720
  fov    = 45.0
  max_depth = 6 
  

AdrianV

import benchmark

type
  ClassID = enum CBase, CSecond, CThird 
  TBase = ref object {.inheritable.}
    class: ClassID
    data: int
  TSecond = ref object of TBase
    d2: int
  TThird = ref object of TSecond

AdrianV

import oopHelper, benchmark

declClass TBase:
  var 
    data: int
  proc create(data: int) {.constructor.} =
    self.data = data
  method Foo(): int = return self.data
  method Multi(a, b, c: int): int = 0
  proc initialize() {.inline.} =

AdrianV

import benchmark

type
  TBase = ref object {.inheritable.}
    data: int
  TSecond = ref object of TBase
    d2: int
  TThird = ref object of TSecond
    d3: int
  

AdrianV

import VExpr;
import VExpr.C.*;

@:access(VExpr)
class Main {

	macro static public function benchmark(test, start, done) {
		return macro {
            trace($start);
            var dt = haxe.Timer.stamp();

AdrianV

Adrian Veith

and how do I code InterlockedExchangeAdd64 in In 32-bit x86 assembly ?

gpt4

InterlockedExchangeAdd64 is a function that atomically adds a 64-bit integer to a target variable and returns the original value of the target variable. In 32-bit x86 assembly, you can implement this using a combination of the LOCK prefix, CMPXCHG8B instruction, and ADD instruction. Here's an example implementation in x86 assembly:

assembly