Anand Rajasekar » Java http://www.anandsekar.com ரெங்கசாமி ஆனந்த் சேகர் ராஜசேகர் Thu, 03 Jun 2010 05:30:03 +0000 http://wordpress.org/?v=2.8.6 en hourly 1 Modifying Classpath at Runtime http://www.anandsekar.com/2008/08/27/modifying-classpath-at-runtime/ http://www.anandsekar.com/2008/08/27/modifying-classpath-at-runtime/#comments Wed, 27 Aug 2008 20:19:35 +0000 anandsekar http://www.anandsekar.com/?p=52 A hackish way of modifying the classpath at runtime can be done in a way described at the java forums Modifying Classpath at Runtime
A cleaner approach is to configure your own classloader and set it as the threads context classloader

  1. URL[] urls=new URL[2];
  2. URLClassLoader classLoader=new URLClassLoader(urls);
  3. Thread.currentThread().setContextClassLoader(classLoader);

This is extremely useful if your unit test cases have dependencies that you would like to load at runtime

]]> http://www.anandsekar.com/2008/08/27/modifying-classpath-at-runtime/feed/ 0 InheritableThreadLocal and Tomcat http://www.anandsekar.com/2008/05/08/inheritablethreadlocal-and-tomcat/ http://www.anandsekar.com/2008/05/08/inheritablethreadlocal-and-tomcat/#comments Thu, 08 May 2008 05:18:40 +0000 anandsekar http://www.anandsekar.com/2008/05/08/inheritablethreadlocal-and-tomcat/ InheritableThreadLocal does not work with tomcat as tomcat thread pool does not clear the thread local contacts after a request has been executed. This results in no good way to share information information between the parent and the child threads that are created using thread local variables.

One way to solve this problem is to maintain a reference to the parent thread by writing your own thread that is constructed by a thread factory.

  1. public class MyThread extends Thread {
  2.         private Thread parent;
  3.         public MyThread(Thread parent) {
  4.                 super();
  5.                 this.parent = parent;
  6.         }
  7.         public Thread getParent() {
  8.                 return parent;
  9.         }
  10. }
  1. import java.util.concurrent.ThreadFactory;
  2. public class MyThreadFactory implements ThreadFactory {
  3.         @Override
  4.         public Thread newThread(Runnable arg0) {
  5.                 return new MyThread(Thread.currentThread());
  6.         }
  7. }
  1. import java.util.HashMap;
  2. import java.util.Map;
  3. public class ClassNeedingInheritableThreadLocal {
  4.         private Map inheritableThreadLocal=new HashMap();
  5.         public Object getInheritableThreadContext() {
  6.                 return inheritableThreadLocal.get(getThread());
  7.         }
  8.         public void setInheritableThreadContext(Object context) {
  9.                 inheritableThreadLocal.put(getThread(), context);
  10.         }
  11.         private Thread getThread() {
  12.                 Thread currentThread=Thread.currentThread();
  13.                 if(currentThread instanceof MyThread) {
  14.                         currentThread=getParent((MyThread) currentThread);
  15.                 }
  16.                 return currentThread;
  17.         }
  18.         public Thread getParent(MyThread myThread) {
  19.                 Thread parent=myThread.getParent();
  20.                 if(parent instanceof MyThread) {
  21.                         return getParent((MyThread) parent);
  22.                 } else {
  23.                         return parent;
  24.                 }
  25.         }
  26. }

Create a executor service by using our thread factory

  1. ExecutorService service=Executors.newFixedThreadPool(10, new MyThreadFactory());

Remember that you would need to clean up all the objects that were put in the thread local. This can be done with a filter or by using AOP.

]]> http://www.anandsekar.com/2008/05/08/inheritablethreadlocal-and-tomcat/feed/ 1 Using Locks for more granular concurrent access http://www.anandsekar.com/2007/09/21/using-locks-for-more-granular-concurrent-access/ http://www.anandsekar.com/2007/09/21/using-locks-for-more-granular-concurrent-access/#comments Fri, 21 Sep 2007 21:03:02 +0000 anandsekar http://www.anandsekar.com/2007/09/21/using-locks-for-more-granular-concurrent-access/ Locks introduced in Java 5 allow a more granular control on a shared resource. When a method is synchronized only the thread that obtains the lock is allowed to enter into that method or any other synchronized method of the class. However some times we may need a more granular control, typically when we have two or more resources we want to share across threads.

