Please read the disclaimer at the bottom, since I don’t have the money or power to get a grant for ANYTHING.

**   If you’re going to use this for any reason, like building a compiler (difficult for most of people), or something else of more value than personal use, then at least give me credit.

Similar to C++, this self-programmable language contains scripting elements that can compile or create other languages.  It might (and who wouldn’t emphasize “might”) be the most advanced, most constructive (and really powerful) programming language available.  It might also be the fastest to learn, since it’s closer to spoken language, though it is still flexible at a low level.
Programming can make you a nerd, so let the compiler do the work, instead; so you don’t need to put in the same stuff, over, and over.......
-- putting a compiler with this self-programmable language on idle, and you could generate an A.I.
(artificial intelligence)

Some symbols on this page may not show up correctly due to the limitation on the number of mathematical symbols HTML has.

Names with an asterisk (*) mean that they are not optional or existent in C.
There may be more names that aren’t applicable to other languages.

And, what kicked off this language in whole:

“bare” structures.

“Bare” structures are the results of leaving out the brackets, and in simplifying the whole equation, it bends the rules.

This language is heavily object-oriented, so everything has no non-specific order.  

Putting an identifier before a structure or an identifier that holds the type of a structure would force the compiled program to translate every entry within the structure to fit.
-- excellent for converting endian formats between platforms
Functions, Macros, and Commands, all are parsed in a run-on fashion, using identifiers to form, what is called, “glue,” taking every word, as it comes, and acting differently only on the defined concepts.

Every symbol has it’s own mathematical significance.

Brackets are not needed in commands, just as long as the “end” identifier is found on the ending line.  The name of the label is also allowed.
   Sample- Example code: (whatever)

int initialize()
{
    if (something)
    {
        loop
        {
            -- code
            whatever(something);
        } until something;
        -[
            the brackets are not needed for routines that have only one line
        ]-
        loop until something
    }
    -- code
}

function int main() -- the term “function” is needed for Bare functions
-- (the English term for routines or functions that end with the English term “end”)
  if (this) then -- “then” is required
    loop until something for -- again, specific commands, like,
    -- loops and conditionals require the English terms that set up
    -- where the brackets left off are required for Bare functions
    end loop; -- “loop” is not needed, but it helps the user know what’s end ing
  end if; -- “if” is also not needed
  whatever();
end main; -- the label “main” isn’t needed, but allowed if it matches a relative name
-- another relative name, that can be used in main’s place, is “function”

-- neither brackets nor “end” is needed for routines that have only one line
function int whatever(done.b)
    -[ more code ]-;

See the resemblance to HyperTalk? Well, HyperTalk can be compiled by replacing and ignoring certain identifiers, like, telling the compiler that the semi-colon (;) is now the “end of line”, and ignoring “loop”.

The structures

struct the_sound (global FLAGS.stereo) ? {left.channel, right.channel} : {mono.channel};

Conditionals in structures?

Yep. Just like Rez files, my programming experience has led me to take advantage of the concept, and put it into the language.

What’s with the “global” thing?

To tell the compiler where it’s coming from without having to define a “class”.

Dots for the thingamajig thing?

What?! Oh, the Type Record.
count.l, the_sound[count+1];

Why is “count+1” in the array for “the_sound”?

That sets the number of “the_sound’. This is called a “Variable Sized Array”.
Calling “sizeof(the_sound)” would require calculation code in the program.
Calling “class(sizeof(the_sound))” would return “variable”.

What’s the “l” for?

The post fix, “l,” defines “count” as a Long integer (32 bits on low end computers).
 NOTE: Structures are bit aligned, not byte aligned. Multiple byte alignment can be done with the “align” object, whenever necessary, and can be done automatically by the compiler or added using high level code.

Structure size definitions

Putting a number in parenthesis directly after a structure name within the definition sets the size of the structure, in bytes.  If the structure definition is not byte aligned, then the packed contents is shifted to the right to force alignment.  Size definitions are required if the definition of the structure, itself, is not available.
This can be done using the import command:

import name(size)

