Inline code..

Function MyFunc:Int( Value:Int, Value2:Int )
Local Val:Int
InlineCpp {
   #includes <iostream, stdio, conio>

   cout << ( Value *Value2 ) << endl;
   Val = Value *Value2
}
return( Val )
End Function

global sum:int

function add:int( val:int ) native "c++"
   @sum=@sum+val; 
   return @sum;
end

#Import "blah.cpp"
#Import "blah/INCLUDE/*.h"

alias WCHAR:short
alias DWORD:int
alias LPSTR:bye ptr
alias LPCSTR:byte ptr
alias LPWSTR:short ptr
alias LPCWSTR:short ptr

extern

function _InitBlah:void( name:LPCWSTR Ptr )="initBlah"

public

function InitBlah:void( name:String ) native "c++"
   WCHAR *_name=@...();
   _initBlah( _name );
   @name.Discard( _name );
end

Method GetIndex:Int(x:Int, y:Int) Inline

!#pragma comment(lib, "MSVCRT -VERBOSE")
!#pragma comment(linker, "<linker options>")
!#pragma comment(lib, "xxx.lib")

!#include <freeglut.h>

Function MyFunc(var:int, var2:ulong)
    ! unsigned long myvar;
    !
    ! // do something here
    ! myvar = var + var2;
    ! cout << "woohoo my var is " << myvar << endl;
    !
    ! return myvar;
End

Function SHR(var:int, value:int)
    ! return ((unsigned int)var >> value);
End

Function InlineAsm()
    !//
    !// C++ code
    !//
    !asm {
        #if COMPILER_PROCESSOR = MX2_PROCESSOR_X64
            #if COMPILER_OS = MX2_OS_MACOSX
                ! 64-bit ASM code for Mac
            #elseif COMPILER_OS = MX2_OS_LINUX
                ! 64-bit ASM code for Linux
            #elseif COMPILER_OS = MX2_OS_WINDOWS
                ! 64-bit ASM code for Windows
            #else
                CompilerError "unsupported target"
            #endif
        #elseif COMPILER_PROCESSOR = MX2_PROCESSOR_X86
            #Select COMPILER_OS
                #Case MX2_OS_MACOSX
                    ! 32-bit ASM code for MacOSX
                #Case MX2_OS_LINUX
                    ! 32-bit ASM code for Linux
                #Case MX2_OS_WINDOWS
                    ! 32-bit ASM code for Windows
                #Default
                    CompilerError "unsupported target"
            #EndSelect
        #elseif COMPILER_PROCESSOR = MX2_PROCESSOR_ARMv7
            ! ARM target code
        #else
            CompilerError "unsupported target"
        #endif
    !}
    !//
    !// more C++ code
    !//
End

1+2
!5

NativeCode
   std::cout << "hello monkey" << std::endl;
   asm {
      NOP
   }
End

Procedure myProc(x,y)
    CompilerIf #PB_Compiler_Processor = #PB_Processor_x86
        ! MOV EAX, [p.v_x]
        ! ADD EAX, [p.v_y]
        ProcedureReturn
    CompilerElseIf #PB_Compiler_Processor = #PB_Processor_x64
        ! MOV RAX, [p.v_x]
        ! ADD RAX, [p.v_y]
        ProcedureReturn
    CompilerElse
        CompilerError "unsupported processor"
    CompilerEndIf
EndProcedure

z = myProc( 10, 7 )
Debug z              ; outputs '17' in Debugger output window

; x86 assembly example
;
Test = 10

EnableASM
    MOV dword [v_Test],20
DisableASM
  
Debug Test ; Will be 20

NativeCode "cpp"
    ...
End

#Native "C"
// stuff here
#EndNative

Local foo:Int
#Native "C"
${foo} = 10;
#EndNative

NativeCode
    #pragma comment(linker, "<linker options>")
    #pragma comment(lib, "freeglut.lib")

    #include <freeglut.h>

    int myFunction(int x) {
        return x * x;
    }
End

Extern
    ' function declarations
    ' ...

Public

Function Test:Int(x:Int)
    Local returnVal:int
    Print "Test()"

    NativeCode
        // native code
        std::cout << "Test() - native code" << std::endl;

        MXLOCAL(returnVal) = MXARG(x) * MXARG(x);

        MXLOCAL(returnVal) = myFunction( MXARG(x) );
    End

    return returnVal
End

Function Samah:Int(x:Int)
    Local returnVal:int
    Print "Samah()"

    NativeCode
        // native code
        std::cout << "Samah() - native code" << std::endl;

        $(returnVal) = $(x) * $(x);

        $(returnVal) = myFunction( $(x) );
    End

    return returnVal
End

Function WithoutSubstitution:Int(x:Int)
    Local returnVal:int
    Print "WithoutSubstitution()"

    NativeCode
        // native code
        std::cout << "WithoutSubstitution() - native code" << std::endl;

        mx_returnVal = mx_x * mx_x;

        mx_returnVal = myFunction( mx_x );
    End

    return returnVal
End

'...

Function Blah()
	NativeCode
		int a = 10;
		int *b = &a;
	End
End

Function Blah()
    #IF TARGET = "JAVA"
        NativeCode
            // Java code here
        End
    #ELSEIF TARGET = "CPP"
        NativeCode
            // C++ code here
        End
    #ENDIF
End

#IF TARGET = "JAVA"

    Function Blah()
        NativeCode
            // Java code here
        End
    End

#ELSEIF TARGET = "CPP"

    Function Blah()
        NativeCode
            // C++ code here
        End
    End

#ENDIF