smackem/ylang

An image manipulation language

ylang's Issues

Replace map_* function with fetch*() and put() functions

• Rename map_* functions to fetchR, fetchG etc
• Add the put(pos, kernelR, kernelG, kernelB, kernelA) method
  • Sets all pixels hit by the kernels around pos

Change kernel syntax

replace [] with || for kernels:

|1 2 1
 2 4 2
 1 2 1|

[] should be used for lists

Function to create polygon from list of points

polygonFromList([0;10, 100;10, 12;12])

Function for creating non-quadratic kernels (arrays)

Add function kernel(count) to create a non-quadratic kernel with count elements that can be used like an array

Add README

Add a real README with language description, sample code and images

Bindings with uppercase idents should be constant

All bindings written in uppercase (like IMAGE/BOUNDS, BLACK) - whether script-defined or pre-defined, should not be assignable.

Indexed value assignment

k := list(10, 0)
k[1] = 1

Add intersect function

intersect(line(0;0, 100;100), line(0;100, 100;0))

should return 50;50
returns nil when there is no intersection

Change number format to float32

lang.Number should point to float32 instead of float64.
convert entire image when loading to lang.Number format, convert back on save

nil should point to constant

nil in ylang is represented by the golang nil value. this leads to golang runtime errors on nil dereference.
better introduce a constant of type nilValue that implements value to represent ylang's nil

Add polygon type

polygon(10;20, 40;23, 100;40)

creates a closed polygon, which can be iterated like a rect or a line

Ellipse type

e := ellipse(10;10, 200) // center, radius
for p in e {
    ....

Complete test cases for values

Foreach value type, create a unit test file that uses compileAndInterpret to test the value implementation.

Create symbol table to report positions from interpreter

each ast element should be associated (via map of instance to some Position) to a Position as generated by the lexer like this:

	harald := person{"harald", 10}
	herbert := person{"herbert", 20}
	harald2 := person{"harald", 10}

	m := map[interface{}]int{
		&harald: 100,
		&herbert: 200,
		&harald2: 500,
	}

	fmt.Printf("%+v: %d\n", harald, m[&harald])
	fmt.Printf("%+v: %d\n", harald2, m[&harald2])

Add pre-defined values

add bindings for pre-defined values IMAGE(rect), W, H, BLACK, WHITE

Syntax highlighting support for monaco editor

Add line function

Use DDA for line function that works like rect:

for pos in line(10;10, 100;200) {
  @pos = #FF0000
}

log() through BitmapContext

add method log(string) to BitmapContext and use it for generating output instead of just calling printf

Add function definitions

def fun(x, y) {
return x + y
}

Add significant new-lines

only new-lines after these tokens (that cannot close a statement) are ignored:

{
[
(
=
:=
,
;

significant new-lines close statements and break scanlines in kernel definitions. this enables kernel expressions with non-quadratic number of values like

[1 0 1
 2 0 2]

new-lines can be escaped with `:

if x < 0`
or x > max {
    ...

requires #16.

Support for Closures

In the following snippet,

fn(x) {
  y := x * x
  doit(fn() -> x + y)
}

the lambda function passed to doit should capture x and y.

Fix point syntax precedence

@((p1.x - 1);(p1.y - 1)) = #ffffff is embarassing
should be
@(p1.x - 1; p1.y - 1) = #ffffff

Add varargs functions

polygon(10;20, 100;23, 33;403, 123;20, 32;32)

Ability to resize output image

Add resize(w, h) statement

Add math functions

re-do function system to provide a mechanism for registering built-in functions that are known at parse time.
then implement sin, cos, tan, asin, acos, atan, atan2, sqrt etc.

Support clip rect

new function clip(rc):
with rc = rect -> set clip rectangle to rc
with rc = nil -> remove clip rectangle
e.g.
after clip(Bounds) you can safely write anywhere without segfault

Support hashmap type

h := { p1: 0;0, p2: 100;200 }
for p in line(h.p1, h.p2) {...

Implement mapping function

Implement a function that maps a kernel, returning a sub-image (kernel of colors)

Bitwise operators

| - bitor
& - bitand
^ - bitxor
~ - bitnot
<< - leftshift
>> - rightshift

Support HTML-like color literals

Support "#112233", "#112233FF", "#123", "#123F"

Support step width in for-range statement

for angle in 0 .. 15 .. 360

Put indexer operator into value interface

right now, indexing like k[0] is handled by the interpreter, exclusively for kernels. it should be a feature of interface value. required for list types

Debug recursion over map/list data structure

Consolidate parse errors to report line number and curren token

pop, push, enqueue, dequeue functions for lists

push adds last, pop removes last
enqueue adds last, dequeue removes first

ls := [1]
push(ls, 2) // ls = [1,2]
x := pop(ls) // x = 2, ls = [1]
enqueue(ls, 3) // ls = [1,3]
y := dequeue(ls) // y = 1, ls = [3]

Support Generic Iterations

rect, kernel, line should all support iteration over positions:

for pos in line(100;100, 20;200) {...}

requires #27
Add something like value.iterate(visit func(value) error)

Parallel for loop

The for x in rect loop can be parallelized (separate rect in 4/8 rects).
Should only be done when iterating over rects

Support list type

[1, 2, 3, true, "abc", line(0;0, 10;10)]

should create a list.

[1, 2] :: 100
1 :: 2

all build lists by concatenation

[1, 2, 3][0]
[1, 2, 3][1:2] // optional, like go
[1, 2, 3][1:] // optional, like go

index list elements

for x in [1,2,3] {
 ...
}

iterates over list

requires #38

Check kernel length when parsing

Kernel must contain a quadratic number of elements. This is yet unchecked.

Translation functions

translateLine(line, point) -> line
translateRect(rect, point) -> rect
translatePolygon(polygon, point) -> polygon
translateEllipse(ellipse, point) -> ellipse

Rename blt to commit

blt should copy all pixels in a region from source to target. it should always require a rect parameter.
for the current purpose of blt (copy last region from target to source), add the new commit statement with optional rect parameter.

HSV color space support

add an internal type colorHSV with properties h, s, v and functions to_hsv(color) and to_color(colorHSV)

Refactor lexer into traditional char-wise state machine

this increased performance and enables significant whitespace

Support Runtime-Types

all value implementations should have a property __type that returns a string containing the type name to enable type checks:

if val.__type == "point" {
    ...
}

Turn If/Else Statement into If/ElseIf/Else

if x { ... } else if y { ... } else if z { ... } else { }

Introduce nil as default value

nil should be used to define uninitialized variables and as default value

Consolidate log output

log("a", "b") should print a b instead of "a""b"
all value implementations should generate sensible output, especially color

Rename pre-defined constant IMAGE to BOUNDS

Add function overloads

math functions should be callable for numbers as well as colors.
therefore, add the possibility to define multiple functionDecls to one identifier, e.g.
"sqrt": []functionDecl{ functionDecl{ invokeSqrtNum, []reflect.Type{numberType}, }, functionDecl{ invokeSqrtCol, []reflect.Type{colorType}, }, }

Kernel element accessor

Kernel[i] should return the element at i and Kernel[x, y] should access the kernel like an image with kernel[kernel.radius, kernel.radius] as center.