/*
Syntax List:
Interrupts:
Interrupt(I); -> Interrupt Number I
NewInt(L,N,W); -> Make Interrupt which does L with interrupt number (N) at W
Freq(V); -> Set frequency **
OUT(B,X,Y,C); -> Turn a Byte(B) into Ascii and print it at X,Y with color C
GOTO(W); -> Jump/Goto W
CCE(A,B,W); -> Compares Byte A with Byte B if equal Calls W **
CCNE(A,B,W); -> Compares Byte A with Byte B if not equal Calls W **
STORE(B); -> Byte B -> Stack **
TAKE(B); -> Stack -> Byte B **
MOV(B,V); -> (V)alue -> Byte B **
BMOV(A,B); -> Byte A = BYTE B **
RAMClear(Min,Max); -> Clear ram from min to max **
NOTE: RAMclear SKIPS screen AND Keyboard, so its actually 0 = 2305
ADD(A,B,W); -> Add Byte A with Byte B into Byte W **
End(); -> Stop program and Draw "End of program" (*) at bottom
Reset(); -> Jump to the start of code
Non Oasm Syntax (Used by THIS to do things):
ClrScr(); -> Clear the Screen *
Print(String,X,Y,Color); -> Print String at X and Y with Color as .. Colour *
Wait(T); -> Wait for T Loops to pass to continue
 
* = Only works if Screen is at first address
** = Used for Oasm Emulator
 
*/
 
#asm
_Start_Of_Program_:
 
DATA;
// Stack Pointer
Alloc _OSP,4096
Alloc _Cmpr,0
Int_Table:; Alloc 512
#endasm
 
Memory2(W,L) int W,L;
/* Direct memory acces with labels */
{
#asm
    mov EDX,EBP;
  add EDX,2; // L
  mov EAX,#EDX;
 
    mov EDX,EBP;
  add EDX,3; // W
  mov EBX,#EDX;
 
Mov ECX,EBX;Add ECX,65536
Mov #ECX,#EAX
#endasm
}
 
DPIXEl(X,Y,C) int X,Y,C;
{
int T;
X = X * 2;
T = 5000; /* T DOES NUTHIN WHEN YOU CHANGE IT */
T = T * 12;
T = T + 5000;
T = T + 536;
T = T + X;
 Y = Y * 60;
 T = T + Y;
C = C*1000
Memory(T,C);
}
 
Memory(W,V) int W,V;
{
#asm
    mov EDX,EBP;
  add EDX,2; // V
  mov EAX,#EDX;
 
    mov EDX,EBP;
  add EDX,3; // W
  mov EBX,#EDX;
 
Mov ECX,EBX;Add ECX,65536
Mov #ECX,EAX
#endasm
}
 
Call(W)
{
#asm
    mov EDX,EBP;
  add EDX,2; // W
  mov EAX,#EDX;
 
Add ESP,1
Call EAX
#endasm
}
 
CCNE(A,B,W) int A,B,W;
{
#asm
    mov EDX,EBP;
  add EDX,2; // W
  mov EAX,#EDX;
 
    mov EDX,EBP;
  add EDX,3; // B
  mov EBX,#EDX;
 
    mov EDX,EBP;
  add EDX,4; // A
  mov ECX,#EDX;
 
Mov EDX,65536;Add EDX,ECX
Mov ESI,#EDX
Mov EDX,65536;Add EDX,EBX
Mov EDI,#EDX
 
Cmp ESI,EDI;Cne EAX
 
#endasm
}
/* Interrupts */
 
Interrupt(I) int I;
{
#asm
 
    mov EDX,EBP;
  add EDX,2; // I
  mov EAX,#EDX;
 
int EAX
#endasm
}
 
NewInt(L,N,W) int L,N,W;
{
#asm
 
    mov EDX,EBP;
  add EDX,2; // W
  mov EAX,#EDX;
 
    mov EDX,EBP;
  add EDX,3; // N
  mov EBX,#EDX;
 
    mov EDX,EBP;
  add EDX,4; // L
  mov ECX,#EDX;
 
Mul EAX,2
 
stp
Int_SetterUpper:
  sti
  lidtr Int_Table
  mov  edi,Int_Table
  add  edi,64
Add EDI,EAX
 Mov #EDI,ECX
Inc EDI
 Mov #EDI,EBX
 
#endasm
}
 