Here’s the list of all of ’em:

• *Strings* - well, nothing that can’t be added using high level commands

String Concatenation
  Like in Java, the plus character (+) concatenates strings -- but in a low-level approach.

• *Values*

The default numeric type can be set using the “numeric” directive

prefixed
# or d	Decimal (default)
$ or 0x or h	Hexadecimal
0 (zero) or o	Octal
% or b	*Binary
'..'	Literal
post fixed
d	*Decimal
h	*Hexadecimal
o	*Octal
(preferenced)
f	Floating Point
l	Long Extended
u	Unsigned
(high level - case sensitive)
K	Kilo (*1e+3) or (<<10) depending on type
M	Mega (*1e+6) or (<<20) " "
G	Giga (*1e+9) or (<<30) " "
T	Terra (*1e+12) or (<<40) " "
Q	Quadr (*1e+15) or (<<50) " "
m	milli- (/1e-3)
µ	micro- (/1e-6) -- this is a “token”
n	nano- (/1e-9)
p	pico- (/1e-12)

Examples:

32456UL

(scale methodizing)

byte store[5M]

farads[5p]

88 = d88 = 88d = #88 =
0x58 = 58h = $58 = h58 =
b1011000 = 1011000b = %0101 1000 =
0130 = o130 = 130o

• *Expressions*

A symbol before an identifier changes it’s value within the expression, but if the symbol comes after it, then the value of the identifier gets affected afterward.

Trailing single

arithmetic self modifiers

-	Negate
+	*Absolute Value	Takes the negative sign off if existing (does nothing on unsigned values)

NOTE: unlike C, self expressions change themselves in post modifying mode
Examples:

~x;  the bits in “x” are inverted
...1+(y-)  ... Negates ‘y’ after the rest of the expression is evaluated
...x+(y+)  ... ‘y’ becomes it’s absolute value after it’s current value is evaluated in the expression

Leading single

boolean
!	Not	sets to non zero if zero and vice versa
binary
~	Not	inverts all bits in the expression
#	*Count	retrieves a fundamental count -- can use plural names!
addressing
&	Effective address
@	*At Index	a temporary index of an array

Temporary indexing eliminates the tiresome method of having to recreate a pointer for an array, time, after time. While a variable pointer only uses the stack or one of the few registers available, “At” indices try to use all they can, since they’re temporary

WARNING: “At” temporary pointers get destroyed once they’ve become irrelevant.

Example:

    periodic_element mixture[5] -- five maximum
    @mixture = 1; -- sets the temporary index pointer to 1

    -- this destroys “@mixture”
    periodic_element *index = &mixture;

Dual

x &^ y : 0x1D
-- Only ones in 0x1D (11101 in binary) get set to the value of the
-- according bits in “y” for the value within the expression

NOTE: incrementing, decrementing, squaring are really a self modifier without an expression, filling in the gap with either one or two (depending on whether it would do anything).

Examples:

x+=;      -- adds 1 to “x” by 1
y*=;      -- Squares “y”
y = =+x;  -- adds 1 to “x” after setting “y” to “x” (notice the symbol’s in reverse)

indirection variable Pointer with address increment (similar to assembly)

-- Must have the pointer variable in parenthesis

Post increment

*(aptr)+  or  *(aptr+=)

Pre increment

*+(aptr)  or  *(=+aptr)

Post decrement

*(aptr)-  or  *(aptr-=)

Pre decrement

*-(aptr)  or  *(=-aptr)

NOTE: different sizes can be used by attaching a type record, such as “*(aptr.h)+” The Effective address symbol can also be used with it (&*(aptr)+)

*aptr+=    adds 1 to the value at address aptr

Pointers or arrays modify the index of it:

@color-    negates the index, which results in the index subtracting from the opposite end

currency bills[1...4]; -- four bills of different value
@bills = 1; -- sets the index to the first
@bills-;    -- flips it around to wind up at 4

*index+;    -- will correct the pointer if it is out of bounds

NOTE: “overflow +aptr” will return a boolean on whether it is bad pointer

