Friday, May 25, 2012

Fuzuliproject.org

After publishing Fuzuli's source code and introductory blog entries, we have just published our web site, official Fuzuli home page. We hope you can easly follow up the news about our interpreter using this site.

Follow our news and us!

For the stdioe team, A.Gokhan Satman.

Thursday, May 24, 2012

File operations in Fuzuli

Fuzuli, our new programming language and interpreter, was first introduced in Fuzuli: A new general purpose interpreter and language has several input and output functions completely derived from standard C and C++.

Since our language is in its first stages and input and output functions have high priority, Fuzuli has adequate number of functions for those jobs.

First of all, the io package must be included before any function call. This package is stored in /usr/lib/fuzuli/nfl by default. Nfl packages (Nafile) have a similar file extension with the name Fuzuli. It means "useless" in English.

In Fuzuli, a package can be included using the require function:


(require "/usr/lib/fuzuli/nfl/io.nfl")


Fuzuli has fopen, fwrite, fread and fclose functions for opening, writing, reading and closing of files,respectively. The code shown below shows how to open file for writing.

(let f (fopen "/tmp/example.txt" "w"))
(let liste (list 1 2 3 4 5 6 7 8 9 10 11 12 13 14))
(fwrite f liste)
(fclose f)


In the example above, we are opening the file example.txt for writing and writing elements of a list in it. This list contains integer numbers from 1 to 14. fwrite takes the reference of file and object to be written as parameters. A single element can be written in same manner. Finaly we are closing the file using 'fclose'. The example shown below shows how to read from values from the same file:

(let dd (fopen "/tmp/example.txt"  "r"))
(let a 0)
(let mysum 0)
(for (let i 0) (< i 5) (inc i)
                (let mysum (+ mysum (fread dd a)))
)


In the example above, dd is a reference to the example.txt. Note that, fopen shares the same file mode types with C++. So "r" means, the file will be opened in "read" mode. Variables "a" and "mysum" are set to zero before the loop. In loop, we are reading the next object using "fread" from the file reference "dd". mysum holds the sum of first 5 integers. The result is 15. Question: How fread knows the data type? The answer is easy. "a" is set using (let a 0) so a is an integer. If "a" is defined using (let a 0.1) then "a" is a double and fread will read a double from the file. In previous example, 5 objects were read from the file. Sometimes, it is impossible to know the number of records of objects that contained by the file. feof function can be used in a loop as in Fuzuli's parents.

(def a INTEGER)
(let dd (fopen "/tmp/kek.txt"  "r"))
(while (= (feof dd) 0)
        (block
                (print (fread dd a) " ")
        )
)
(fclose dd)


In the example above, the value of "a" is not set but it is defined as integer. We are reading from the file in a while loop and the stop condition is reaching the end of file. As we mentioned above, fread reads integers because of the type of variable "a". Fuzuli has several input and output functions beyond the file operations. The function fflush is used for writing bytes stored in the buffer.

(let f (fopen "/tmp/example.txt" "w"))
(let liste (list 1 2 3 4 5 6 7 8 9 10 11 12 13 14))
(fwrite f liste)
(fflush f)
(fclose f)


In the example above, fflush sends content of the file buffer to the opened file after each fwrite operation. getpdw function is to get the working directory:

(let mydir (getpwd))
(print mydir "\n")


With chdir, current path can be changed:

(chdir "/tmp")


Function dir returns a list of directories and files of a given directory:

(let mydir (dir "."))
(foreach direntry in mydir
        (block
                (print direntry "\n")
        )
)


In the example above, dir takes a parameter of "." so content of the current directory is shown. Function unlink and rename deletes and renames files, respectively:

(let mydir (dir "."))
(unlink "/tmp/example.txt")
(rename "1.txt" "2.txt")


In the example above, example.txt was deleted and name of 1.txt is set to 2.txt.

Fuzuli currently has those io functions in io.nfl:
  • fopen
  • fclose
  • feof
  • fwrite
  • fread
  • fflush
  • chdir
  • getpwd
  • dir
  • unlink
  • rename
  • tmpfile
  • tmpnam
  • datetime
  • asctime
  • sleep
  • getenv
  • rnd
  • print_r
  • popen
  • pclose

There are several input and output functions in Fuzuli. Please have a look at the Fuzuli Documentation in Fuzuli Source Code page for further information. We will explain the language and its libraries with more examples in next posts.

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!

Wednesday, May 2, 2012

Text & binary modes on ftp – CR LF ASCII codes


Why there are binary mode and text mode transfers?

What is the difference between binary and text mode transfers?

When FTP data transfer modes are important, When it doesn't matter?

Sometimes, I can see an unknown character like "^M" at and of a line, what is this character? Why is it there?

I have to talk about "how to recording data" when we are writing to a text file. Because, the questions above are directly related how to save text files on disk! As you know, there is a character table for text which is called ASCII code table as following,


When we press to a character on the keyboard while we are using a text editor, the text editor records them as equivalent value on the ascii table. For example, when we pressed the character "a", the editor saves it as hex "0x61". This situation is same for all Operating Systems.

BUT,

We see a text as lines of characters but normally all of the information is constructed by 1's and 0's. Those texts don't lie as lines in computer's memory. Text editors try to mark each line with special characters starting with a character. The problem is that when we press ENTER button on the keyboard, the text editors are using different marking information on different Operating Systems.

Let's continue our sample,
We want to write

"Hello\n"

"\n" part is for pressing ENTER button on the keyboard. This is a characteristic symbol in the C programming language. Content of that string is stored on Windows, Unix/Linux and Mac Operating Systems as follow;

54 65 73 74 0D 0A - On a Windows system
54 65 73 74 0A    - On a Unix/Linux system 
54 65 73 74 0D    - On a Mac system                 

0D and 0A parts are for illustrating CR and LF on ASCII table. CR means, "Carriage Return" and LF means "Line Feed". As you see below Microsoft Windows needs both to mark a new line however Unix / Linux operating system don't need both of them. CR is enough to show anew line. The Mac style is just the opposite of the Unix/Linux.

There are 255 characters in Ascii table. The extended part of Ascii table is other part as follows;



Just because for this reason, ftp protocol is supporting two different transfer mode.

Binary mode is transferring data from ftp client to ftp server bit by bit without any modification. If client and server have different type of operating systems, target system can not identify the line endings if the subject to send is text file.

Text mode is able to understand source and target system difference and fix the line ending codes as expected format by the requester.

So, If your system and  target ftp server are in different type and your data is text, you have to select text transfer mode on your ftp client to ensure files to be sent in correct form.

Saturday, April 14, 2012

Stdioe Starts Tweeting


We are happy to announce that we start to tweet at twitter.
Follow @stdioe for our updates, new articles and other news.
For the stdioe team, async:false.


twitter.com/stdioe