Code-Bin #190 - Oasm ReUp

Oasm ReUp
Posted by: Yo mamma | November 12, 2008 @ 4:19pm

Revision 1 - Original post on November 12, 2008 @ 4:18pm

Other Code

/*
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 */

Syntax Highlighting

[Open in new window]

Author Comments

Forgot Password!
Version 1: New code

Rating

4.62 / 8
203 Votes