e.g.

  1. package org.lock;
  2.  
  3. public class LockExample {
  4. private boolean initialized;
  5. int salary=0;
  6.  
  7. public void increaseSalary() {
  8. if(!initialized) {
  9. initialized=true;
  10. salary=1000;
  11. }
  12. salary=salary+100;
  13. }
  14.  
  15. public void reset() {
  16. initialized=false;
  17. salary=0;
  18.  
  19. }
  20.  
  21. }

In this example we need to synchronize access on the initialization and the reset operations. Also we want to make sure that threads have a serialized access when they increase salary.

This is where we can leverage locks. We define two locks, one for initialization and one for the salary operation.

  1. package org.lock;
  2.  
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  5.  
  6. public class LockExample {
  7.         Lock initializationLock=new ReentrantLock();
  8.         Lock salaryLock=new ReentrantLock();
  9.         private boolean initialized;
  10.         int salary=0;
  11.        
  12.         public void increaseSalary() {
  13.                 if(!initialized) {
  14.                         initializationLock.lock();
  15.                         try {
  16.                                 initialized=true;
  17.                                 salary=1000;
  18.                         } finally {
  19.                                 initializationLock.unlock();
  20.                         }
  21.                 }
  22.                 salaryLock.lock();
  23.                 try {
  24.                         salary=salary+100;
  25.                 } finally {
  26.                         salaryLock.unlock();
  27.                 }
  28.         }
  29.        
  30.         public void reset() {
  31.                 initializationLock.lock();
  32.                 try {
  33.                         initialized=false;
  34.                         salary=0;
  35.                 } finally {
  36.                         initializationLock.unlock();
  37.                 }
  38.         }
  39. }

If you are using Java 1.4 you can utilize temporary synchronization objects to achieve the same result

  1. package org.lock;
  2.  
  3. public class Lock14Example {
  4.         private Object initializationLock=new Object();
  5.         private Object salaryLock=new Object();
  6.         private boolean initialized;
  7.         int salary=0;
  8.        
  9.         public void increaseSalary() {
  10.                 if(!initialized) {
  11.                         synchronized(initializationLock) {
  12.                                 initialized=true;
  13.                                 salary=1000;
  14.                         }
  15.                 }
  16.                 synchronized(salaryLock) {
  17.                         salary=salary+100;
  18.                 }
  19.         }
  20.        
  21.         public void reset() {
  22.                 synchronized(initializationLock) {
  23.                         initialized=false;
  24.                         salary=0;
  25.                 }
  26.         }
  27. }
]]> http://www.anandsekar.com/2007/09/21/using-locks-for-more-granular-concurrent-access/feed/ 0 Entrust Certification Chain Validation Error using Java Clients http://www.anandsekar.com/2006/08/31/entrust-certification-chain-validation-error-using-java-clients/ http://www.anandsekar.com/2006/08/31/entrust-certification-chain-validation-error-using-java-clients/#comments Thu, 31 Aug 2006 17:28:40 +0000 anandsekar http://www.pullaveli.com/?p=40 We were stumped yesterday trying to debug why all java clients trying to connect to a secure site using entrust’s Secure Server Certificates were throwing a certificate chain validation error. It turned out that the intermediate certificate that we downloaded from entrust had a bad expiration date. To correct this problem download the intermediate certificate again from entrust (they have posted the correct certificate now !) or remove the intermediate certificate from the server. (http://www.entrust.net/ssl-technical/chaincert_faq.cfm)

]]> http://www.anandsekar.com/2006/08/31/entrust-certification-chain-validation-error-using-java-clients/feed/ 1 Applied Symmetric Cryptography http://www.anandsekar.com/2006/05/13/applied-symmetric-cryptography/ http://www.anandsekar.com/2006/05/13/applied-symmetric-cryptography/#comments Sun, 14 May 2006 02:24:01 +0000 anandsekar http://www.pullaveli.com/?p=34 Cryptography in essence tries to solve three main real world problems.

  1. Confidentialty
  2. Integrity
  3. Authenticity

Lets consider there are two people Alice and Bob who want to communicate with each other, and Eve is trying to eaves drop on the communication. The communication is said to be confidential if eve is not able to understand what messages Alice and Bob are exchanging. Ok, Eve cannot understand what Alice and Bob are talking, however Eve could stand between Alice and Bob and tamper the message. Somehow Bob must be able to deduce that the messages that come from Alice have not been tampered. There is yet another problem, Eve could be sending messages on behalf of Alice, somehow Bob must be able to authenticate that the message came from Alice.