• *Bit Fields*

Old fashioned Structure

struct
{
    ...
    size object:width, object:width....
    ...
}

struct structurename .... object:width, object:width....

NOTE: a “U” or an “S” before the number represents the sign (the default is usually unsigned)

Expressional
  object{offset:width}

Examples:

struct hex hi:u4, lo:u4;
-- Splits whatever container that is defined as a “hex” into two unsigned four bit
parts (or nybbles)

z = y+x{1:3};
-- Takes the bits after the first within the “x” container.
-- An error will occur if the specified field is too large, has a negative field width,
or does not exist.

• *Arrays*

Structured
[count] a count (indexed at 0)
[a..b] from a to b (from Pascal) if ‘a’ is zero, then the array will act as a single count
[xxx][xxx] matrix

Definition
{a,b,c...,z}    entries to make up the storage

NOTE: unlike C, arrays can be put on bit fields and register variables

Numbered Record

   For multiple names within a structure
Sample (from the HyperCard stack format):

stackFormat.h =
  enum
  {
      invalid,
      preRelease.1 .. version.1 = 8,
      preRelease.2, version.2 = 10 .. newer
  };

myFormat.h = strict   -- `strict' inhibits the usage of the following terms in other means
  enum
  {
      who_knows,
      whocares,
      get_away
  };

• *Comment Symbols*

• *Loops*

Sample macro code for square root:

loop with (1<<(s::)/2) ratio 2 (s/result) until +delta≤1;

• *Identifier Sequences*

Putting objects within brackets after an identifier (with the exception of structure and union definitions) means that whatever objects that are in the space between the brackets are of property of the identifier.

For example:

stuff_in_my_pocket
{
    copper coin;
    plastic button;
}

“copper coin” and “plastic button” are now properties of “stuff_in_my_pocket”.
Because “coin” is set up only with “stuff_in_my_pocket copper”, “coin” is not defined by itself.  Because of this, “coin” by itself is yet unrecognized, and not a property of “stuff_in_my_pocket”; neither is “button”, for the same reason.

• *Bit Enumeration*

Putting a colon after an ‘enum’ instead of brackets means that the names that follow represent a structure field as an unlimited sized integer, only going from bottom to top.  In other words, it’s enumeration that represent values of a power of two.

For example:

ThingFlags enum:
    something,
    another;

‘something’ points to the least significant bit of ‘ThingFlags’ (bit zero), and ‘another’ to bit one.

• *Previous Expression Comparison*

Using only symbol that represents comparison (a.k.a inequality) act in the condition for which that symbol would act toward the previous expression.

For example:

if (3<4) doThat();  if (>) doThis();
return (a==b) ? 0 : ((>) ? 1 : -1);
b = a, positive = (>);       -- comparison with zero

• *Parameter Keywords*

Putting a type after a variable creates a keyword, and the parameter setup becomes more flexible.

For example:

-- (somewhere along the text, maybe in a header)
typedef tablespoon Fixed32;   -- ‘Fixed32’ is already defined as 32:32 bits for high accuracy precision
fixed point values

int water(amount tablespoons);    -- plural names are acceptable

void fill_it_up()
{
    water(amount 3);
    water(amount 3 tablespoons);   -- the same as (tablespoons)3 or tablespoons(3)
}

• *Special*

command routines

if  or  do..if

(high level - can be used in structures and macros)
These are predefined in the language, and are temporarily removeable.

structure elements

ignore  or  unused   or  unknown
align

format defined attributes

-- you can keep adding more, and more until your hard drive and memory space fills
and no more having to build functions for simple operations; let the compiler do it.

Format definitions can be inlined for debugging or compression
(maybe be done automatically by the compiler)

relative attributes

elem or element or fundamental	class warfare!! -- no, identifier
none	no element -- must be defined to be used
all, each	glue
for, with or  using or  given	“loop” and “macro” glue
error, delta or  δ	math
index
first	index to an array -- DUH
last	(ditto)
next	index to array and/or loop iteration
ptr, pointer, handle, handler	also accessible by using the “class” function (so you don’t have to look at the header files to know what the-
ratio, from, to, while, until	for the “loop” command - one liner? Easy! an “element” defined loop depends on the size of the element
leading	(identifies from “lead”)
trailing	(identifies from “trail”)
heading	(identifies from a header)
failure	in response of a function
overflow or clipped
protected	goes beyond a “const” at protecting data
scanned
endian	endian byte order
BCD	Binary Coded Decimal (case sensitive)
cherished	okay... maybe I’m going too far

NOTE: Relative Attributes that aren’t defined to the compiler can’t be acted upon, but can still
be used as identifiers.
Example:

float width x, height y;
-- ‘width’ and ‘height’ are not recognized, but they are still parsed without error
-- assuming they are to seperate their types from other variables

float   x;

x = thing.x;
-- this will generate a warning, due to the fact that
-- x is defined to be only a ‘float’, and not a ‘width float’

high level single array functions
(using the “loop” command)

largest()  or  max()
smallest()  or  min()	Identifiers: lowest, highest
pin()	to keep the middle value within boundaries
arithmetic standard
product()
sum()
mean()  or  average()	(sum/count)
median()	middle number (or average of the remaining middle numbers)
mode()	most occurring (or average of the same most occurring)
lcd()	lowest common denominator
factors()	builds an array of the prime factors of a number or returns an index in ascending specific order
find()
restore()
random()	aren’t “randomizers” fun?

* and the “bare” bones - the preprocessed directives * What creates high level commands, and can replace or disable objects to emulate other programming languages at compilation time.
They can be grouped, and multiply defined when put in brackets.
They start with the pound or number character (#), and are also called “macros”.

(already existing)
define  or  substitute:	to name a label to that gets replaced with a certain text
undef  or  rid:	to delete a define’d label, if it exists
insert file, import, or include:	to add text of another file to the file in memory
pragma:	compiler specific settings
if, else, endif, elif, elseif:	conditionals
ifdef, ifndef:	“define” conditionals
(errors and warnings, usually used with conditional macros)
error:	gives an error at compilation time
obsolete, warning:	gives a warning at compilation time for whatever reason
(new)
concept:	the fundamental magic of this whole language uses compiler-native op-codes to generate new format defined attributes and is really hectic if you don’t have much patience
plural:	defines the only plural name or a list of names for an identifier
Example: #plural mouse mice -- “mouses” no longer works since it’s not in the list of new plural names
ignore  or  disable:	disable a term or directive
revive  or  enable:	enable a previously disabled term or directive
numeric:	parameters for either a base number or a concept

preprocessed functions and constants

defined()
exists()
sizeof()
offset()
class()
__option()

__FILE__
__LINE__
__TIME__
__DATE__
__RESULT__

file

Index

Structures

size definition

Types

Strings

Values

Expressions

singular
dual
indirection

temporary pointer

Bit Fields

Comment symbols

Loops

Identifier Sequences

Bit Enumeration

Previous Expression Comparison

Parameter Keywords

Special

command routines
format defined attributes
relative attributes
high level single array functions
preprocessed directives

This programming language is based on C, and contains elements of other languages, such as Java, Pascal, HyperTalk, and Visual Basic.
I have no known connection to anybody that developed any programming languages, which includes the ones previously mentioned.
This text and any software generated for it is made out of will and convenience in the public domain. This comes without a warranty, copyright or patent, and is non-profit.  Neither I nor mentioned companies or entities are responsible for any actions, opinions, damage this file or related software may cause.
THE USER IS SOLELY RESPONSIBLE FOR DAMAGE CREATED BY USE OR MISUSE OF THIS FILE OR RELATED SOFTWARE.  USE AT YOUR OWN RISK.

HyperTalk is the language of HyperCard, a registered product and trademark of Apple Computer, Inc. ©1987-1998.
All other names may or may not be trademarks and/or registered trademarks of their respected owners.
All Rights Reserved.

Any legitimately offensive material may be taken out on request.

I’m trying not to go out of my league.