yasl-lang / yasl Goto Github PK

• foreach loops (over 1 and 2 values, over all iterables)
  • over 1 value
  • over 2 values
• list and table comprehensions (over 1 and 2 values, over all iterables)
  • list comprehensions
    • over 1 value
    • over 2 values
  • table comprehensions
    • over 1 value
    • over 2 values
• metatables
• garbage collector
• importing files
• regex (with matching operator)
• operator overloading
• infinity and nan

add the following type literals:

• float64
• int64
• bool
• str8
• list
• map
• file
• type

add the following functions:

• typeof (takes literal, returns type of that literal)

• add jump table for builtins
• add builtin string functions
• add builtin os functions

string->count(substring) returns the number of times substring appears in string (an int).

e.g.

'abc'->count('a') is 1 ('a' appears once in 'abc')
'xxxx'->count('xx') is 2 (we don't count overlapping occurrences of substring)

• contains
• endswith
• isal
• isalnum
• isnum
• isspace
• ltrim
• replace
• rtrim
• search
• split
• startswith
• trim

The following escapes should be valid in single quoted strings:

• \b (backspace)
• \f (formfeed)
• \n (newline)
• \r (carriage return)
• \t (horizontal tab)
• \v (vertical tab)
• \ (backslash)
• ' (single quote)
• " (double quote)
• \e (escape character)

This should be doable with changes only to lexer.c (and possibly lexer.h)

allow the notation s[a:b] for strings and lists. This is syntactic sugar for s->__slice(a, b). This returns a copy of s, starting from a and up to but not including b.

The following forms are allowed:

s[a:b] (s->__slice(a, b))
s[:b] (s->__slice(undef, b). For lists and strings, this is the same as s->__slice(0, b), but should decompose to the more general form with undef.)
s[a:] (s->__slice(a, undef). Similar to above example.)

The __slice method is mostly implemented already, but named slice currently (also, it does not support undef parameters, just int parameters.

After this is done, exponentiation should be the only thing that depends on math.h

interpolated strings should accept all escapes that single quoted strings accept, plus string interpolation using a # character.

In Makefile, setting an optimization flag (eg. "CFLAGS=-lm -O1") and then running this hailstone code

for i <- [1234567] {
while i > 1 {
  if i % 2 > 0 {
    i = 3*i+1
  } else {
    i = i//2
  }
  print i
}
}

will cause a segmentation fault. The same YASL script run with an Interpreter compiled with -O2 errors printing "Floating point exception (core dumped)".
The program prints nothing but the respective error message either time.

add in operator.

see here for examples of where underscores are allowed.

Must be supported by literals, str.tofloat, and str.toint.

• clone
• keys
• values

Get tests written in Perl working with Travis.

use this to implement break and continue.

e.g.

for let x = 1; x < 20; x += 1 {
     print x
}

add classes.

• reverse
• append
• search
• extend
• pop
• copy

add blocks delimited only by {...} with lexical scoping.

the following should be supported:

• stdin, stdout, stderr
• open(name, mode:="r")
• close(file)
• flush(file)
• read(file, format)
• write(file, value)
  seek(file, whence, offset)

once this is implemented, files should be removed from main interpreter

for i, val <- ls { ... }

add the following literals:

• stdin
• stdout
• stderr

add the following functions:

• open (opens file from string)
• popen (runs string in shell, returns stdout of process run)

add the following methods:

• write
• read
• readline
• close
• pclose

YASL functions currently trim or extend the argument list passed to match the number of arguments expected. Make C functions do the same.

When executing print ["A", "B"] interpreter prints the location in memory of the list instead of something meaningful (like a recursive call on its contents' toString() .)

rewrite the whole Python part in C

user should be able to write strings delimited by backticks. No escape sequences or interpolation should happen in these strings (including no escaping of backticks or backslashes).

This change should be possible by changing only lexer.c (and possibly lexer.h)

and continue

Compiler flag issues

add lists

e.g.

for let x in ls {
    print x 
}

Add strings.

Parser currently doesn't understand the precedence level of function calls.

list.sort method has the following semantics:

• if all elements are strings, sort it lexically.
• if all elements are numbers, sort it numerically.
• otherwise, throw a type error.

e.g.
x := [4, 3, 1]; x->sort() (x is now [1, 3, 4])
x := ['a', 'c', 'b']; x->sort() (x is now ['a', 'b', 'c'])
x := [1, 'a']; x->sort() (type error)

Note that all the lexical comparisons for strings and numbers are already implemented, so feel free to use those.

I did a cheap hack when I first implemented for-loops (added a second stack to store their values). This should be fixed so that only 1 stack is used for everything.

Currently, all division operations result in a float64 object. This is not the expected/desired behaviour when both operands are integers, especially if the remainder is zero.

Suggested fix: support '//' operation to force integer division (floor result, return int64)

prevent infinite loops from causing a segfault.