There are two kinds of Cryptography

  1. Symmetric/Secret Key Cryptography
  2. Asymmetric/Public Key Cryptography

Confidentiality using Symmetric/Secret Key Cryptography
Secret key cryptography, uses the same key to encrypt and decrypt the message. If Alice wants to communicate a confidential message to Bob they must first have the same encryption key in their possession.
confidential.png
In the example below we use the key generator to generate a key for the DES encryption algorithm. The cipher class is then instantiated for encryption and decryption using the key which is distributed to Alice and Bob.

  1. package org.symmetric;
  2.  
  3. import javax.crypto.Cipher;
  4. import javax.crypto.KeyGenerator;
  5. import javax.crypto.SecretKey;
  6.  
  7. public class ConfidentialitySecretKey {
  8.  
  9.         public ConfidentialitySecretKey() throws Exception {
  10.                 KeyGenerator keyGenerator = KeyGenerator.getInstance(“DES”);
  11.                 SecretKey key = keyGenerator.generateKey();
  12.                 Alice alice = new Alice();
  13.                 Bob bob = new Bob();
  14.                 alice.setKey(key);
  15.                 bob.setKey(key);
  16.                 byte[] cipherText = alice.getMessage();
  17.                 bob.receiveMessage(cipherText);
  18.         }
  19.  
  20.         public class Alice {
  21.                 private SecretKey key;
  22.  
  23.                 public void setKey(SecretKey key) {
  24.                         this.key = key;
  25.                 }
  26.  
  27.                 public byte[] getMessage() throws Exception {
  28.                         String message = “Top Secret”;
  29.                         Cipher cipher = Cipher.getInstance(“DES/ECB/PKCS5Padding”);
  30.                         cipher.init(Cipher.ENCRYPT_MODE, key);
  31.                         return cipher.doFinal(message.getBytes(“UTF-8″));
  32.                 }
  33.  
  34.         }
  35.  
  36.         public class Bob {
  37.                 private SecretKey key;
  38.  
  39.                 public void setKey(SecretKey key) {
  40.                         this.key = key;
  41.                 }
  42.  
  43.                 public void receiveMessage(byte[] message) throws Exception {
  44.                         Cipher cipher = Cipher.getInstance(“DES/ECB/PKCS5Padding”);
  45.                         cipher.init(Cipher.DECRYPT_MODE, key);
  46.                         byte[] plainText = cipher.doFinal(message);
  47.                         System.out.println(new String(plainText, “UTF-8″));
  48.                 }
  49.         }
  50.  
  51.         public static void main(String args[]) throws Exception {
  52.                 ConfidentialitySecretKey c = new ConfidentialitySecretKey();
  53.         }
  54. }

Integrity using Symmetric/Secret Key Cryptography
Now since Alice can send a confidential message to Bob, she is faced with another problem. She needs to some how ensure the integrity of the message. On the event that the message is tampered by eve, somehow Bob should be able to detect that the message has been tampered.
A message digest is an function on the message that generates a unique but shorter representation of the message itself. Alice now generates a digest of the message that she needs to send to Bob. Now she encrypts the message digest with the secret key that only she and Bob shares. The result of the transforation is called the Message Authentication Code or MAC. She now sends the message and the MAC to Bob. Since Bob is the only other person in the world who is in possession of the secret key, nobody can tamper the message and regenerate the MAC. When Bob received the message he verifies that the message has not been tampered by generating the message digest from the message and matching it with the decripted MAC.
integrity.png
The example below shows how one could generate a MAC using java.

  1. package org.symmetric;
  2.  
  3. import java.util.Arrays;
  4.  
  5. import javax.crypto.KeyGenerator;
  6. import javax.crypto.Mac;
  7. import javax.crypto.SecretKey;
  8.  
  9. public class IntegritySecretKey {
  10.  
  11.         public IntegritySecretKey() throws Exception {
  12.                 KeyGenerator keyGen = KeyGenerator.getInstance(“HmacMD5″);
  13.                 SecretKey key = keyGen.generateKey();
  14.                 Alice alice = new Alice();
  15.                 Bob bob = new Bob();
  16.                 alice.setKey(key);
  17.                 bob.setKey(key);
  18.                 byte[] message = alice.getMessage();
  19.                 byte[] mac = alice.getMAC();
  20.                 bob.receiveMessage(message, mac);
  21.                 // eve tampers the next message
  22.                 message[0] = 0;
  23.                 bob.receiveMessage(message, mac);
  24.         }
  25.  
  26.         public class Alice {
  27.                 private SecretKey key;
  28.  
  29.                 public void setKey(SecretKey key) {
  30.                         this.key = key;
  31.                 }
  32.  
  33.                 public byte[] getMessage() throws Exception {
  34.                         return “Top Secret”.getBytes(“UTF-8″);
  35.                 }
  36.  
  37.                 public byte[] getMAC() throws Exception {
  38.                         byte[] message = getMessage();
  39.                         Mac mac = Mac.getInstance(key.getAlgorithm());
  40.                         mac.init(key);
  41.                         return mac.doFinal(message);
  42.                 }
  43.  
  44.         }
  45.  
  46.         public class Bob {
  47.                 private SecretKey key;
  48.  
  49.                 public void setKey(SecretKey key) {
  50.                         this.key = key;
  51.                 }
  52.  
  53.                 public void receiveMessage(byte[] message, byte[] macReceived)
  54.                                 throws Exception {
  55.                         Mac mac = Mac.getInstance(key.getAlgorithm());
  56.                         mac.init(key);
  57.                         byte[] macToCompare = mac.doFinal(message);
  58.                         System.out.println(Arrays.equals(macToCompare, macReceived));
  59.                 }
  60.         }
  61.  
  62.         public static void main(String args[]) throws Exception {
  63.                 IntegritySecretKey i = new IntegritySecretKey();
  64.         }
  65. }

