OSDev.org

Code: Select all

(int) Return4 = ()
{
   return (4);
}

(int,unsigned int)ReturnNumTwice = (int no)
{
    return (no, (unsigned int)no);
}

~class SomeClass =
{
   public:
      (SomeClass *)SomeClass = ();
      ~SomeClass = ();

   private:
      (int) someMember;
}


() Main = ()
{
   (int) myVar = Return4;
   // myVar now equals 4
   (int, unsigned int) nums = ReturnNumTwice(myVar);
}

Code: Select all

<Application
	Name="AcessOS XMLA Test"
	Version="1.0"
	Category="dev"
	Author="thePowersGang" >
	<Code>
	<![CDATA[
function TextboxKeydown(Entity: self; Integer: keycode): Integer
{
	if(keycode == KEYSYM_RETURN)
	{
		Core.MessageBox(self.contents);
	}
}
]]>
	</Code>
	<Window id="mainwin" title="AcessOS XMLA Test" width="200" height="200">
		<Element
			type="TextBox" id="mainInput"
			x="100" y="100"
			width="80" height="30"
			onKeyDown="TextboxKeydown"
			value="Test Box" />
	</Window>
</Application>

Code: Select all

import Kernel;
import GraphicsIPC;
import GC;
import String;

namespace default
{   
  use GC; // Garbagecollection by default
  use String::autotostring; //allow automatic conversion to string

  function getframebuffer () returns (boolean *, -GC void ptr framebufferaddress)
  {
    Log("initializing framebuffer");
    Kernel::AllocatePageDirectory(0xE0000000, -1);
    (boolean b, String s) = GraphicsIPC::RequestFramebufferAccess()
    if (!b) { Log(s); return (b, null); }
    Log("Framebuffer access granted");
    (framebufferaddress, int bytes,*) = GraphicsIPC::GetFramebufferProperties();
    Log("Framebuffer base address at 0x" + framebufferaddress + String::NEWLINE);
 
    processif (Compiler::Arch == ARCH_I386)
      subsection
      {       
        use Kernel::Registers;
        directive exclusive([edi,eax,ecx]);

        edi = framebufferaddress;
        ecx = bytes >> 2; // will compute bytes
        eax = 0;
        asm "cld";
        asm "rep stosd";
      }
    else 
      memclear(framebufferaddress, bytes);

    // return success, the lfb address was already set.
    return (true, *);
  }

  // etc

Code: Select all

int start:
.variables
32 hello := "Hello World!",0;  \\variables are declared by bit size not by type
32 output;  \\Since hello isnt a pointer all you can access is the 'H' in this form
.code
push output; \\reliqueshes both its value and its name.  If this isnt done then the address of output is written over to point to the function's output.
precall printf;  \\precall inits all variables marked with pre for passing purposes
output = hello;
call printf;
pop output; \\gets both back now that output isnt in use
start := END_SUCCESSFULL;
end;

int printf:
.variables
16 x := 0;  \\These two variables dont exist until call printf
32 char current;
32* char output (pre);  \\This pointer is preinitialized.  Pointer is the only variable type in this whole language.
.code
current := output[x];  \\Array stuff can be done on pointers with the address in question incing the variable size every element
while (current != 0);
\\Code to print the letter to screen
x++;
current := output[x];
end while;
ret SUCCESS;  \\sets the value of printf and returns

Code: Select all

#struct test
int number
string id
#endstruct


#object printfun
test m
int i=5
string s="Salil is good"
(i>0) {
	()printstring(s)
	()dec(i)
	()printnumber(m.number)
}
#endobject

Code: Select all

use lib std;
use inc "include_file.h"

int, char function_test(int x)
{
       return x, 't';
}

int main ()
{
       int h, x=0;
       write("Hello. Does x==0? %?\n", (does (x==0)?));
       char d;
       h, d = function_test(5);
       if(h==5)
              write("five\n");
       return 0;
}

Code: Select all

Hello. Does x==0? Yes
five

Code: Select all

/* reserved keywords
	define, signed, struct, class, function, while, for, do, extern, return, this, new, delete, operator, static, asm

	The C preprocessor will run through the sources files first
*/


define signed 4 MyGlobalVariable

struct hello
	signed 4 Foo
	unsigned 4 Bar

extern class someClassInAnotherFile
extern struct someStructInAnotherFile

class someBaseClass
	function someMemberFunc() signed 4
		printf("this is someClass, my address is %d\n", (unsigned 4)(deref this))

	operator new() // called when class is created
		Foo = 5

	operator +(ref someClass)
		Foo += someClass.Foo

	virtual someMemberFunc2()

	invisible
		signed 4 Foo

class anotherBaseClass
	// empty class

class someChildClass extend someBaseClass anotherBaseClass
	function someMemberFunc2()
		// overwrites above member - does nothing

	function multiply2Numbers(signed 4 numA, signed 4 numB)
		return numA * numB


function main()
	define someChildClass HiThere
	define ref someChildClass HiThere2 = ref HiThere // ref HiThere accesses the address of the variable
	(deref HiThere2).someMemberFunc()
	(deref (ref someBaseClass)HiThere2).someMemberFunc()	// you can also type cast references

	define signed 4 ACounter = 0
	while ACounter < 10
		printf("%d ",ACounter)

	for ACounter = 0; ACounter < 5; ACounter++
		printf("%d ",Acounter)

	someChildClass = new someChildClass // dynamically allocate it
	delete someChildClass // dynamically destroy it

		define unsigned 8 AnotherVar // local scope only because it's indented

		asm
			eax = AnotherVar // all you can do in asm blocks is move variables in/out of registers
			"int 100" // and call assembly instructions
			AnotherVar = eax