Using lex and yacc tools on windows


Recently I came accross a situation where I have to use Lex tools for writing lexical analyzers. Generally these tools are avilable on most of the standard UNIX based operating sustems. But I use Windows Operating system. So, I just wanted to share my experience of installing them, writing sample programs and compiling them and executing them.

  
Let me first start with how to install them on your windows machine...

(1) Download Flex (Free implementations of LEX library), Bison (Free implementation of Bison library) and  Dev-CPP
(2) Install them on your machine (Note: without spaces in the name of the directory)  
(3)Set PATH variable to include bin directories of Flex, Bison, gcc

Now compiling .l and .y files and generating .exe file...

Open your command prompt and  go to directory where you lex and yacc files are located and run below commands

(1) flex  filename.l
           ===> it generates lex.yy.c file
(2) bison filename.y
           ===> it generates y.tab.c and y.tab.h file
(3) gcc lex.yy.c y.tab.c -o test.exe
           ===> it generates executable file (.exe)
Note:  You can run gcc command only with lex.yy.c file also. ex: gcc lex.yy.c -o .exe


Sample lex file (whitespace.l):
  
non_white [^ \t\n]*
%%

{non_white} ECHO;
.  ;
[\n]  ;

%%

int yywrap(void)
{
    return 0;
}

int main(void)
{
    yylex();
    return 0;
}

Sample lex file (lexicalAnalyzer.l):
  
DIGIT [0-9]
ID [a-z][a-z0-9]*
%%
char|int|float|double|main|void|real|printf|for|while|do   printf("keyword=%s\n",yytext);
{DIGIT}   printf("integer %s\n",yytext);
{ID}+     printf("identifier %s\n",yytext);
{DIGIT}+"."{DIGIT}*   printf("floating point number:%s\n",yytext);
[=|!=|>=|<=|<|>|+|-|*|/]    printf("operator %s\n",yytext);
[(]     printf("openparenthesis %s\n",yytext);
[)]    printf("closeparenthesis %s\n",yytext);
[{]    printf("open bbrace is %s\n",yytext);
[}]   printf("close braceis %s\n",yytext);
[;]   printf("eos %s\n",yytext);
[\t\n]+     /*eat up whitesapaces */
["{"|^}\n]*"}"]      /*eat up comments */
["|,|.]         printf("punctaation :%s \n",yytext);
%%

main()
{
yylex();
}
int yywrap()
{
return 1;
}
3:33 AM | Category: | 1 comments

Creating namespaces in JavaScript


In the past it was very common to see global variables in snippets of JavaScript code across the web, such as:
name = "Spock";
function greeting() {
 return "Hello " + name;
}
A better approach is to place all of your code within a namespace; an object that contains all of your code and helps to prevent name clashes with JavaScript code written by others.

The simplest method of creating a namespace is to use an object literal.
var foo = {};
foo.name = "Spock";
foo.greeting = function() {
 return "Hello " + foo.name;
}
This can also be specified using a different syntax.
var foo = {
 
 name: "Spock",
 
 greeting: function() {
  return "Hello " + foo.name;
 }
 
};
This approach is better that having outright global variables, but it exposes everything within the namespace as global. In other words both foo.name and foo.greeting are available everywhere.
Another problem with this approach is that greeting needs to refer to ‘foo.name’ rather than just ‘name’.
Another method of creating a namespace is through the use of a self executing function.
var foo = (function(){
 
 // Create a private variable
 var name = "Spock";
 
 // Create a private function
 var greeting = function() {
  return "Hello " + name;
 };
 
 // Return an object that exposes our greeting function publicly
 return {
  greeting: greeting
 };
 
})();
Here, when the function is executed it creates a private variable and a private inner function. The inner function can refer to the private variable directly. The main function then returns an object literal containing a reference to the greeting private function – this then exposes the greeting function as a public function so we can call it via the foo namespace.
console.log(foo.greeting() === "Hello Spock"); // true

Taken from Kevan Stannard post on the same.
9:12 PM | Category: | 0 comments