while c, c=*p++, endw, p-s, p--

. p=a, q=b, n>>>2
loop n, (u32) *p++=*q++, endl

while s<e, c=*s, *s++=*e, *e--=c, endw

loop n, c=*s++, *p++=c
  if c=0, break, end
endl, p--

while c, c=*s++, *p++=c, endw, p--

if n=0, *p++='0', *p=0
  return s
end    

while c=d, c=*p++, d=*s++
  if c=0, break, end
  if d=0, break, end
endw, p=c, p-d

while n, x=n, x&1, x+'0'
  . *p++=x, n>>>1
endw, *p=0

forever, c=*p++
  if c=0, return n, end
  . x=n, x<<2, n+x, n+n, n-'0', n+c
endfv    

; memory copy 32BIT

function memory.copy, a, b, n
  alias p=r0, q=r1
  . p=a, q=b, n>>>2
  loop n, (u32) *p++=*q++, endl
endf

; text.n t - get length, # characters

function text.n, t
  alias p=r0, s=r1, c=r2
  . p=t, s=p, c=1
  while c, c=*p++, endw, p-s, p--
endf

; text.copy a, b - standard copy with
; 0 after. return advanced address

function text.copy, a, b
  alias p=r0, s=r1, c=r2
  . p=a, s=b, c=1
  while c, c=*s++, *p++=c, endw, p--
endf

; text.copy.n a, b, n - copy with maximum
; size specified. return &

function text.copy.n, a, b, n
  alias p=r0, s=r1, c=r2
  . p=a, s=b
  loop n, c=*s++, *p++=c
    if c=0, break, end
  endl, p--
endf                                               

; convert 32BIT binary number to text

function b2t, n, t
  alias p=r0, x=r1
  . p=t
  if n=0, *p++='0', *p=0
    return
  end
  while n, x=n, x&1, x+'0'
    . *p++=x, n>>>1
  endw, *p=0
  text.reverse t
endf

; load/save memory and text

function load.file, name
  catch .0
  try open name
  try file.p=allocate file.n
  try read file.p, file.n
  close
  return file.p
  .0: flush
  close
endf 0

function save.file, name, p, size
  catch .0
  try create name
  try write p, size
  close
  return 1
  .0: close
endf 0

function append.file, name, p, size
  catch .0
  open name
  if false
    try create name
  else
    seek 0, SEEK.END
  end
  try write p, size
  close
  return 1
  .0: close
endf 0

function load.text, name
  alias p=r0
  catch .0
  try open name
  . r0=file.n, r0++
  try file.p=allocate r0
  try read file.p, file.n
  close
  . p=file.p, p+file.n, *p=0
  return file.p
  .0: flush
  close
endf 0

function save.text, name, t
  text.n t
  save.file name, t, r0
endf    

; ABAKIS EXAMPLE. SEE \INCLUDE\

include 'z.inc'

text t(64), s(64), f='LOG.TXT'
text m(64)='NOItUlOVe ReLBmESsa SikaBa'

function test.text
  text.copy t, m
  say t
  text.reverse t
  text.upper t
  text.attach.c t, '!'
endf

function test.number
  say.n 4294967295
  say.h 0ABCDEF12h
  say.h 0FFFFFFFFh
  say.b 11110000111100001111b
endf

function test.memory
  locals p
  try p=allocate 33
  memory.zero p, 33
  memory.set p, '1234', 32
  say p
  destroy p
endf 1

function test.file
  locals n
  get n=text.n t
  try create f
  write t, n
  close
  try open f
  read s, n
  say s
  close
  execute f
endf 1

function test.io
  test.memory
  if false
    say 'Memory allocation error'
    return 0
  end
  test.file
  if false
    say 'File I/O error'
    return 0
  end
endf 1

function main
  test.text
  test.number
  try test.io
endf    

