root/trunk/src/tutorials/d2html/d2html.d

/*
 * Copyright (c) 2001
 * Pavel "EvilOne" Minayev
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Author makes no representations about
 * the suitability of this software for any purpose. It is provided
 * "as is" without express or implied warranty.
 
 * Updated by J C Calvarese, http://jcc_7.tripod.com/d/, 2003/12/18
    Modifications donated to the public domain.  

    Fixed:
     + Compiles with DMD 0.76
     + "Naked" escape sequences (\n, \r, etc.).
     + Escape sequences in character literals ('\'').
     + Supporsts WYSIWYG (``) strings.
     + Endless loop for 0x1 or 0b1.
     + Nestable (/+ +/) comments.
     + Escape sequence for backslashes (\\).
     + Added identifier output option.
     + Fixed problem with single-line comments added an extra CR or LF.

    To-Do:
     +  Teach the program to expect the end of the file rather than just react to it.
     +  Unicode support.
     + <br> in embedded strings is mis-handled (should convert to "&lt;br&gr;".
     + r"WYSIWYG" is probably not handled correctly for special case such as r"\" (but maybe it is right).
     + d2html should say what the problem is if quotes (or block comments) are unmatched.
*/


import std.c.stdio;
import std.string;
import std.stream;




/* Colors for syntax highlighting, default values are
   Pavel Minayev's preferences in Microsoft Visual Studio editor   */
class Colors
{
    static char[] keyword = "0000FF";
    static char[] number  = "008000";
    static char[] string  = "000080";
    static char[] comment = "808080";
}

const int tabsize = 4;  /* number of spaces in tab */
const char[24] symbols = "()[]{}.,;:=<>+-*/%&|^!~?";
char[][] keywords;
version(talkative) int lineNumber = 0;


bit isspace(char c)
/* true if c is whitespace, false otherwise */
{
    version(talkative) if (c==10) lineNumber++;
    return std.string.find(whitespace, c) >= 0;
}

bit isalpha(char c)
/* true if c is a letter or an underscore, false otherwise */
{
    /* underscore doesn't differ from letters in D anyhow... */
    return c == '_' || std.string.find(letters, c) >= 0;
}

bit isdigit(char c)
/* true if c is a decimal digit, false otherwise */
{   
    return cast(bit) ((std.string.find(digits, c) >= 0) ? true : (c == '_'));
    
}

bit ishexdigit(char c)
/* true if c is a hexadecimal digit, false otherwise */
{
    return cast(bit) ((std.string.find(hexdigits, c) >= 0) ? true : (c == '_'));
}

bit isoctdigit(char c)
/* true if c is an octal digit, false otherwise */
{
    return cast(bit) ((std.string.find(octdigits, c) >= 0) ? true : (c == '_'));
}

bit issymbol(char c)
/* true if c is legal D symbol other than above, false otherwise */
{
    return find(symbols, c) >= 0;
}

bit iskeyword(char[] token)
/* true if token is a D keyword, false otherwise */
{
    for (int i = 0; i < keywords.length; i++)
        if (!cmp(keywords[i], token))
            return true;
    return false;
}



char[] baseFilenameWithPath(char[] r)
{   /*  By J C Calvarese
        Returns the path & filename without the extension. */

    int i;
    char[] s;


    version(very_talkative) printf("Looking for \".\" in \"%.*s\"...\n\0", r);
    if(r.length > 0) i = rfind(r, '.');

    version(very_talkative) printf("Result: %d\n\0", i);
    
    if (i > 0) s = r[0..i];
    else s = r;
    version(very_talkative) printf("Return baseFilenameWithPath\n\0");
    
    return s;

}



