Wednesday, May 23, 2012

Fuzuli: A new general purpose interpreter and language

We are happy to announce that we have just released 0.1 revision of our general purpose interpreter Fuzuli.

Although Fuzuli has a syntax similar to Lisp, it is not intended to be a Lisp clone. We just wanted to have an interpreter that has lots of properties from both Algol and Lisp languages.

Fuzûlî is a 16th century poet, writer and thinker that lived in Ottoman Empire. Since his real name was Muhammad bin Suleyman, he used the name Fuzuli as his pen name. The name Fuzuli is very interesting because of its meaning. It means impertinent, improper, unnecessary in English. However it is an Arabic word with more than one meanings. With its primary meaning, Fuzuli has its roots from the word "science" and the word "arts". Please read more about the name and the poet Fuzuli in Wikipedia.

 It is not a coincidence, we choose this name for our interpreter because we had no motivation for writing it. We have just written it for fun! There are lots of languages that we use such as C, C++, Java, Php and Perl and  they satisfy what we need at all. Writing such a language was just a fuzuli work! Note that we are not computer science guys, so our code may not be a real king!

Fuzuli has been written in C++ and Fuzuli. It currently supports dynamic library loading, Algol type loops and control statements with a Lisp syntax, a primitive garbage collector, scopes for global and local variables, MySql databases and socket connections. It has an IO library that completely inherited from C++. It has libraries about GD2 and Tcl/Tk in an elementary manner. 

 The project page is hosted in Fuzuli Google Code page and the source code is ready for downloading and compiling. Our friends are preparing installation packages for several Linux Distributions such as Ubuntu and Slax. We are also working to build up a comprehensive documentation. Your help about coding, documentation, making packages for the other distributions, Windows and Mac binaries or anything else is also welcome! We also need your ideas and suggestions on Fuzuli for further revisions.

A fibonacci function written in Fuzuli is shown below:

(function fibonacci (params x)
     (block
        (if (<= x 2)
          (return 1)
          (return (+ (fibonacci (- x 1)) (fibonacci (- x 2))))
        )
     )
 ) 
 

This function is called using an expression similar to this:

(let result (fibonacci 5))

A list that contains integers from 1 to 10 can be written as:


(let alist (: 1 10))

and R users would be happy when they see the operator ':' in Fuzuli. A for loop is something like

(for (let i 0) (< i 10) (inc i)
   (block
      (print "i is " i "\n")
   )
)

in fuzuli. The variable 'i' is local and invisible to upper scopes, such as global scope. We define variables using a notation like this:

(def i INTEGER)
(def d FLOAT)
(def s STRING)

and variables are visible in the scope which they were created and scopes under that scope. Block, for, while and foreach expressions define blocks. For example 

(block
   (def i INTEGER)
   (let i 10)
)
(print i)

writes NULL because i is defined and set in a local block. However 

(def i INTEGER)
(block
  (let i 10)
)
(print i)

prints a "10" because the variable 'i' is defined at the top of the block.
We have implemented some functionality of Fuzuli in seperated dynamic libraries. The fuzuli package math.nfl has a content similar to
(let mathlib (dynload "FuzuliCore"))



(let PI (C mathlib "pi") 0)


(function sin (params x)
    (return (C mathlib "sind" x))
)

(function cos (params x)
    (return (C mathlib "cosd" x) )
)

(function tan (params x)
    (return (C mathlib "tand" x) )
)

This package loads the dynamic library FuzuliCore (it is libFuzuliCore.so in Linux) and defines some math functions. Actually, they do nothing but acting like wrappers. The fuzuli function 'C' is used to call C functions from fuzuli. In example below, C functions pi, sin, cos and tan are wrapped. The sin and the cos functions are defined as
Token *sind(Token *params, Environment *env){
    Token *resultToken = new Token(0.0, FLOAT);
    resultToken->setFloatValue(sin(params->tokens[0]->getFloatValue()));
    return(resultToken);
}

Token *cosd(Token *params, Environment *env){
    Token *resultToken = new Token(0.0, FLOAT);
    resultToken->setFloatValue(cos(params->tokens[0]->getFloatValue()));
    return(resultToken);
}


Note that this code is not integrated with our primitive garbage collector and the code should be

Token *sind(Token *params, Environment *env){
    Token *resultToken = env->newToken(0.0, FLOAT);
    resultToken->setFloatValue(sin(params->tokens[0]->getFloatValue()));
    return(resultToken);
}


Fuzuli can also used as a CGI language. It supports HTML tags in a manner similar to Php. Here, there is an interesting example:



The example shown below creates an HTML table with content of days of a week! The interesting point is that it starts with an html tag and it ends with html tag end. Setting this file as executable is what we need for running it as a CGI program.

We also plan to implement more languages that run in fuzuli.

Finally, Fuzuli is in its early stages. We need usage statistics, suggestions and ideas. We are also preparing the documentation. Follow us at stdioe!

No comments:

Post a Comment

Thanks