* Rewrote variables. All standard names like byte, char, int/eger, void.
* Safer. Removed most fix-es. Replaced with macros and equates. "fix" was only used temporarily. Never use "fix" unless you have to. Example: "text fix db" is a bad idea. After this, the word "text" can not be used as locals, parameters or members (name#.text)
* "if" can be written on same line: if min<0, min=0, end
* Multi-Statements: let/if/loop/while/break/end can have multiple arithmetic and/or if/loop after it. Statements occur at the begining of the loop unlike with "for i=0, i<n, i++". "if/loop/while" definitions still need some work
* Pointer arithmetic (registers-only): * and &. (u8) is the default for *p if not specified by (cast)
* Automatic [value] for integral (integer/byte/void) and float/double. Address for everything else; text, arrays, structures. One exception: For special addressing modes ([a+b*c]), always specify *(x) or &(x): . *(r0+r1*4)=r2 (value) or . r0=&(r7+16) (address or expression). This is just how it works for now as a safety precaution and for CPU portability. Not quite finished, not working in all contexts
* Text arrays are easier and more versatile. Now, "text" does it all: text ta[]='ann', 'kim', 'sue'. See "variable examples" in LANGUAGE.INC.

Hi m3ntal,

Looks cool.
Anyway, it's interesting to see that you modified FASM in order to support your language.
Hopefully you don't mind to share the modified code as well

if n=0, *p++='0', *p=0, return 0, end

while n, x=n, x&1, x+'0', *p++=x, n>>>1
endw, *p=0, s=p, x*1000

loop, c=*p++
  if c=0, return n, end
  . x=n, x<<2, n+x, n+n, n-'0', n+c
endl    

text ta[]= '123', 'ABC', 'XYZ'

text names[](8)= 'ann', 'kim', 'sue'

text xyz[]= ID.A='A', ID.B='B', ID.C='C'

text theme.names[THEME.*]= BLACK='Black', WHITE='White', SILVER='Silver'    

;;;;;;;;;;;;;;;;;;;; DRAWING ;;;;;;;;;;;;;;;;;;;;;

; address &vga[(y*(screen.w*4))+(x*4)]
; (y*(screen.w*(bpp/8))))+(x*(bpp/8))
; (y*(screen.w*(bpp>>>3))))+(x*(bpp>>>3))

function vga.xy, x, y
  alias a=r0, b=r1, n=r2
  . a=screen.w, a*4, a*y, b=x, b*4, a+b, a+vga
endf

; erase screen with color/r0...

function clear.screen, c
  alias p=r0, n=r1, z=r2
  . p=vga, n=screen.n, z=c
  loop n, (u32) *p++=z, endl
endf

; draw pixel

function draw.pixel, x, y, c
  alias p=r0, z=r1
  try clip.pixel x, y
  vga.xy x, y
  . z=c, (u32) *p=z
endf 1

; draw horizontal line

function draw.line.h, x, y, n, c
  alias p=r0, z=r1, w=r2
  . p=&x, z=&y, w=&n
  try clip.line 'h', p, z, w
  vga.xy x, y
  . z=c
  loop n, (u32) *p++=z, endl
endf 1

; draw vertical line

function draw.line.v, x, y, n, c
  locals swb
  alias p=r0, z=r1, h=r2
  . p=&x, z=&y, h=&n
  try clip.line 'v', p, z, h
  vga.xy x, y
  . z=c, swb=screen.pitch
  loop n, (u32) *p=z, p+swb, endl
endf 1

; draw solid rectangle

function draw.box, x, y, w, h, c
  locals i
  try visible x, y, w, h
  . i=y, i--
  loop h, i++
    draw.line.h x, i, w, c
  endl
endf 1    

include 'a.inc'
use interface

!on create
  ; ...
!end

!on draw
  locals x, y, w, h
  clear.screen ROYAL.BLUE
  . x=128, y=128, w=screen.w, w-256
  . h=screen.h, h-256
  draw.box x, y, w, h, POWER.BLUE
  draw.outline x, y, w, h, WHITE 
!end

!on key
  if key.event='k'
    say 'Key Press'
  end
!end

!on mouse
  if mouse.event='c'
    say 'Mouse Click'
  else.if mouse.event='rc'
    minimize.window
  end
  redraw
!end    

;;;;;;;;;;;;;;;; WINDOW PROCEDURE ;;;;;;;;;;;;;;;;

function _window.procedure, window, message, wp, lp
  alias m=r0
  . m=message, event.id=0, mouse.double=0

  if m=WM_PAINT
    get _dc=BeginPaint _hwnd, _ps
    redraw
    EndPaint _hwnd, _ps
   go .default

  else.if m=WM_COMMAND
    calle command

  else.if m=WM_KEYDOWN
    . key=wp, event.id='k', key.event='k'
    if exit.if.esc
      if wp=K.ESCAPE
        SendMessageA window, WM_DESTROY, 0, 0
      end
    end
    .key:
    calle key
    return 0

  else.if m=WM_KEYUP
    . key=NO, event.id='k', key.event='r'
    go .key

  else.if m=WM_CHAR
    . key=wp, event.id='k', key.event='c'
    go .key

  else.if m=WM_MOUSEMOVE
    . mouse.event='m'
    if mouse.1
      if not mouse.drag
        . mouse.drag=YES,\
        mouse.drag.x=mouse.x,\
        mouse.drag.y=mouse.y
      end
    end
    .mouse:
     . event.id='m', r0=lp, r1=r0,\
     r0&0FFFFh, mouse.x=r0,\
     r1>>16, r1&0FFFFh, mouse.y=r1
    calle mouse
    if mouse.event='m'
      . mouse.px=mouse.x,\
       mouse.py=mouse.y
    end
    return 0

  else.if m=WM_LBUTTONDOWN
    . mouse.event='c', mouse.1=YES,\
    mouse.drop=NO
    go .mouse

  else.if m=WM_LBUTTONUP
    . mouse.event='r', mouse.1=NO
    if mouse.drag
      . mouse.drop=YES,\
      mouse.drop.x=mouse.x,\
      mouse.drop.y=mouse.y,\
      mouse.drag=NO
    end
    go .mouse

  else.if m=WM_LBUTTONDBLCLK
    . mouse.double=YES
    go .mouse

  else.if m=WM_RBUTTONDOWN
    . mouse.event='rc', mouse.2=YES
    go .mouse

  else.if m=WM_RBUTTONUP
    . mouse.event='rr', mouse.2=NO
    go .mouse

  else.if m=WM_MOUSEWHEEL
    . mouse.event='w', r1=wp,\
    r1>>16, mouse.wheel=r1
    go .mouse

  else.if m=WM_CREATE
    calle create
    jmp .default

  else.if m=WM_DESTROY
    .destroy:
    calle destroy
    PostQuitMessage 0
    jmp .default

  else
    go .default
  end

  .default: DefWindowProcA \
  window, message, wp, lp