Authentication using Secret/Symmetric Key Cryptography
Using message authentication codes inherently solves the problems of authentication, as not only the integrity of the message is ensured, since Alice and Bob are the only two persons who are in possession of the secret key, if the MAC is verified it also authencitates that Alice really sent the message. Now Eve has a few tricks up her sleeve ! She could record the messages and replay them at a later time, or she should reorder the messages. This could be solved by embedding the timestamp in the messages. Eve could still cause trouble by deleting the messages totatally ! This problem cannot be solved by cryptography but with the handshake and protocol used for communication.

]]> http://www.anandsekar.com/2006/05/13/applied-symmetric-cryptography/feed/ 1 JBoss 4.0 Classloader Problems with Commons-Logging http://www.anandsekar.com/2006/03/09/jboss-40-classloader-problems-with-commons-logging/ http://www.anandsekar.com/2006/03/09/jboss-40-classloader-problems-with-commons-logging/#comments Fri, 10 Mar 2006 00:11:01 +0000 anandsekar http://www.pullaveli.com/?p=24 “Log4JLogger does not implement Log” .. this happens because commons logging is bound to the JBoss system classloader, however the application classloader is trying to associate it to itself. The best way to resolve this error is to remove all references to commons-logging and utilize the one that is packaged with JBoss. For more information refer Commons Logging FAQ.

To configure JBoss with a simpler flat classloader make the following changes.

Changes to be made in {JBoss-Home}/server/{server-name}/deploy/ear-deployer.xml

set attribute with name="Isolated" to false
set attribute with name "CallByValue" to false

Changes to be made in {JBoss-Home}/server/ {server-name}/deploy/jbossweb-tomcat55.sar/META-INF/jboss-service.xml

set attribute with name "UseJBossWebLoader" true

Refer the JBoss Wiki for more information.

]]> http://www.anandsekar.com/2006/03/09/jboss-40-classloader-problems-with-commons-logging/feed/ 0 Exporting the Private Key from a JKS keystore http://www.anandsekar.com/2006/01/19/exporting-the-private-key-from-a-jks-keystore/ http://www.anandsekar.com/2006/01/19/exporting-the-private-key-from-a-jks-keystore/#comments Thu, 19 Jan 2006 23:22:04 +0000 anandsekar http://www.pullaveli.com/?p=13 A common problem faced when moving certificates and keys from tomcat to Apache web server is that keytool does not allow you to export the private key in the format that apache’s modssl module requires. Mark Foster’s post and Andrew Morrow’s post contains valuable information on how to export a key from a JKS keystore.

Here is a summary of the steps needed to export a private key
Download ExportPrivateKey.zip
Invoke

java -jar ExportPrivateKey.zip {keystore_path} JKS {keystore_password} {alias} {target_file}

This would export the key to PKCS #8 PEM format. Now run openssl to convert it to the format apache modssl expects the file in

openssl pkcs8 -inform PEM -nocrypt -in exported-pkcs8.key -out exported.key

