--- /dev/null
+
+Types have a per-module namespace.
+This is pre-populated with
+ int i8 i16 uint u8 u64 etc
+ num float f64 f128
+ Bool
+ byte
+ char string
+
+Types can be added with:
+
+ struct name: content
+ record name: content
+ enum name: content
+ class name: content
+
+ name is optional, and can list (parameters) and /attributes
+
+Types can be constructed with
+
+ name(args) parameterized type
+ name^ reference type
+ name[size] array type
+ (args:: args) procedure type
+ (args:: type) function type
+
+
+The content of struct and record are a list of:
+ fieldname: type
+ or
+ fieldname/attribute: type
+
+ 'attribute' can:
+ indicate endianness - bigendian littleendian hostendian
+ 'const' ??
+ identify a refcount,
+ protected by a given lock??
+
+ For enum, content is list of
+ name = value
+ where "= value" is optional
+
+Pointers:
+ to assign a pointer, use foo = stuff
+ to update what the pointer points to, use foo^ = stuff
+ to get a reference to store in a pointer....
+ references are either borrowed or owned.
+ a name defined "type^" is a borrowed reference, a name defined
+ "type@" is owned.
+ borrowed references may be taken of anything, but only remain defined
+ as long as the owner remains defined.
+ owned references can only be taken of ownable objects, and
+ remain indefinitely.
+
+ There are various ways to own an object:
+ - refcount or lock
+ - ownership of a containing object.
+ - ownership provided by class method
+
+non-type names (vars, constants) can be introduced with
+
+const prefix: name = value; ...
+func: name(args::type): statements
+proc: name(args::result): statements
+
+main: statements
+init:
+exit:
+
+
+enum name: values
+
+
+Plan:
+ decide on data structure
+ different types can't really be handled by a big switch now,
+ I probably need and object with function pointers.
+ free_value(), vtype_compat(), val_init(),
+ dup_value(), value_cmp(), print_value(), parse_value()
+
+ parse_value only needed for args - str and num
+ val_init...
+ print_value - only needed for print and code-dump
+ dup_value - needed until pointers can make sense
+ vtype_compat - needed for various things
+ value_cmp - needed until we have object behaviours
+
+ pre-defined
+ Bool
+ int - sizes
+ char
+ string
+ array
+ I think I need to disassociate the type from the storage.
+ So a 'value' is a parsed constant, but something new is needed for
+ the content of a variable.
+ const
+ struct
+
+----------
+
+ I currently have an enum of types that is used to test compatability
+ and for propagation.
+ This needs to change .... I guess I need a struct type* What goes in it?
+ - name
+ - scalar/record/struct/array/pointer/func/enum
+ - other details.
+
+ Do I need forward declarations? Maybe I can just be lazy and
+ require everything to be declared eventually.
+ That isn't sufficient for:
+ - mutually recursive functions
+ - mutually recursive structures
+
+ What about unions ???
+ blend with enum: a tag with fields?
+ struct name:
+ x:int; y:int
+
+ .Bool.true = a:char; b:char
+ .Bool.false = ......
+
+ Are enums just a fancy way of doing 'const'?
+ I could have
+ const: a=1; b=2; c; d
+ which defines module-wide consts.
+ And separately have
+ enum foo: a, b, c
+ which defines consts foo.a foo.b foo.c
+ But I don't really like foo entering the val namespace.
+ If bar:foo, then bar.a could be true/false depending on value of bar.
+ bar.a! could set it?? bar.a=true?
+ var = .foo.a
+
+ How do we allocate new objects?
+ new(type) ???
+ ptrname = new ??
+ new(ptrname)
+ ptrname := new(type)
+
+ Maybe ^= assigns a borrowed reference, and @= assigns an owned reference.
+
+ allocating isn't really a top priority, so I should just focus on
+ non-allocated types.
code / ocean-D / blobdiff