Freq(V) int V;
{
#asm
    mov EDX,EBP;
  add EDX,2; // Value
  mov ESI,#EDX;
out 0,ESI
#endasm
}
 
#asm
Alloc X
Alloc Y
Alloc C
Alloc B
#endasm
 
OUT(B,X,Y,C) int B,X,Y,C;
{
#asm
 
    mov EDX,EBP;
  add EDX,3; // Y
  mov #Y,#EDX;
 
    mov EDX,EBP;
  add EDX,4; // X
  mov #X,#EDX;
 
    mov EDX,EBP;
  add EDX,5; // Byte
  mov #B,#EDX;
 
     mov EDX,EBP;
  add EDX,2; // Colour
  mov #C,#EDX;
 
 
Mov EAX,65536;Add EAX,#B
Mov ESI,#EAX
Jmp _Asciinize
_Ascii_Fin:;DB 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1
 
_AsciiNize:
mov EAX,_Ascii_Fin
mov EDX,10000000         // if you want less digits, remove zeros from this number
mov EBX,ESI
mov ECX,0
fint EBX
div EBX,EDX
div EDX,10
fint EBX
mov ECX,EBX
mul ECX,EDX
add EBX,48
mov #EAX,EBX
inc EAX
jmp Int_loop
 
Int_loop:
mov EBX,ESI
div EBX,EDX
fint EBX
push EBX
sub EBX,ECX
pop ECX
mul ECX,10
add EBX,48
mov #EAX,EBX                       // Write to DB
inc EAX
div EDX,10
cmp EDX,0.1
je Int_Fin
jmp Int_loop
 
Int_Fin:
Mov EBX,#X;Mul EBX,2
Mov ECX,#Y;Mul ECX,60
Mov ESI,#C
Mov EAX,65536;Add EAX,ECX;Add EAX,EBX
Mov EDI,_Ascii_Fin
Jmp _Print
#endasm
}
 
Ramclear(Min,Max) int Min,Max;
{
#asm
    mov EDX,EBP;
  add EDX,2; // Max
  mov EAX,#EDX;
 
    mov EDX,EBP;
  add EDX,3; // Min
  mov EBX,#EDX;
 
Mov ECX,65536;Add ECX,2048;Add ECX,256;Add ECX,EAX
_Ram_Clear:
Cmp EAX,EBX;Jle _CLEAR_RET
 Mov #ECX,0
  Dec EAX
Jmp _Ram_Clear
_Clear_Ret:
#endasm
}
 
 
 
 
GOTO(W) int W;
{
#asm
    mov EDX,EBP;
  add EDX,2; // W
  mov EAX,#EDX;
 
Add ESP,1
 Jmp EAX
#endasm
}
 
CCE(A,B,W) int A,B,W; 
{
#asm
    mov EDX,EBP;
  add EDX,2; // W
  mov EAX,#EDX;
 
    mov EDX,EBP;
  add EDX,3; // B
  mov EBX,#EDX;
 
    mov EDX,EBP;
  add EDX,4; // A
  mov ECX,#EDX;
 
Mov EDX,65536;Add EDX,ECX
Mov ESI,#EDX
Mov EDX,65536;Add EDX,EBX
Mov EDI,#EDX
 
Cmp ESI,EDI;Ce EAX
 
#endasm
}
 
STORE(B) int B;
{
#asm
    mov EDX,EBP;
  add EDX,2; // B
  mov EAX,#EDX;
 
Mov EBX,65536;Add EBX,EAX
 Mov ECX,#EBX
Mov EBX,65536;Add EBX,#_OSP
Mov #EBX,ECX;Dec #_OSP
#endasm
}
 
/* Not finished */
 
TAKE(B) int B;
{
#asm
 
    mov EDX,EBP;
  add EDX,2; // B
  mov EAX,#EDX;
 
Mov EBX,65536;Add EBX,EAX
Mov ECX,#EBX
Mov EBX,65536;Add EBX,#_OSP
Inc EBX;Inc #_OSP
Mov EDX,#EBX
Mov EBX,ECX;Mov #EBX,EDX
#endasm
}
 
BMOV(A,B) int A,B;
{
#asm
    mov EDX,EBP;
  add EDX,2; // B
  mov EAX,#EDX;
 
    mov EDX,EBP;
  add EDX,3; // A
  mov EBX,#EDX;
 
Mov ECX,65536;Add ECX,EAX
Mov ESI,ECX
Mov ECX,65536;Add ECX,EBX
Mov EDI,ECX
 
Mov #ESI,#EDI
 
#endasm
}
 