The java code for exporting the private key in PKCS #8 format

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.FileWriter;
  4. import java.security.Key;
  5. import java.security.KeyPair;
  6. import java.security.KeyStore;
  7. import java.security.KeyStoreException;
  8. import java.security.NoSuchAlgorithmException;
  9. import java.security.PrivateKey;
  10. import java.security.PublicKey;
  11. import java.security.UnrecoverableKeyException;
  12. import java.security.cert.Certificate;
  13.  
  14. import sun.misc.BASE64Encoder;
  15.  
  16. public class ExportPrivateKey {
  17.         private File keystoreFile;
  18.         private String keyStoreType;
  19.         private char[] password;
  20.         private String alias;
  21.         private File exportedFile;
  22.  
  23.         public static KeyPair getPrivateKey(KeyStore keystore, String alias, char[] password) {
  24.                 try {
  25.                         Key key=keystore.getKey(alias,password);
  26.                         if(key instanceof PrivateKey) {
  27.                                 Certificate cert=keystore.getCertificate(alias);
  28.                                 PublicKey publicKey=cert.getPublicKey();
  29.                                 return new KeyPair(publicKey,(PrivateKey)key);
  30.                         }
  31.                 } catch (UnrecoverableKeyException e) {
  32.         } catch (NoSuchAlgorithmException e) {
  33.         } catch (KeyStoreException e) {
  34.         }
  35.         return null;
  36.         }
  37.  
  38.         public void export() throws Exception{
  39.                 KeyStore keystore=KeyStore.getInstance(keyStoreType);
  40.                 BASE64Encoder encoder=new BASE64Encoder();
  41.                 keystore.load(new FileInputStream(keystoreFile),password);
  42.                 KeyPair keyPair=getPrivateKey(keystore,alias,password);
  43.                 PrivateKey privateKey=keyPair.getPrivate();
  44.                 String encoded=encoder.encode(privateKey.getEncoded());
  45.                 FileWriter fw=new FileWriter(exportedFile);
  46.                 fw.write(“—–BEGIN PRIVATE KEY—–\n“);
  47.                 fw.write(encoded);
  48.                 fw.write(“\n“);
  49.                 fw.write(“—–END PRIVATE KEY—–”);
  50.                 fw.close();
  51.         }
  52.  
  53.  
  54.         public static void main(String args[]) throws Exception{
  55.                 ExportPrivateKey export=new ExportPrivateKey();
  56.                 export.keystoreFile=new File(args[0]);
  57.                 export.keyStoreType=args[1];
  58.                 export.password=args[2].toCharArray();
  59.                 export.alias=args[3];
  60.                 export.exportedFile=new File(args[4]);
  61.                 export.export();
  62.         }
  63. }
]]> http://www.anandsekar.com/2006/01/19/exporting-the-private-key-from-a-jks-keystore/feed/ 37 Writing an Interpretter Using JavaCC http://www.anandsekar.com/2006/01/15/writing-a-interpretter/ http://www.anandsekar.com/2006/01/15/writing-a-interpretter/#comments Sun, 15 Jan 2006 19:37:14 +0000 anandsekar http://www.pullaveli.com/?p=8 Ever wondered how an interpreter works ? Well, while evaluating parser generators for executing expressions I wrote this small example.

Getting to the basics

What is an Interpreter ?

An interpreter is a computer program that executes the program given to it as an input. In contrast, a compiler generates machine code for the program given to it, which is then executed by the operating system or computer.

Lets say the language we are going to interpret supports simple assignment statements like

  1. a=1+5;
  2. b=a*3;
  3. c=a+b;

The execution of this small piece of code would involve four steps

  1. Lexical Analysis
  2. Syntax Analysis
  3. Generation of Abstract Syntax Tree
  4. Execute the code

In the lexical analysis phase all the tokens in the code are identified. In out example the tokens are [a, =, 1, +, 5, ; ......]. Once the tokens are identified we need to match them to our defined grammar i.e. many lines of Identifier=Expression;

Defining our language as a Context Free Grammar
The first thing we need to do is to define the grammar of our language as a context free grammar. A context free grammar is a way to define the formal structure in the form

V -> w

  1. language -> (statement)+ # contains one or more statements statement ->
  2. variable=expression; variable -> [“a”-“z”]+ # a variable contains one or more letters from a-z
  3. expression -> additiveExpr
  4. additiveExpr -> multiplyExpr ((+ | -) multiplyExpr)* # can be 5 or (5 + 4) or (5 – 2)
  5. multiplyExpr -> unaryExpr ((* | %) unaryExpr)* # can be 5 or (5 * 4) or (5 % 2)
  6. unaryExpr -> -primaryExpr | primaryExpr # can be 5 or -5
  7. primaryExpr -> number | variable | [1-9]+ # can be  1 or abc
  8.  