int main(char[][] args)
{
    bit outputIdentifiers;
    File idFile;
    char[] fn;
    char[] fnIdent;
    bit useStyleSheet;
    bit xhtmlFormat; 


    
    void analyzeOptions(char[] s)
    {  
        
        switch(s)
        {  
            case "-i":
                version(very_talkative) printf("Produce identifier list: true.\n");
                outputIdentifiers = true;
                fnIdent = null;
                fnIdent = baseFilenameWithPath(args[1]) ~ ".id";
                break;
                
            case "-s":
                version(very_talkative) printf("Use a style-sheet.\n");             
                useStyleSheet = true;
                break;
            
            case "-x":
                version(very_talkative) printf("XHTML format.\n");              
                xhtmlFormat = true;
                break;
                
            default:
                printf("Warning: Unknown option (%.*s).\n", s);
        }
        

    }

    
    version(very_talkative) printf("Starting program...\n\0");
    
    /* need help? */
    if (args.length < 2) // || args.length > 3)
    {
        printf("D to HTML converter\n"
               "Usage: D2HTML program.d [file.html] [-i]\n"
               \n
               "program.d: source file\nfile.html: output file\n"
               "-i:        produce list of identifiers\n"
               "-s:        use a stylesheet\n"
               "-x:        XHTML format\n");
        return 0;
    }
    
    
    /* auto-name output file */
    fn = baseFilenameWithPath(args[1]) ~ ".html";
    fnIdent = baseFilenameWithPath(args[1]) ~ ".id";
    
    version(very_talkative) printf("Checking argument list...\n\0");

    if (args.length > 2) for(int i = 2; i < args.length; i++)
    {
        if(args[i][0..1] == "-")
            analyzeOptions(args[i]);
        else
        {  
            if(args[i].length > 2)
                if(args[i][0..1] == "-")
                    analyzeOptions(args[i]);
                else
                {
                    version(very_talkative) printf("Override default output name.\n\0");
                    fn = null; 
                    fn = args[i]; /* override auto-name */
                }
            else
            {
                version(very_talkative) printf("Override default output name.\n\0");
                fn = null; 
                fn = args[i]; /* override auto-name */
            }
        }
    }
    
    /* load keywords */
    version(talkative) printf("Reading in keywords...\t\0");
    File kwd = new File("d2html.kwd");
    while (!kwd.eof())
    {
        keywords.length = keywords.length + 1;
        keywords[][keywords.length - 1] = kwd.readLine();
    }
    version(talkative) 
    {
        printf("Read in keywords.\n\0");
        for(int i=0; i < keywords.length; i++)
            printf(cast(char*) (keywords[i] ~ "\t" ~ "\0"));
        version(talkative) printf("\n\0");
    }
    kwd.close();
    
    /* open input and output files */
    File src = new File(args[1]), dst = new File;
    dst.create(fn);
    
    if(outputIdentifiers)
    { 
        idFile = new File;
        idFile.create(fnIdent);
    }

    /* write HTML header */
    if(xhtmlFormat) 
        dst.writeLine("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">");
    else
        dst.writeLine("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\">");
    dst.writeLine("<html><head><title>" ~ args[1] ~ "</title>");
    if(useStyleSheet) 
        dst.writeLine("<link rel=\"stylesheet\" href=\"style.css\"" ~ (xhtmlFormat ? "\\" : "") ~ ">");
    dst.writeLine("</head>");
    if(useStyleSheet) 
        dst.writeLine("<body><pre><code>");
    else
        dst.writeLine("<body color='#000000' bgcolor='#FFFFFF'><pre><code>");
    
    /* the main part is wrapped into try..catch block because
       when end of file is reached, an exception is raised;
       so we can omit any checks for EOF inside this block... */
    try
    {
        int linestart = 0;  /* for tabs */
        char c;
        char c2;
        
        src.read(c);
        while (true)
        {
            if (isspace(c))     /* whitespace */
            {
                do
                {
                    
                    switch(c)
                    { 
                        case 9: /* tab character */
                            /* expand tabs to spaces */
                            int spaces = tabsize -
                                (src.position() - linestart) % tabsize;
                            for (int i = 0; i < spaces; i++)
                                dst.writeString(" ");
                            linestart = src.position() - tabsize + 1;
                            break;
                            
                        case 10: /* linefeed */
                            linestart = src.position() + 1; /* reset line start on newline */
                            dst.write(c);

                            break;
                            
                        case 13: /* control return */
                            linestart = src.position() + 1; /* reset line start on newline */
                            
                            if (c2 != 10)
                                dst.write(c);                               
                            break;
                            
                        default: /* space is left, anything else? */
                            dst.write(c);
                            break;

                    }
                    
                    c2 = c;
                    src.read(c);
                
                } while (isspace(c));
            }
            else if (isalpha(c))    /* keyword or identifier */
            {
                char[] token;
                do
                {
                    token ~= c;
                    src.read(c);
                } while (isalpha(c) || isdigit(c));
                if (iskeyword(token))   /* keyword */
                    if(useStyleSheet)
                        dst.writeString("<span class=\"keyword\">" ~ token ~ "</span>");
                    else
                        dst.writeString("<font color='#" ~ Colors.keyword ~
                        "'>" ~ token ~ "</font>");
                else    /* simple identifier */
                {   
                    /* add identifier to the identifier list, if desired */
                
                    if(outputIdentifiers)
                        idFile.writeString(token ~ \n);             
                    
                    dst.writeString(token);                 
                }
            }
            else if (c == '0')  /* binary, octal or hexadecimal number */
            {
                if(useStyleSheet)
                    dst.writeString("<span class=\"number\">");                 
                else
                    dst.writeString("<font color='#" ~ Colors.number ~ "'>");
                dst.write(c);
                src.read(c);
                if (c == 'X' || c == 'x')   /* hexadecimal */
                {
                    dst.write(c);
                    src.read(c);
                    while (ishexdigit(c))
                    {
                        dst.write(c);
                        src.read(c);
                    }
                    /* TODO: add support for hexadecimal floats */
                }
                else if (c == 'B' || c == 'b')  /* binary */
                {
                    dst.write(c);
                    src.read(c);
                    while (c == '0' || c == '1' || c == '_' )
                    {
                        dst.write(c);
                        src.read(c);
                    }
                                    }
                else    /* octal */
                {
                    do
                    {
                        dst.write(c);
                        src.read(c);
                    } while (isoctdigit(c))
                    {
                        dst.write(c);
                        src.read(c);
                    }
                }
                if(useStyleSheet)
                    dst.writeString("</span>");
                else
                    dst.writeString("</font>");
            }
            else if (isdigit(c))    /* decimal number */
            {
                if(useStyleSheet)
                    dst.writeString("<span class=\"number\">");
                else
                    dst.writeString("<font color='#" ~ Colors.number ~ "'>");
                /* integral part */
                do
                {
                    dst.write(c);
                    src.read(c);
                } while (isdigit(c));
                /* fractional part */
                if (c == '.')
                {
                    dst.write(c);
                    src.read(c);
                    while (isdigit(c))
                    {
                        dst.write(c);
                        src.read(c);
                    }
                }
                /* scientific notation */
                if (c == 'E' || c == 'e')
                {
                    dst.write(c);
                    src.read(c);
                    if (c == '+' || c == '-')
                    {
                        dst.write(c);
                        src.read(c);
                    }
                    while (isdigit(c))
                    {
                        dst.write(c);
                        src.read(c);
                    }
                }
                /* suffixes */
                while (c == 'U' || c == 'u' || c == 'L' ||
                    c == 'l' || c == 'F' || c == 'f')
                {
                    dst.write(c);
                    src.read(c);
                }
                dst.writeString(useStyleSheet ? "</span>" : "</font>");             
            }
            else if (c == '\\')   /* naked escape sequence (\) */
            {
                if(useStyleSheet)
                    dst.writeString("<span class=\"string\">");
                else    
                    dst.writeString("<font color='#" ~ Colors.string ~ "'>");
                char prev;  /* used to handle \" properly */
                dst.write(c);
                prev = c;
                src.read(c);
                dst.write(c);
                src.read(c);

                dst.writeString(useStyleSheet ? "</span>" : "</font>");             
            }
            else if (c == '"')  /* string (") with escape sequences  */
            {
                if(useStyleSheet)
                    dst.writeString("<span class=\"string\">");
                else    
                    dst.writeString("<font color='#" ~ Colors.string ~ "'>");
                char prev;  /* used to handle \" properly */
                bit isEscape;
                do
                {
                    if (c == '<')   /* special symbol in HTML */
                        dst.writeString("&lt;");
                    else
                        dst.write(c);
                    
                    prev = c;
                    if ((prev == '\\' && c == '"') || (prev == '\\' && c == '\\') && !isEscape) 
                        isEscape = true;
                    else
                        isEscape = false;
                    
                    src.read(c);
                } while (isEscape || c != '"'); 
                
                dst.write(c);
                src.read(c);
                
                dst.writeString(useStyleSheet ? "</span>" : "</font>");             
            }
            else if (c == '\'') /* character (') with escape sequences  */
            {
                if(useStyleSheet)
                    dst.writeString("<span class=\"string\">");
                else    
                    dst.writeString("<font color='#" ~ Colors.string ~ "'>");
                char prev;  /* used to handle \" properly */
                bit isEscape;
                do
                {
                    if (c == '<')   /* special symbol in HTML */
                        dst.writeString("&lt;");
                    else
                        dst.write(c);
                        
                    prev = c;
                    
                    if ((prev == '\\' && c == '\'') || (prev == '\\' && c == '\\') && !isEscape) 
                        isEscape = true;
                    else
                        isEscape = false;
                    
                    src.read(c);
                } while (isEscape || c != '\'');
                dst.write(c);
                src.read(c);
                
                dst.writeString(useStyleSheet ? "</span>" : "</font>");             
            }
            else if (c == '`')  /* character (`) with no escape sequences */
            {
                if(useStyleSheet)
                    dst.writeString("<span class=\"string\">");
                else    
                    dst.writeString("<font color='#" ~ Colors.string ~ "'>");
                do
                {
                    if (c == '<')   /* special symbol in HTML */
                        dst.writeString("&lt;");
                    else
                        dst.write(c);
                    src.read(c);
                } while (!(c == '`')); /* 96 */
                dst.write(c);
                src.read(c);
                
                dst.writeString(useStyleSheet ? "</span>" : "</font>");             
            }
            else if (issymbol(c))   /* either operator or comment */
            {
                if (c == '<')   /* special symbol in HTML */
                {
                    dst.writeString("&lt;");
                    src.read(c);
                }
                else if (c == '/')  /* could be a comment... */
                {
                    src.read(c);
                    if (c == '/')   /* single-line one */
                    {
                        if(useStyleSheet)
                            dst.writeString("<span class=\"comment\">/");
                        else                        
                            dst.writeString("<font color='#" ~ Colors.comment ~ "'>/");
                        while (c != 10 && c != 13)
                        {
                            if (c == '<')   /* special symbol in HTML */
                                dst.writeString("&lt;");
                            else if (c == 9)
                            {
                                /* expand tabs */
                                int spaces = tabsize -
                                    (src.position() - linestart) % tabsize;
                                for (int i = 0; i < spaces; i++)
                                    dst.writeString(" ");
                                linestart = src.position() - tabsize + 1;
                            }
                            else
                                dst.write(c);
                            c2 = c; 
                            src.read(c);
                        }
                        dst.writ