Just did some googling and found an online version of syntax highlighter at:

http://www.chamisplace.com/colorizer/cc.asp

Andy, I saw those posts of Jez through the links you gave. Amazingly, they dated 2003!

Well, how about 'integrating' the coloring mechanisms with messaging posting process? We can have an option of 'Syntax Highlighted Preview', just before posting..

Regards,
Vignesh

#include <REG52.H>

// EXAMPLE Port & Pin definitions to match the 8052.com Tutorial
sbit LCD_EN = P3^7;
sbit LCD_RS = P3^6;

sbit LCD_RW = P3^5;
#define LCD_PORT P0

// Funtion prototype
void lcd_data(unsigned char dat);


/*
 * this routine displays the supplied 8-bit unsigned number
 * in hexadecimal notation.
 *
 * The hexadecimal display is achieved by sending two ASCII-coded
 * characters to the LCD; eg the number 0xA4 is displayed by sending 
 * a '4' character followed by an 'A' character.
 */ 
void hex2lcd( unsigned char number ) 
{ 
  unsigned char MSD; // used to extract the Most-Significant  (MS) Hex Digit of the number

  unsigned char LSD; // used to extract the Least-Significant (LS) Hex Digit of the number

  MSD = (number&0xf0) >>4; // extract the MS Hex Digit; ie the top 4 bits

  LSD = (number&0x0f);     // extract the LS Hex Digit; ie the bottom 4 bits

  // First, obtain the character to represent the MS Hex digit
  // Note that the conversion differs slightly depending on whether the value is 0x0-0x9 or 0xA-0xF
  if( MSD < 0xA )

  { 
	// The MS Digit is less than 0xA; ie it is in the range 0x0-0x9
	// Convert it to the corresponding ASCII character code '0' to '9'.
	// This conversion is easy, as we just have to add the value of the digit, 0x0-0x9,
	// to the value of the ASCII code for a '0' character
    MSD += '0'; 
  }

  else 
  {
	// The MS Digit is not less than 0xA; ie it is in the range 0xA-0xF
	// Convert it to the corresponding ASCII character code 'A' to 'F'
	// This conversion is slightly more complicated, as the values we are converting
	// are in the range 0xA-0xF; so we cannot simply add the value to be converted
	// to the ASCII code for an 'A' character - hence the subtraction of 0xA
	// (note that a decent compiler will do the subtraction at compile-time, and 

	//  will not generate code to work it out every time this line is executed!)
    MSD += ('A' - 0xA); 
  }

  // Now obtain the character to represent the LS Hex digit
  // The process is exactly the same as for the MS digit
  // Note that, since we have the MS and LS Digits in separate variables, it doesn't
  // matter in which order we convert the digits.
  if( LSD < 0xA )

  { 
    LSD += '0'; 
  }
  else 
  {

    LSD += ('A' - 0xA); 
  }

  // Now send the two characters forming the hex representation to the display

  // Note that it is now important that we send them in the correct order!
  lcd_data( MSD ); 
  lcd_data( LSD ); 

} 

/*
 * this routine displays the supplied 8-bit unsigned number
 * in decimal notation, with leading zeros; ie "000" to "255"
 *
 * The decimal display is achieved by sending three ASCII-coded
 * characters to the LCD; eg the number 0x78 (123 decimal) is displayed by 
 * sending  a '1' character followed by a '2' character followed by a '3' character.
 */ 
void dec2lcd(unsigned char number) 
{ 
  unsigned char h=0; // used to extract the "hundreds" Digit of the number in decimal notation

  unsigned char t=0; // used to extract the "tens"     Digit of the number in decimal notation

  // First, determine the number of "hundreds" in the number.
  // We do this by repeatedly subtracting 100 until the number falls below 100, 
  // and counting how many times we subtracted 100

  while( number >= 100 ) 
  { 
    number -= 100; 
    h++; 			// Count another "hundred"

  } 

  // The number now has no "hundreds" - either it had none to start with, or
  // they have all just been subtracted. 
  // Next, determine the number of "tens" in the number.
  // Again, we do this by repeatedly subtracting 10 until the number falls below 10, 
  // and counting how many times we subtracted 10
  while(number>=10) 
  { 
    number -= 10; 
    t++; 
  } 

  // The number now has no "hundreds" and no "tens" - either it had none to start with, or

  // they have all just been subtracted. 
  // All that is now left is the units!
  // Now send the 3 digits - "hundreds", "tens", and "units" - to the display as ASCII-Coded
  // Characters.
  // Because each digit must be in the range 0-9, the corresponding ASCII code is found by
  // adding the digit value to the value of the ASCII code for a '0' character 
  lcd_data(      h + '0' ); // hundreds

  lcd_data(      t + '0' ); // tens
  lcd_data( number + '0' ); // units (remember: number was left containing just units)

} 

/* 
 * This Routine sends the supplied byte to the LCD
 *
 * Note that you must supply appropriate definitions for the port pins
 * used by the LCD, and these must be bit-addressable
 *
 * Note also that the LCD must be properly initialised, and the control lines
 * in their proper states,  before calling this function.
 *
 * Note also that a software delay loop is used to set the length of the
 * Enable pulse - YOU WILL ALMOST CERTAINLY NEED TO MODIFY THIS TO MATCH
 * YOUR PARTICULAR CLOCK FREQUENCY, CHIP INSTRUCTION TIMINGS, COMPILER
 * SETTINGS, etc. (in fact, it would be better to write a separate assembler
 * delay routine).
 *
 */
void lcd_data( unsigned char dat) 
{ 
  unsigned char a; // Loop counter for the delay loop - YOU MAY NEED TO MODIFY THIS!


  LCD_RS=1;           // Set the Register Select line high indicating data for display
  LCD_RW=0; 		  // Set the Read/Write line low indicating a Write to the display
  LCD_PORT=( dat );   // Write the supplied byte to the LCD port


  // Now pulse the Enable line so that the LCD will see the data
  LCD_EN=1; 		      // Set the EN line high
  for( a=0; a<0xf; a++ ); // Pause a while - YOU WILL NEED TO MODIFY THIS!

  LCD_EN=0; 		      // Set the EN line low
}