Implementing with JavaCC

JavaCC is a parser generator that takes a context free grammar and generates a parser for that language. Lets try to define our grammar in JavaCC. JavaCC would take a .jj file and generate java classes to parse the file and validate the grammar.

Lexical Analysis

We would need to instruct javacc to identify the tokens. The first thing to define in the javacc file is the tokens it needs to skip and the tokens that it needs to scan and parse out.

  1. SKIP :
  2. {
  3. ” “
  4. |“\t“
  5. |“\n“
  6. |“\r“
  7. }

Now we need to define all the tokens that the parser generated by javacc should parse out

  1. TOKEN:
  2. {
  3. <number:>
  4. |       <variable:>
  5. |</variable:></number:>
  6. <divide:>       |     <multiply:>
  7. |</multiply:></divide:>
  8. <plus:>         |       <minus:>
  9. }

Syntax Analysis
In JavaCC the way to define a production of the form V->e is like

  1. V() :
  2. {}
  3. {
  4. e()
  5. }

The final grammar defined using the javacc format would look like

  1. PARSER_BEGIN(ExpressionParser)public class ExpressionParser {
  2.  
  3. public static void main(String args[]) throws Exception {
  4. ExpressionParser parser = new ExpressionParser(new java.io.FileReader(args[0]));
  5. }
  6. }
  7.  
  8. PARSER_END(ExpressionParser)
  9.  
  10. SKIP :
  11. {
  12. ” “
  13. |“\t“
  14. |“\n“
  15. |“\r“
  16. }
  17.  
  18. TOKEN:
  19. {
  20. <number:>
  21. |       <variable:>
  22. |</variable:></number:>
  23. <divide:>       |     <multiply:>
  24. |</multiply:></divide:>
  25. <plus:>         |       <minus:>
  26. }</minus:></plus:>ASTstart start() :{}
  27. {
  28. (statement())+
  29. {}
  30. }void statement() :
  31. {}
  32. {
  33. identifier()“=”expression()“;”
  34. }
  35.  
  36. void identifier() :
  37. {}
  38. {
  39. <variable>
  40. {
  41. }
  42. }</variable>
  43.  
  44. void expression():
  45. {}
  46. {
  47. additiveExpression()
  48. }
  49.  
  50. void additiveExpression() :
  51. {}
  52. {
  53. multiplicativeExpression()
  54. (
  55.  
  56. <plus> multiplicativeExpression()
  57. | <minus> multiplicativeExpression()
  58. )*
  59. }</minus></plus>void multiplicativeExpression() :
  60. {}
  61. {
  62. unaryExpression()
  63. (
  64. <multiply> unaryExpression()
  65. |</multiply>
  66. <divide> unaryExpression()
  67. )*
  68. }
  69. void unaryExpression() :
  70. {}
  71. {
  72. <minus> numberExpression()|
  73. numberExpression()
  74. }</minus></divide>void numberExpression() :
  75. {
  76. }
  77. {
  78. <number>
  79. | <variable>
  80. }

This would generate ExpressionParser.java which would contain the code requried to parse the defined grammar. On execution of the main method with a file as an argument the parser would pass if there is a valid grammar in the file, or it would throw an exception if the file does not confine to the defined grammar. Now we are done with the lexical and the syntactical analysis.
Constructing the Abstract Syntax Tree
Now we need to construct the abstract syntax tree. Lets take a simple example

  1. a=1+5;
  2. b=a*3;
  3. c=a+b;

The abstract syntax tree for this should look like
Abstract Syntax Tree
JavaCC comes along with a preprocessor called jjtree that would create us a abstract syntax tree. Whereever in the grammar we need a tree node we embed # in the grammar definition file.

  1. void statement() #Statement:
  2. {}
  3. {
  4. identifier()“=”expression()“;”
  5. }

