h2o in vaporware.... codename: steam
H20 ... currently in vapour phase ;D
That is brutal sentence ;D
Sounds good,
Petr
Learn 3D graphics with ThinBASIC, learn TBGL!
Windows 10 64bit - Intel Core i5-3350P @ 3.1GHz - 16 GB RAM - NVIDIA GeForce GTX 1050 Ti 4GB
h2o in vaporware.... codename: steam
Acer Notebook: Win 10 Home 64 Bit, Core i7-4702MQ @ 2.2Ghz, 12 GB RAM, nVidia GTX 760M and Intel HD 4600
Raspberry Pi 3: Raspbian OS use for Home Samba Server and Test HTTP Server
Vaporware can be very useful for planning I want to make sure that Asmosphere is complete as a programing layer, so looking ahead informs current development. It should be fairly easy to mix several languages in the same script - with their various syntax rules and paradigms as long as they can be rendered to machine code ( and always close their brackets! )
basic (
...
)
pascal (
)
or nested together:
basic (
asm (
o2 (
)
)
)
Totally wild things you put out Charles. Makes my love for computers even grow stronger in knowing that there is still so much I don't know after all these years!
Acer Notebook: Win 10 Home 64 Bit, Core i7-4702MQ @ 2.2Ghz, 12 GB RAM, nVidia GTX 760M and Intel HD 4600
Raspberry Pi 3: Raspbian OS use for Home Samba Server and Test HTTP Server
The important thing is to adopt widely used standards wherever possible, so as to avoid total alienation
Currently asmosphere uses very simple macros without a parameter facility. For the next release, I'm going to extend it by adopting something that DOS batch files use since it is very simple and efficient to use: each parameter is represented by %1 %2 %3 etc.
To show how this will be implemented in Asmosphere
this macro returns the address of a single dimensional array element:
note that the expression v ( 42 ) has 4 elements represented inside the macro as: v %1 ( %2 42 %3 ) %4
Another thing to note is that the macro definition does not use a prototype, the macro simply 'eats' as many words from the invocation line as it requires.
array1_ptr v(42)
def array1_ptr
(
mov eax, sizeof %1
imul eax,eax,%3
lea edx,%1
add eax,edx
)
supposing v might be something like [ebp-1000] with elements of 8 bytes each;
then this macro would expand to:
[b]
mov eax,8
imul eax,eax,42
lea edx, [ebp-1000]
add eax,edx
[b]
These macros are cool. Reminds me of all the cool things they are doing with templates in c++, but nothing approaches supporting different languages in the same source. You are really thinking abstractly that is wonderful!
Acer Notebook: Win 10 Home 64 Bit, Core i7-4702MQ @ 2.2Ghz, 12 GB RAM, nVidia GTX 760M and Intel HD 4600
Raspberry Pi 3: Raspbian OS use for Home Samba Server and Test HTTP Server
Thanks Kent, I had'nt really thought of it as abstraction, but its true. This exercise helps to identify the fundamental building blocks for programming.
So far we have:
language (...) ' embedded language.
def (...) ' define macros.
type (...) ' define data structures.
var (...) ' map variables.
skip (..) ' ignore block.
but thinking about a system for generating sound, there is a large amount of initial values and default data to set up. To do this efficiently, we will definitely need a data block to complete the set
data (..) ' define inline data block
This could be any form of embedded database but if it is set up as a table with fixed length columns then an array variable of matching Type can be mapped on to it, for simple access.
Looks very good.... was wondering... could you create something as following, where all of these building blocks could be like this:
language (...) ' embedded language.
def (...) ' define macros.
type (...) ' define data structures.
var (...) ' map variables.
skip (..) ' ignore block.
data(..)
class ()
...language()
...vars( these could also hold pointers to data((..))
...funcs()
Acer Notebook: Win 10 Home 64 Bit, Core i7-4702MQ @ 2.2Ghz, 12 GB RAM, nVidia GTX 760M and Intel HD 4600
Raspberry Pi 3: Raspbian OS use for Home Samba Server and Test HTTP Server
Class is equivalent to Type which can include any kind of data elements including function pointers, or pointers to table of function pointers.
Types can embed previously defined types in themselves or include these types as a basic form of inheritance.
C++ classes of course have a lot more specialised items in them - much to do with restricting access.
To go a bit more abstract: def () type() var() are specialised forms of a block (..)
Unqualified blocks are used to define scope which means that labels, macros, structures as well as variables can be made local - indeed most words and symbols can be temporarily redefined, reverting to the original when the block ends. Local functions can also be defined, being visible only inside the block. ( This could be awesome or awful can't decide which )
Having that ability seems like a big plus to me, but I guess it could also be confusing... but when you think of how much you have to understand what you are doing with this stuff, you should be able to tell the scope of a variable in that point of the code
Acer Notebook: Win 10 Home 64 Bit, Core i7-4702MQ @ 2.2Ghz, 12 GB RAM, nVidia GTX 760M and Intel HD 4600
Raspberry Pi 3: Raspbian OS use for Home Samba Server and Test HTTP Server
Bookmarks