endf    

; SYSTEM.INC...

function os.create.vga, w, h
  alias p=r0, x=r1
  set.screen screen.w, screen.h, screen.bpp
  try vga.hbm=CreateBitmap \
   screen.w, screen.h, 32, 1, vga
  memory.zero vga.bmi, BITMAPINFOHEADER.$
  . vga.bmi.biSize=BITMAPINFOHEADER.$
  . vga.bmi.biWidth=screen.w
  . x=screen.h, neg x, vga.bmi.biHeight=x
  . vga.bmi.biPlanes=1, vga.bmi.biBitCount=32
  ShowCursor 0
endf

function os.show.vga
  SetDIBits _dc, vga.hbm, 0, screen.h,\
   vga, vga.bmi, 0
  draw.bitmap.w vga.hbm, 0, 0, screen.w, screen.h
  . vga.rect.left=0, vga.rect.top=0,\
   vga.rect.right=screen.w,\
   vga.rect.bottom=screen.h
  InvalidateRect _hwnd, vga.rect, 0
endf    

No one here wanted to talk about programming so I gave up.

1. Newcomers who come to fasm are primarily very interested in fasm and want to learn fasm primarily (first) perhaps later they will look at something like what you have designed

2. Those who are already here are mostly "elites"...

3. Abakis isn't "really" assembly and that pisses some people off

4. Being dependent on an underlying assembler with a new "language" on top of it creates annoying dependencies, specially if the author of the top layer isn't serious (I don't know whether you are serious or not, but it can be an annoyance)

5. If you change your mind and re-design your language often, people have to re-learn it, if this is a bad habit, some people may be put off by that and decide to abandon the language

6. If the language is highly subjective to the author, it might piss some people off.

... the narcisistic designer, I'm not saying you are, but this is a very big annoyance with those who are)

7. If you brag about it, people may just leave your language just to punish you.

There is nothing wrong about bragging, but the destructive kind of bragging where you put down other designers of similar projects.

8. People need a language designer who is optimistic and give inspiration and optimism to the user...

... if you find yourself to be highly destructive, that itself may trigger people to abandon Abakis.

Abakis doesn't claim to be assembly. You have a misconception that I want people to use Abakis.

"Use me, baby. I'm the best language, most beautiful and powerful there is, there's nothing better than me, I can prove it with numbers and measurements. Don't even look at C or I'll get jealous. You don't need her, I'll do everything for you" - Don't listen to her. She tells mostly truth that can be verified, but she's crazy, not perfect, has "issues", still needs safety and expressions. She's fun to play with at times, exciting and dramatic, but very "dangerous" and not the type who I would stay with. You can have her. I'm generous with abilities, knowledge, women, programs, languages, inventions, CPU designs, etc, things which I have an abundance of.

You've treated many people in here like trash for many years

Btw. I'm studying the match macro these days. It's not really much to study, but it's one of those macros you can't skip. I see a match and it is a good match, it's not based on a virtual reality, the match is virtual at reality, you can irps to irp to go through white clumps of matter.

macro variable [p] {    ; create integer variables
  common                ; do this once...
    local m
    define m 0          ; did match occur?
  forward               ; loop for each p...
    match v==n, p \{    ; assignment? use 2 == for =
      v dd n            ; create variable
      define m 1        ; successful match
    \}
    match =0 v, m p \{  ; else, just name
      v dd 0            ; create variable, value=0
      define m 1        ; successful match
    \}
    match =0, m \{      ; else, no match
      display 'Error'
    \}
}    

You should use lookup buffers if they are very small, up to 64 bytes and if you have a very few of them alltogether in your code.

When you're speaking about "mistakes", based on what you're saying it seems as if you're trying to distance yourself from that and don't want to have anything to do with that, but don't be angry with those who point out your mistakes, because it's your own mistakes, not theirs.

We should join forces starcode.