This would create a node ASTStatement.java for the production statement. All nodes by default would extend SimpleNode.java which implements Node that is generated with the node lifecycle methods.

  1. /* Generated By:JJTree: Do not edit this line. Node.java */
  2.  
  3. /* All AST nodes must implement this interface.  It provides basic
  4. machinery for constructing the parent and child relationships
  5. between nodes. */
  6.  
  7. public interface Node {
  8.  
  9. /** This method is called after the node has been made the current
  10. node.  It indicates that child nodes can now be added to it. */
  11. public void jjtOpen();
  12.  
  13. /** This method is called after all the child nodes have been
  14. added. */
  15. public void jjtClose();
  16.  
  17. /** This pair of methods are used to inform the node of its
  18. parent. */
  19. public void jjtSetParent(Node n);
  20. public Node jjtGetParent();
  21.  
  22. /** This method tells the node to add its argument to the node’s
  23. list of children.  */
  24. public void jjtAddChild(Node n, int i);
  25.  
  26. /** This method returns a child node.  The children are numbered
  27. from zero, left to right. */
  28. public Node jjtGetChild(int i);
  29.  
  30. /** Return the number of children the node has. */
  31. public int jjtGetNumChildren();
  32.  
  33. /** Accept the visitor. **/
  34. public Object jjtAccept(ExpressionParserVisitor visitor, Object data);
  35. }

Our final grammar decorated with all the defintions of the abstract syntax tree nodes would look like

  1. options {
  2. MULTI=true;
  3. VISITOR=true;
  4. NODE_DEFAULT_VOID=true;
  5. NODE_EXTENDS=“BaseNode”;
  6. }
  7.  
  8. PARSER_BEGIN(ExpressionParser)
  9.  
  10. public class ExpressionParser {
  11.  
  12. public static void main(String args[]) throws Exception {
  13. ExpressionParser parser = new ExpressionParser(new java.io.FileReader(args[0]));
  14. //ExpressionParser parser = new ExpressionParser(System.in);
  15. ASTstart expr=parser.start();
  16. ExpressionVisitor v=new ExpressionVisitor();
  17. System.out.println(expr.jjtAccept(v,null));
  18. }
  19. }
  20.  
  21. PARSER_END(ExpressionParser)
  22.  
  23. SKIP :
  24. {
  25. ” “
  26. |“\t“
  27. |“\n“
  28. |“\r“
  29. }
  30.  
  31. TOKEN:
  32. {
  33. <number:>
  34. |       <variable:>
  35. |</variable:></number:>
  36. <divide:>       |     <multiply:>
  37. |</multiply:></divide:>
  38. <plus:>         |       <minus:>
  39. }</minus:></plus:>ASTstart start() #start:{}
  40. {
  41. (statement())+
  42. { return jjtThis; }
  43. }void statement() #Statement:
  44. {}
  45. {
  46. identifier()“=”expression()“;”
  47. }
  48.  
  49. void identifier() :
  50. {}
  51. {
  52. <variable>
  53. {
  54. jjtThis.data.put(“name”,token.image);
  55. }#Variable
  56. }</variable>
  57.  
  58. void expression():
  59. {}
  60. {
  61. additiveExpression()
  62. }
  63.  
  64. void additiveExpression() :
  65. {}
  66. {
  67. multiplicativeExpression()
  68. (
  69.  
  70. <plus> multiplicativeExpression()#AddExpr(2)
  71. | <minus> multiplicativeExpression()#SubractExpr(2)
  72. )*
  73. }</minus></plus>void multiplicativeExpression() :
  74. {}
  75. {
  76. unaryExpression()
  77. (
  78. <multiply> unaryExpression()#MultiplyExpr(2)
  79. |</multiply>
  80. <divide> unaryExpression()#DivideExpr(2)
  81. )*
  82. }
  83. void unaryExpression() :
  84. {}
  85. {
  86. <minus> numberExpression()#NegateExpr(1)|
  87. numberExpression()
  88. }</minus></divide>void numberExpression() :
  89. {
  90. }
  91. {
  92. <number>
  93. {
  94. jjtThis.data.put(“value”,new Integer(Integer.parseInt(token.image)));
  95. }#Number
  96. | <variable>
  97. {
  98. jjtThis.data.put(“name”,token.image);
  99. }#VariableValue
  100. }

If you notice in the option, we have instructed jjtree to extend all sources from BaseNode.java. The base node is decorated with a hashmap that would be used to store the scanned tokens during parsing.

  1. import java.util.HashMap;</variable></number>public class BaseNode{
  2. public HashMap data=new HashMap();
  3. }

