Should allow two scenarios of variable creation - by declaration and assignment. Example:

x = some.method()
x, y = some.method(), 3

So basically:

<assign-expression> ::= <identifier-list> "=" <expression-list>
<identifier-list> ::= <identifier> | <identifier> "," <identifier-list>
<expression-list> ::= <expression> | <expression> "," <expression-list>

• Add token for assign operator "="
• If identifier is used for the first time, it should be created based on expression being assigned
• Implement basic type checks
• Documentation: variables, assign statement

Currently internal implementations of Class, Object and Method try to imitate vm ones. This makes a mess when creating player context.

• There should be only one definition of Class and Object types
• There should be a vmMethod and internalMethod types: vmMethod should execute Operations and internalMethod should call internal function
• Method should store argumentCount and returnCount

Document:

• VM: Class, Method, Object, internal calls

Extend functionality #23 , so that function can return multiple values at once.

TODO:

• Extend function declaration with return declaration list
• Extend return statement to handle multiple values
• Support assignment operators (=, :=) to handle multiple values on the right hand side
• Document

When object is instantinated, I expect function Init to be called.

Example in room object:

    addExit("south", "locations/room_a")
}

Telnet.handleReadAsync processes single bytes instead of frames, which might be inefficient.

• Implement buffer to store whole frame of data
• Process bytes from buffer
• Documentation: Telnet protocol

Currently there are no control statements. Introduce if statement, so the following code works:

func HandleLine(line string) {
    if (line == "enter") {
        player.Move("room_b")
        player.Send(room.GetDescription())
    }
}

• Implement if-else statement (lexer, parser, compiler)
• Implement == operator
• Implement conditional jumps (vm)
• Documentation: Grammar, keywords, tokens, statements, operators

Blocked by: #16

Implement a new context along player, so that following pseudocode works:

player.Move("room_b")
player.Send(room.GetDescription())

In example above, room is a context, which can be called and player.Move causes to change current room context to switch to an object of roob_b.

• VM should keep a map of all created rooms
• room context should change when player is moving
• Documentation: contexts

Improve loading not compiled classes and registering internal objects

Import statement should load a class into Class.imports collection and allow programmer to create a new instance of this class.

Example code:

import (
    "dir/some_class"
    "dir/next/some_class" as "class_alias"
)

func DoSomething() {
    a := new some_class
    b := new class_alias
}

Things to consider:

• How "new operator" should look like?

Language currently supports only string addition. More data types and operators should be available.

Data types:

• int
• float

Operators:

• subtract
• divide
• modulo
• multiply

Wiki:

• Documentation: GMSL

It should be possible to use inheritance when creating new classes, eg. for player and room objects.

Currently only void methods are supported. Handle method output. Implement both return value declaration and return statement.

Currently function declaration is implemented as follows:

<function-declaration> ::= "func" <identifier> "(" <argument-declarations> ")" "{" <statements> "}"
<identifier> ::= <any valid identifier>
<argument-declarations> ::= <argument-declaration> | <argument-declaration> "," <argument-declarations>
<argument-declaration> ::= <identifier> <type>
<type> ::= <any valid type>
<statements> ::= <statement> | <statement> <statements>
<statement> ::= <any valid statement>

To do:

• Extend <function-declaration> to include return types as <return-types> ::= <type> | "(" <types> ")" and <types> ::= <type> | <type> "," <types>
• Add return statement as <return-statement> ::= <expression-list> and <expression-list> ::= <expression> | <expression> "," <expression-list>
• Documentation

There are many places with excessive logging or using fmt.Println to debug application.

• Remove fmt.Println calls
• Replace default log calls with logrus with correct log levels
• Documentation: Aplication logging

Package declaration was inspired by GoLang. VM doesn't use this abstraction and each file is considered as a separate class. It makes no sense having a package declaration in code.

Currently there is a mess with AssemblyEntries being too creative.

• AssemblyEntry should be a single struct having: OpCode, (int, optional, if none => 0) value, token reference
• Assembly should group entries by methods
• Method info should contain argument types and return types

Documentation:

• VM Operations (assembly)

Currently parser calls panic every time it fails. It should fail gracefully.

Also: move operation generation to a different place

Semicolon is a bad idea, which came from nowhere.

• Remove semicolon token
• Documentation: Go Mud Scripting Language

Change handling of dot operator.

Currently AST node structures are complex, have many pointers and are hard to understand.

Cleanup those structures:

• Remove pointer declarations, where not necessary
• Remove interface fields in structures
• Add "pretty" printing

Documentation:

• Compiler AST

Currently, method is executed within Method.Execute method. It should be executed on ExecutionFrame.

• ExecutionFrame should get string pool and operations from Method before execution
• ExecutionFrame should have a program counter to execute step-by-step and enable jumps in future
• Documentation: VM ExecutionFrame

Some tokens share functionality, eg. IdentifierToken stores also context name.

• Split context name token from IdentifierToken
• Document tokens

Object should have fields. They should be defined by assignment statements outside of function scope.

Currently escaped characters like \r\n are not translated correctly to #10#13 characters.

• Support \n escaped character to place #10#13 sequence
• Ignore \r escaped character
• Replace \t with #9
• Replace \\ with \
• Replace \" with "
• Documentation: String literals

Maybe some kind of event loop?

Currently parser is based on many (sometimes recursive) calls, which is hard to read and debug. Rewrite it to use stack/states.

User should be able to pass configuration to driver on startup.

Following properties should be configurable:

• Server host
• Server port
• Mudlib directory

Sources of configuration:

• CLI flags
• mud.yaml file in CWD

Documentation:

• CLI documentation
• Config file documentation

Currently compression is handled by in connection struct.

• Create ZlibFilter and PlainFilter, so that this logic is moved away
• Implement MCCP1 fallback handshake option

Documentation:

• MCCP protocol implementation notes