MOV(W,V) int W,V; /* Move Value into Byte W */
{
#asm
 
    mov EDX,EBP;
  add EDX,2; // V
  mov EAX,#EDX;
 
    mov EDX,EBP;
  add EDX,3; // W
  mov EBX,#EDX;
 
Cmp EBX,4096;Jg _HW
Cmp EBX,0;Jl _LW
Cmp EAX,2147483647;Jg _HV
Cmp EAX,-2147483647;Jl _LV
 // Check Values
 Mov ECX,65536;Add ECX,EBX
Mov #ECX,EAX
 // Save to Byte X
#endasm
}
 
ADD(A,B,W) int A,B,W; /* Add 2 Bytes into Byte W */
{
#asm
 
    mov EDX,EBP;
  add EDX,2; // W
  mov EAX,#EDX;
 
    mov EDX,EBP;
  add EDX,3; // B
  mov EBX,#EDX;
 
    mov EDX,EBP;
  add EDX,4; // A
  mov ECX,#EDX;
 
// Get Values
 
Mov EDX,65536;Add EDX,EBX // B
Mov ESI,#EAX
// Store B Into ESI
Mov EDX,65536;Add EDX,ECX // A
Mov EDI,#EAX
// Store A Into EDI
 Add ESI,EDI
// Add them
Mov EDX,EAX;Add EDX,65536
Mov #EDX,ESI
// Store them into Byte W + 65536
// Save to Byte
 
#endasm
}
 
HW() /* High Byte */
{
 
ClrScr(); 
Print("Inaccessible Byte",0,0,999);
Print("Too High",0,0,999);
End();
 
}
 
LW() /* Low Byte */
{
ClrScr
Print("Inaccessible Byte",0,0,999);
Print("Too Low",0,0,999);
End();
}
 
HV() /* High Value */
{
ClrScr();
Print("Too High Value",0,0,999);
Print("Max Value: 2147483647",0,1,999);
End();
}
 
LV() /* Low Value */
{
ClrScr();
Print("Too Low Value",0,0,999);
Print("Min Value: -2147483647",0,1,999);
End();
}
 
Reset()
{
#asm
Jmp _Start_Of_Program_
#endasm
}
/*
End()
{
Print("End of Program",0,17,999);
#asm
_End_:
Jmp _End_
#endasm
}
*/
 
 
End() /* End program C style */
{
Print("End of Program",0,17,999);
Goto(End);
}
 
 
ClrScr() /* Clear Screen */
{
#asm
Mov EAX,65536;Add EAX,2041
Mov #EAX,1
Mov #EAX,0
#endasm
}
 
 
Print(String,X,Y,Color) char *string; int X,Y,Color; /* Print Text */
{
#asm
    mov EDX,EBP;
  add EDX,2; // Colour
  mov ESI,#EDX;
 
    mov EDX,EBP;
  add EDX,3; // Y
  mov EBX,#EDX;
 
    mov EDX,EBP;
  add EDX,4; // X
  mov ECX,#EDX;
 
    mov EDX,EBP;
  add EDX,5; // String
  mov EDI,#EDX;
 
 Mov EAX,65536
  Mul ECX,2
   Mul EBX,60
Add EAX,EBX;Add EAX,ECX
 
    Print_:
      Cmp #EDI,0
Je _PRET
       Mov #EAX,#EDI
       Inc EAX
       Mov #EAX,ESI
Inc EAX
        Inc EDI
    Jmp Print_
_PRET:
#endasm
}
 
Wait(T) int T;
{
#asm
    mov EDX,EBP;
  add EDX,2; // T
  mov EAX,#EDX;
 
Wait_Loop:
Cmp EAX,0;Jle Wait_Ret
Dec EAX
Jmp Wait_Loop 
Wait_Ret:
Mov EAX,0
#endasm
}
 
#asm
CODE;
#endasm
 
Init()
{
ClrScr();
Print("Initializing Oasm",0,0,999);
Print("Reading Code",0,1,999);
Wait(100); /* Yes, It actually does nothing :V */
Print("Setting Up Variables",0,2,999);
Print("Oasm: Overv Emulator",0,3,999);
Print("4096 Byte",0,4,999);
Print("Code Output:",0,5,999);
#asm
Jmp _Main
#endasm
}
/* Code continues on HERE */