If you observe line 99 of the grammar definition, it shows how the parsed number token is added to the Number node that is constructed by jjtree.
This completes the generation of the abstract syntax tree.
Interpretation and Execution
What now remaing is to walk the tree and execute the code. One of the options that we have specified in the grammar definition is to generate the visitor. JJtree would automatically add accept methods on all the nodes generated and also generate the visitor interface

  1. void statement() #Statement:
  2. /* Generated By:JJTree: Do not edit this line. C:\workspace\JavaCC\target\ExpressionParserVisitor.java */
  3.  
  4. public interface ExpressionParserVisitor
  5. {
  6. public Object visit(SimpleNode node, Object data);
  7. public Object visit(ASTstart node, Object data);
  8. public Object visit(ASTStatement node, Object data);
  9. public Object visit(ASTVariable node, Object data);
  10. public Object visit(ASTAddExpr node, Object data);
  11. public Object visit(ASTSubractExpr node, Object data);
  12. public Object visit(ASTMultiplyExpr node, Object data);
  13. public Object visit(ASTDivideExpr node, Object data);
  14. public Object visit(ASTNegateExpr node, Object data);
  15. public Object visit(ASTNumber node, Object data);
  16. public Object visit(ASTVariableValue node, Object data);
  17. }

All we need to do now is to implement the visitor interface and interpret our language. The Interpreter would need two datastores

    Symbol Table
    Execution Stack

The symbol table would hold all the variables and their values, and the execution stack would contain all the intermediate results while expression are evaluated.
The Visitor code would look like.

  1. public interface ExpressionParserVisitor
  2.  
  3. import java.util.HashMap;
  4. import java.util.LinkedList;
  5.  
  6. public class ExpressionVisitor implements ExpressionParserVisitor{
  7.  
  8. private LinkedList stack=new LinkedList();
  9. private HashMap symbolTable=new HashMap();
  10.  
  11. public Object visit(SimpleNode node, Object data) {
  12. node.childrenAccept(this,data);
  13. return null;
  14. }
  15.  
  16. public Object visit(ASTstart node, Object data) {
  17. node.childrenAccept(this,data);
  18. return symbolTable;
  19. }
  20.  
  21. public Object visit(ASTAddExpr node, Object data) {
  22. node.childrenAccept(this,data);
  23. Integer arg1=pop();
  24. Integer arg2=pop();
  25. stack.addFirst(new Integer(arg2.intValue()+arg1.intValue()));
  26. return null;
  27. }
  28.  
  29. public Object visit(ASTSubractExpr node, Object data) {
  30. node.childrenAccept(this,data);
  31. Integer arg1=pop();
  32. Integer arg2=pop();
  33. stack.addFirst(new Integer(arg2.intValue()-arg1.intValue()));
  34. return null;
  35. }
  36.  
  37. public Object visit(ASTMultiplyExpr node, Object data) {
  38. node.childrenAccept(this,data);
  39. Integer arg1=pop();
  40. Integer arg2=pop();
  41. stack.addFirst(new Integer(arg2.intValue()*arg1.intValue()));
  42. return null;
  43. }
  44.  
  45. public Object visit(ASTDivideExpr node, Object data) {
  46. node.childrenAccept(this,data);
  47. Integer arg1=pop();
  48. Integer arg2=pop();
  49. stack.addFirst(new Integer(arg2.intValue()/arg1.intValue()));
  50. return null;
  51. }
  52.  
  53. public Object visit(ASTNegateExpr node, Object data) {
  54. node.childrenAccept(this,data);
  55. Integer arg1=pop();
  56. stack.addFirst(new Integer(arg1.intValue()*-1));
  57. return null;
  58. }
  59.  
  60. public Object visit(ASTNumber node, Object data) {
  61. node.childrenAccept(this,data);
  62. stack.addFirst(node.data.get(“value”));
  63. return null;
  64. }
  65.  
  66. public Object visit(ASTStatement node, Object data) {
  67. node.childrenAccept(this,data);
  68. Integer value=(Integer)stack.removeFirst();
  69. String var=(String)stack.removeFirst();
  70. symbolTable.put(var,value);
  71. return null;
  72. }
  73.  
  74. public Object visit(ASTVariable node, Object data) {
  75. node.childrenAccept(this,data);
  76. String var=(String)node.data.get(“name”);
  77. stack.addFirst(var);
  78. return null;
  79. }
  80.  
  81. public Object visit(ASTVariableValue node, Object data) {
  82. node.childrenAccept(this,data);
  83. String var=(String)node.data.get(“name”);
  84. stack.addFirst(symbolTable.get(var));
  85. return null;
  86. }
  87.  
  88. private Integer pop()
  89. {
  90. return (Integer)stack.removeFirst();
  91. }
  92.  
  93. }

Well, thats it .. our very own interpretter !!
Source Code As Eclipse Project

]]> http://www.anandsekar.com/2006/01/15/writing-a-interpretter/feed/ 18