/*----------------------------------------------------------------

  * $Id: Core.java,v 1.1.1.1 2004/01/26 20:46:18 pkb Exp $

  * 

  * (c)2001 - Paul Blankenbaker */

 //----------------------------------------------------------------

 package com.ccg.macros.at;

 import com.ccg.util.Log;

 import com.ccg.util.Debug;

 import com.ccg.macros.*;

 import java.io.*;

 import java.util.*;

 import java.text.*;

 //----------------------------------------------------------------

 /** Set of core macros which provide some standard basic features.

  * 

  * <code><pre>

  * class Example {

  *   public void main(String[] args) {

  *     com.ccg.macros.at.Core o = new com.ccg.macros.at.Core();

  *           System.out.println(o);

  *   }

  * }

  * </pre></code>

  * 

  * @version $Revision: 1.1.1.1 $

  * 

  * @since 1.0

  * 

  * @author $Author: pkb $ */

 //----------------------------------------------------------------

 public class Core extends Base {

   //----------------------------------------------------------------

   /** Constructs the object and readies it for {@link #install installation}.

    * 

    * @since        1.0

    * 

    * @see #install */

   //----------------------------------------------------------------

   public Core() {

     super(true);

     _Includes = new Hashtable();

     setLineSeparator(null);

   }

   //----------------------------------------------------------------

   /** Holds the string used to separate lines on the current platform

    * 

    * @serial        

    * 

    * @since        1.0  */

   //----------------------------------------------------------------

   private String _LineSeparator;

   //----------------------------------------------------------------

   /** Set the string used to separate lines on the current platform

    * 

    * @param        val

    * 

    *         New String value to assign - note, if you pass null, we will

    *         attempt to reset it based on the "line.separator" system

    *         property.

    * 

    * @see #getLineSeparator  */

   //----------------------------------------------------------------

   public void setLineSeparator(String val) {

     if (val == null) {

       val = System.getProperty("line.separator");

       if (val == null) val = "\n";

     }

     _LineSeparator = val;

   }

   //----------------------------------------------------------------

   /** Get the string used to separate lines on the current platform

    * 

    * @return

    * 

    *         Current String value assigned.

    * 

    * @see #setLineSeparator  */

   //----------------------------------------------------------------

   public String getLineSeparator() {

     return _LineSeparator;

   }

   //----------------------------------------------------------------

   /** @ifEqual(V1,V2,E,NE) macro - branching macro.

    * 

    * <p>This macro is used to compare two values (V1 and V2). If the

    * evaluation of the two values results in identical values, then

    * the equal statement (E) is evaluated, else the false statement

    * "NE" is evaluated.

    *

    * <pre>

    * @define(name,fred)@ifEqual("&#064name","barney","betty","wilma")

    * </pre>

    *

    * <p>The above should result in the output of "wilma".

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void ifEqual(Output out, Vector args)

     throws IOException, InterpretException {

     AtMacros am = getAtMacros();

     if ((args != null) && (args.size() >= 3)) {

       Object o1 = args.elementAt(0);

       Object o2 = args.elementAt(1);

       String v1 = null;

       String v2 = null;

       if (o1 != null) v1 = am.interpretCheck(o1.toString());

       if (o2 != null) v2 = am.interpretCheck(o2.toString());

       if (v1 == null) v1 = "";

       if (v2 == null) v2 = "";

       if (v1.equals(v2)) {        // if equal, do equal output if possible

         Object e = args.elementAt(2);

         if (e != null) out.write(am.interpretCheck(e.toString()));

       }

                                 // otherwise do not equal output if possible

       else if (args.size() >= 4) {

         Object ne = args.elementAt(3);

         if (ne != null) out.write(am.interpretCheck(ne.toString()));

       }

     }

   }

   //----------------------------------------------------------------

   /** @increment(NAME) increments value of integer macro by 1.

    * 

    * <p>This macro is used to increment the value of the macro "NAME"

    * by 1. If the macro does not exist or has a non numeric value, it

    * is created and initialized with a value of '1'.

    *

    * <pre>

    * @increment(cnt)@cnt,&#064increment(cnt)&#064cnt

    * </pre>

    *

    * <p>The above should result in the output of "1,2".

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void increment(Output out, Vector args)

     throws IOException, InterpretException {

     AtMacros am = getAtMacros();

     if ((args != null) && (args.size() >= 1)) {

       Object o1 = args.elementAt(0);

       if (o1 != null) {

         String mname = o1.toString();

         Object macro = am.getMacro(mname);

         if (macro == null) {

           am.addMacro(mname,"1");

         } else {

           String nstr = am.interpretCheck(""+am.getStartMacroChar()+mname);

           try {

             am.addMacro(mname,Integer.toString(Integer.parseInt(nstr)+1));

           } catch (Exception e) {

             am.addMacro(mname,"1");

           }

         }

       }

     }

   }

   //----------------------------------------------------------------

   /** @decrement(NAME) decrements value of integer macro by 1.

    * 

    * <p>This macro is used to decrement the value of the macro "NAME"

    * by 1. If the macro does not exist or has a non numeric value, it

    * is created and initialized with a value of '1'.

    *

    * <pre>

    * @define(cnt,4)@decrement(cnt)@cnt,&#064decrement(cnt)&#064cnt

    * </pre>

    *

    * <p>The above should result in the output of "3,2".

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void decrement(Output out, Vector args)

     throws IOException, InterpretException {

     AtMacros am = getAtMacros();

     if ((args != null) && (args.size() >= 1)) {

       Object o1 = args.elementAt(0);

       if (o1 != null) {

         String mname = o1.toString();

         Object macro = am.getMacro(mname);

         if (macro == null) {

           am.addMacro(mname,"-1");

         } else {

           String nstr = am.interpretCheck(""+am.getStartMacroChar()+mname);

           try {

             am.addMacro(mname,Integer.toString(Integer.parseInt(nstr)-1));

           } catch (Exception e) {

             am.addMacro(mname,"-1");

           }

         }

       }

     }

   }

   //----------------------------------------------------------------

   /** @ifDefined(MACRO,YES,NO) macro - branch if macro is defined.

    * 

    * <p>This macro is evaluates the <b>MACRO</b> name passed. If the

    * evaluated value of the <b>MACRO</b> is a defined macro, then the

    * <b>YES</b> clause is evaluated. Otherwise the <b>NO</b> clause is

    * evaluated.</p>

    *

    * <p>The following determines if the <b>&#064;name()</b> macro is

    * defined. If not, it defines it to "fred".

    *

    * <pre>

    * @ifDefined("name",,"@define("name","fred")")

    * </pre>

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void ifDefined(Output out, Vector args)

     throws IOException, InterpretException {

     AtMacros am = getAtMacros();

     if ((args != null) && ((args.size() == 2) || args.size() == 3)) {

       Object o1 = args.elementAt(0);

       String v1 = null;

       if (o1 != null) v1 = am.interpretCheck(o1.toString());

       if (v1 == null) v1 = "";

                                 // if macro is defined

       if (am.getMacro(v1) != null) {

         Object e = args.elementAt(1);

         if (e != null) out.write(am.interpretCheck(e.toString()));

       }

                                 // handle the undefined case

       else if (args.size() == 3) {

         Object e = args.elementAt(2);

         if (e != null) out.write(am.interpretCheck(e.toString()));

       }

     }

   }

   //----------------------------------------------------------------

   /** @fnb(V0[,V1[,V2[,...]) macro - find first "non-blank" value.

    * 

    * <p>This macro returns the first parameter that evaluates to

    * something other than white space (or no space). It is

    * particularily useful when defining macros where you want to

    * provide a default value if the user omits one. Here's an example

    * that defines "pkb" to print "Paul Blankenbaker (574-7964)" unless

    * a alternate phone number is passed:

    *

    * <pre>

    * @define("pkb","Paul Blankenbaker (&#064fnb("&#064param(0)","574-7964"))")

    * </pre>

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void fnb(Output out, Vector args)

     throws IOException, InterpretException {

     if (args != null) {

       int n = args.size();

       for (int i = 0; i < n; i++) {

         Object f = args.elementAt(i);

         if (f == null) continue;

                                 // as soon as we find a parameter that

                                 // isn't white space, append it and

                                 // exit

         String text = getAtMacros().interpretCheck(f.toString());

         if ((text != null) && (text.length() != 0) &&

             (text.trim().length() != 0)) {

           out.write(text);

           return;

         }

       }

     }

   }

   //----------------------------------------------------------------

   /** @param(N[,t|f]) macro - get parameter value

    * 

    * This macro is typically used in the definition of run time macros

    * (in the VAL parameter of "@define(NAME,VAL)". It allows a user

    * defined macro (run time defined) to reference the parameter

    * passed to its invocation. Take a look at the following:

    *

    * <pre>

    * @define(email,"<a href=\"mailto:@param(0)\">@param(0)</a>")

    * @email("paul@mekwin.com")

    * </pre>

    *

    * <p>The above defines a new run time macro "&#064;email", the new

    * "@email" macro allows the user to pass an argument which is

    * subsitutes in two places. This provides a means to make some

    * pretty powerful run time macros.

    *

    * <p>Note, the second parameter indicates whether you want the

    * value of the parameter to be interpretted or not. You can get the

    * exact value passed (instead of the default interrpretted

    * results), by passing "f".

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void param(Output out, Vector args)

     throws IOException, InterpretException {

     AtMacros am = getAtMacros();

     int size = args.size();

     if ((args != null) && (size >= 1)) {

       Object o = args.elementAt(0);

       int idx = -1;

       try {

         idx = Integer.parseInt(am.interpretCheck(o.toString()));

       } catch (Throwable t) {

         throw new InterpretException("@param("+o+") - "+t.getMessage());

       }

                                 // determine if parameter's value

                                 // should be evaluated

       boolean eval = true;

       if (size >= 2) {

         Object eo = args.elementAt(1);

         if (eo != null) {

           String estr = am.interpretCheck(eo.toString());

           if ((estr.length() > 0) && (estr.charAt(0) == 'f')) eval = false;

         }

       }

       //      out.write("eval:"+eval+"  param:"+am.getParameter(idx,false));

       out.write(am.getParameter(idx,eval));

     }

   }

   //----------------------------------------------------------------

   /** @quote(TEXT) macro - output text verbatim

    * 

    * This macro is invoked in the form "@quote(TEXT)". This macro only

    * looks at the first argument (additional arguments are

    * ignored). The text of the first argument is written verbatim to

    * the output device. This allows one to output macro names. For

    * example: <b>&#064;quote("&#064;quote(TEXT)")</b> would result in

    * <b>&#064;quote(TEXT)</b> in the output stream.

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void quote(Output out, Vector args)

     throws IOException, InterpretException {

     if ((args != null) && (args.size() >= 1)) {

       Object o = args.elementAt(0);

       if (o != null) out.write(o.toString());

     }

   }

   //----------------------------------------------------------------

   /** @setDocumentInfo(TYPE,INFO,yyyy-MM-dd) set information

    * about the document.

    *

    * <p>Often it is desirable to have a consistent set of macros to

    * retrieve information about the document being processed (such as

    * its last revision date, copyright, etc). This macro is used to

    * generate these values.

    *

    * <p>You typically use this macro at the start of your document in

    * the following form:

    *

    * <pre>

    * @setDocumentInfo("cvsId","$Id: Core.java,v 1.1.1.1 2004/01/26 20:46:18 pkb Exp $","2001-12-25")

    * </pre>

    *

    * <p>The following parameters are recognized:

    *

    * <dl>

    *

    * <dt>TYPE</dt><dd>This is the type of information from which we

    * are to get the document info from. This describes the format of

    * the INFO field. Currently, the only recognized type is "cvsId"

    * which means the info corresponds to the CVS Id value.</dd>

    *

    * <dt>INFO</dt><dd>This is the text string which provides

    * information about the document.</dd>

    *

    * <dt>yyyy-MM-dd</dt><dd>This is the copyright date associated with

    * the document. It must be in the format shown.</dd>

    *

    * </dl>

    * 

    * <p>This takes the information passed to it and then defines the

    * following macros:

    *

    * <dl>

    *

    * <dt>&#064;docLastModifiedMillis()</dt><dd>Will be the Java

    * millisecond count that the document was last modified - if unable

    * to determine from the information passed, the current time will

    * be used.</dd>

    *

    * <dt>&#064;docVersion()</dt><dd>Will be the version number

    * associated with the document, if unable to determine, this will

    * default to "0.0.1".</dd>

    *

    * <dt>&#064;copyRightYear()</dt><dd>Will be the year field from the

    * copy right.</dd>

    *

    * <dt>&#064;copyRightDate()</dt><dd>Will be the copy right date.</dd>

    *

    * <dt>&#064;copyRightMillis()</dt><dd>Will be the copy right date

    * as a Java millisecond time value.</dd>

    *

    * </dl>

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void setDocumentInfo(Output out, Vector args) 

     throws IOException, InterpretException {

     AtMacros am = getAtMacros();

                                 // set copyright info

     String cr = getStringParameter(args,2);

     SimpleDateFormat ymd = new SimpleDateFormat("y-M-d");

     ymd.setLenient(true);

     try {

       Date crDate = ymd.parse(cr);

       am.addMacro("copyRightDate",cr);

       am.addMacro("copyRightMillis",""+crDate.getTime());

       int dpos = cr.indexOf('-');

       am.addMacro("copyRightYear",cr.substring(0,dpos));

     } catch (ParseException pe) {

       throw new InterpretException("missing/bad copyright parameter "+

                                    "to setDocumentInfoMacro");

     }

     long lastMod = System.currentTimeMillis();

     String ver = "0.0.1";

     if (getStringParameter(args,0).equals("cvsId")) {

       String cvsId = getStringParameter(args,1);

       int vpos = cvsId.indexOf(",v ");

       if (vpos > 0) {

         vpos += 3;

         int spos = cvsId.indexOf(' ',vpos);

         if (spos > vpos) {

           ver = cvsId.substring(vpos,spos);

           try {

             SimpleDateFormat df = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");

             Date lastModDate = df.parse(cvsId.substring(spos+1));

             lastMod = lastModDate.getTime();

           } catch (Exception e) {

             throw new InterpretException("CVS modification date not in "+

                                          "yyyy/MM/dd HH:mm:ss format");

           }

         }

       }

     }

     am.addMacro("docLastModifiedMillis",""+lastMod);

     am.addMacro("docVersion",ver);

   }

   //----------------------------------------------------------------

   /** @formatMillis([MILLIS][,DATE_FMT[,TIME_FMT]],[TZ]) macro -

    * format a Java millisecond count.

    * 

    * <p>This macro is invoked in the form "&#064;millis(MILLIS)". This

    * macro accepts up to four arguments (how to format the date/time

    * and the time zone). Refer to the {@link SimpleDateFormat} class

    * if you want to specify your own custom format (like:

    * "yyyy-MM-dd").</p>

    *

    * <p>The four optional parameters to this macro accepts include:</p>

    *

    * <dl>

    *

    * <dt>MILLIS</dt><dd>This value can be the Java millisecond count

    * of the time to be formatted. If omitted, the current system time

    * is used.</dd>

    *

    * <dt>DATE_FMT</dt><dd>This parameter can be one of the Java

    * specific formats (like: "long", "short", etc - described

    * below). Or, it can be a full date/time format using the

    * characters recognized by the {@link java.text.SimpleDateFormat}

    * class (like "yyyy-MMM-dd hh:mm:ss").</dd>

    *

    * <dt>TIME_FMT</dt><dd>This parameter is only used if you want to

    * specify the locale specific formats supported by the Java run

    * time.</dd>

    *

    * <dt>TZ</dt><dd>You only need to pass this parameter if you want

    * to force a particular time zone. It may be any string value (it

    * will be interpretted first) recognized as a valid parameter to

    * {@link TimeZone#getTimeZone(String)}. For example: "UTC",

    * "America/Los_Angeles", or "GMT+10". If you pass a unrecognized

    * timezone, we will ignore your request (we will log a debug

    * message) and use the default time zone for the JVM.</dd>

    *

    * </dl>

    *

    * <p>If you want to use one of the built in local formats, pass use

    * one of the following keywords for the <b>DATE_FMT</b> and/or

    * <b>TIME_FMT</b> parameters:</p>

    *

    * <dl>

    *

    * <dt>none</dt><dd>Don't include (only one of the parameters should

    * be set to this value).</dd>

    *

    * <dt>short</dt><dd>Use the {@link DateFormat#SHORT} format for

    * this portion.

    *

    * <dt>medium</dt><dd>Use the {@link DateFormat#MEDIUM} format for

    * this portion.

    *

    * <dt>long</dt><dd>Use the {@link DateFormat#LONG} format for

    * this portion.

    *

    * <dt>full</dt><dd>Use the {@link DateFormat#FULL} format for

    * this portion.

    *

    * </dl>

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void formatMillis(Output out, Vector args) 

     throws IOException, InterpretException {

     String fmt = getStringParameter(args,1);

     String fmt2 = getStringParameter(args,2);

     String tz = getStringParameter(args,3);

     DateFormat df = null;

                                 // if we have the two argument form

     if (fmt2.length() > 0) {

       int dfmt = getDateTimeFormat(fmt);

       int tfmt = getDateTimeFormat(fmt2);

       if (dfmt != -1) {

         if (tfmt != -1) {

           df = DateFormat.getDateTimeInstance(dfmt,tfmt);

         }

         else {

           df = DateFormat.getDateInstance(dfmt);

         }

       }

       else if (tfmt != -1) {

         df = DateFormat.getTimeInstance(tfmt);

       }

     }

     else if (fmt.length() > 0) {

       df = new SimpleDateFormat(fmt);

     }

     if (df == null) df = DateFormat.getDateTimeInstance();

     String text = null;

     long now = getLongParameter(args,0,System.currentTimeMillis());

     Date curTime = new Date(now);

     if (tz.length() > 0) {

       try {

         df.setTimeZone(TimeZone.getTimeZone(tz));

       } catch (Throwable tze) {

         if (Debug.ENABLED && Debug.isEnabledFor(3)) {

           Debug.out("problem with time zone \""+tz+"\" - ignoring",tze);

         }

       }

     }

     try {

       text = df.format(curTime);

     } catch (Throwable t) {

       if (Debug.ENABLED && Debug.isEnabledFor(3)) {

         Debug.out("problem with date format:"+df,t);

       }

       text = DateFormat.getDateTimeInstance().format(curTime);

     }

     out.write(text);

   }

   //----------------------------------------------------------------

   /** @now() macro - dumps current time

    * 

    * <p>This macro is invoked in the form "&#064;now()". This macro

    * accepts one argument (how to format the date/time). Refer to the

    * {@link SimpleDateFormat} class if you want to specify your own

    * custom format (like: "yyyy-MM-dd").

    *

    * <p>If you want to use one of the built in local formats, pass two

    * arguments in the form "@now(DATE_FMT,TIME_FMT)", where the

    * first parameter corresponds to the format to use for the date

    * portion and the second parameter corresponds to what to use for

    * the time portion. The following formats are recognized:

    *

    * <dl>

    *

    * <dt>none</dt><dd>Don't include (only one of the parameters should

    * be set to this value).</dd>

    *

    * <dt>short</dt><dd>Use the {@link DateFormat#SHORT} format for

    * this portion.

    *

    * <dt>medium</dt><dd>Use the {@link DateFormat#MEDIUM} format for

    * this portion.

    *

    * <dt>long</dt><dd>Use the {@link DateFormat#LONG} format for

    * this portion.

    *

    * <dt>full</dt><dd>Use the {@link DateFormat#FULL} format for

    * this portion.

    *

    * </dl>

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   /*

   public void now(Output out, Vector args) 

     throws IOException, InterpretException {

     String fmt = getStringParameter(args,0);

     String fmt2 = getStringParameter(args,1);

     DateFormat df = null;

                                 // if we have the two argument form

     if (fmt2.length() > 0) {

       int dfmt = getDateTimeFormat(fmt);

       int tfmt = getDateTimeFormat(fmt2);

       if (dfmt != -1) {

         if (tfmt != -1) {

           df = DateFormat.getDateTimeInstance(dfmt,tfmt);

         }

         else {

           df = DateFormat.getDateInstance(dfmt);

         }

       }

       else if (tfmt != -1) {

         df = DateFormat.getTimeInstance(tfmt);

       }

     }

     else if (fmt.length() > 0) {

       df = new SimpleDateFormat(fmt);

     }

     if (df == null) df = DateFormat.getDateTimeInstance();

     String text = null;

     Date curTime = new Date();

     try {

       text = df.format(curTime);

     } catch (Throwable t) {

       if (Debug.ENABLED && Debug.isEnabledFor(3)) {

         Debug.out("problem with date format:"+df,t);

       }

       text = DateFormat.getDateTimeInstance().format(curTime);

     }

     out.write(text);

   }

   */

   //----------------------------------------------------------------

   /** @debug(LEVEL,TEXT) macro - debug output.

    * 

    * This macro is invoked in the form "@debug(LEVEL,TEXT)". If

    * the current {@link Debug#isEnabledFor debug level} is enabled for

    * the LEVEL specified, the text is interpretted and debug output is

    * generated. This can be VERY useful when tracking down problems in

    * your source file.

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void debug(Output out, Vector args)

     throws IOException, InterpretException {

                                 // get debug level

     int dlevel = getIntParameter(args,0,-1);

                                 // if we should output debug info, do so now

     if (dlevel >= 0 && Debug.ENABLED && Debug.isEnabledFor(dlevel)) {

                                 // use second argument as output to

                                 // debug message

       Debug.out(getStringParameter(args,1));

     }

   }

   //----------------------------------------------------------------

   /** @define(NAME,VAL[,OPT]) macro - define a new macro.

    * 

    * This macro is invoked in the form

    * "@define(NAME,VAL[,OPT])". This macro is used to define new

    * text replacement macros. The first argument NAME is the name of

    * the new macro to define (do not include the leading "@"

    * sign). The second argument VAL is the text which is to be

    * subsituted. The third arguments allows for some specialized

    * options during the definition. For example:

    *

    * <pre>

    * @define(pkb_email,"@quote(paul@mekwin.com)")

    * </pre>

    *

    * <p>After interpretting the above, one could then use

    * "@pkb_email()" in the document and have "paul@mekwin.com"

    * appear. It should be noted, that the "VAL" area can contain

    * references to other macros. For example:

    *

    * <pre>

    * @define(pkb,"Paul Blankenbaker (@pkb_email)")

    * </pre>

    *

    * <p>There are two important concepts to understand with the

    * above. One is that the @pkb macro just defined contains a

    * reference to another macro. This is handled properly and the

    * contained @pkb_email reference will be expanded each time the

    * @pkb macro is used. The second concept is that the expansion

    * occurs at the time the @pkb macro is used, not at the time it is

    * defined. In other words, if someone changed the definition of the

    * @pkb_email macro, then it would affect subsequent invocations of

    * the @pkb macro.

    *

    * <p>The third parameter to this macro is optional, and can be

    * extremely useful in some circumstances. The third parameter can

    * be one of the following:

    *

    * <dl>

    *

    * <dt><b>ifnew</b></dt><dd>The "ifnew" option means that the

    * definition should only be accepted if a definition does not

    * already exist. This can be a very handy way to provide default

    * values.</dd>

    *

    * <dt><b>now</b></dt><dd>The "now" option means that the value

    * should be interpretted immediately (right now). This can be more

    * efficient and prevents future changes from having affects.</dd>

    *

    * </dl>

    *

    * <p>To get an idea of how these behave, try running the the

    * following through to see what comes out:

    *

    * <pre>

    * @define("name","Joe Schmoe")

    * @define("phone","333-333-3333")

    * @define("pname","@name @phone")

    * @define("nname","@name @phone","now")

    * @define("phone","444-444-4444")

    * @define("phone","555-555-5555","ifnew")

    * @quote("@pname=")@pname

    * @quote("@nname=")@nname

    * </pre>

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void define(Output out, Vector args) 

     throws IOException, InterpretException {

     AtMacros am = getAtMacros();

     if ((args != null) && (args.size() >= 2)) {

                                 // allow interpretation of name

       String name = getStringParameter(args,0);

       Object v = args.elementAt(1);

       if ((name != null) && (v != null)) {

         String val = v.toString();

                                 // see if any special options specified

         if (args.size() > 2) {

           Object op = args.elementAt(2);

           String opStr = null;

           if (op != null) opStr = op.toString();

           if (opStr != null) {

                                 // "now" option requires us to evaluate now

             if (opStr.equals("now")) { val = am.interpretCheck(val); }

                                 // "ifnew" option means to skip

                                 // definition if already defined

             else if (opStr.equals("ifnew")) {

               if (am.getMacro(name) != null) return;

             }

           }

         }

         am.addMacro(name,val);

       }

     }

   }

   //----------------------------------------------------------------

   /** @definition(NAME) macro - fetch definition of a macro.

    * 

    * This macro is mainly used for debugging purposes, it returns the

    * current definition of a macro. You pass the NAME of the macro

    * (without the leading "@" symbol) which you want to retrieve the

    * definition for. The current definition of the macro is returned

    * as a text string. If the macro was created with the

    * "@define(NAME,VAL)" macro, then the returned text will be

    * "VAL". If the macro is a built-in macro (such as

    * "@definition(NAME)", then the returned value will be the name of

    * the Java class/method used to handle the macro.

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void definition(Output out, Vector args) 

     throws IOException, InterpretException {

     AtMacros am = getAtMacros();

     if ((args != null) && (args.size() >= 1)) {

       Object n = args.elementAt(0);

       if (n != null) {

         Object o = am.getMacro(n.toString());

         out.write(o);

       }

     }

   }

   //----------------------------------------------------------------

   /** @systemProperty(NAME[,DEF]) macro - fetch a specific system

    * property.

    * 

    * This macro is evaluates the "NAME" parameter and then tries to

    * fetch the "system property" it identifies. If the system property

    * is successfully retrieved, it is returned. Otherwise, if the

    * system property is not available (or attempts to retrieve it

    * result in some sort of error), the optional DEF parameter is

    * evaluated and returned.

    *

    * <p>Here are some sample (and useful definitions) out of "Core.At"

    * which area available and make use of this:

    *

    * <pre>

    * @define("userName","@systemProperty("user.name","unknown")","now")

    * @define("userHome","@systemProperty("user.home",".")","now")

    * </pre>

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void systemProperty(Output out, Vector args) 

     throws IOException, InterpretException {

     String key = getStringParameter(args,0);

     String text = null;

     try {

       text = System.getProperty(key);

     } catch (Throwable t) { 

       if (Debug.ENABLED && Debug.isEnabledFor(3)) {

         Debug.out("problem retrieving system property for \""+key+"\":"+t);

       }

     }

     if (text == null) text = getStringParameter(args,1);

     if (text.length() > 0) out.write(text);

   }

   //----------------------------------------------------------------

   /** @dumpDefinitions() macro - dump definition of all macros.

    * 

    * <p>This macro is mainly used for debugging purposes. It dumps the

    * definition of ALL defined macros.

    *

    * <p>NOTE: You may optionally pass a single argument to this

    * method. If passed, the argument will be expanded for each

    * definition in our macro dictionary. The following macros will be

    * available:

    *

    * <dl> 

    *

    * <dt>&#064;dumpDefName()</dt><dd>The name of the macro the

    * definition refers to.

    *

    * <dt>&#064;dumpDefValue()</dt><dd>The string value of the macro

    * (this may be the name of the Java method used to evaluate

    * it.</dd>

    *

    * </dl>

    *

    * <p>Here is an example which produces the same results as the

    * default output:

    *

    * <pre>

    * @dumpDefinitions("@dumpDefName()=@dumpDefValue()

    * ")

    * </pre>

    *

    * <p>Here's an example which provides a little fancier output in

    * HTML:

    *

    * <pre>

    * @dumpDefinitions("<h2>@quote(@)@dumpDefName()</h2>

    * <pre>

    * @htmlEscape("@dumpDefValue()")

    * </pre>

    * ")

    * </pre>

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void dumpDefinitions(Output out, Vector args) 

     throws IOException, InterpretException {

     AtMacros am = getAtMacros();

                                 // default dump ouput

     String format = "@dumpDefName()=@dumpDefValue()"+_LineSeparator;

                                 // see if user overrode format

     if ((args != null) && (args.size() > 0)) {

       Object o = args.elementAt(0);

       if (o != null) format = o.toString();

     }

                                 // get and sort macro names that are defined

     Vector allNames = new Vector(500);

     Enumeration keys = am.getMacroNames();

     while (keys.hasMoreElements()) {

       String name = keys.nextElement().toString();

       allNames.addElement(name);

     }

     String[] mnames = new String[allNames.size()];

     for (int i = 0; i < mnames.length; i++) {

       mnames[i] = (String) allNames.elementAt(i);

     }

     Arrays.sort(mnames,new com.ccg.util.CompareStrings());

     class Verbatim implements MacroHandler {

       String _Text;

       public void process(Output ov, Vector av)

         throws IOException, InterpretException {

         ov.write(_Text);

       }

     }

     Verbatim v = new Verbatim();

     am.addMacro("dumpDefValue",v);

                                 // now, go process each macro definition

     for (int i = 0; i < mnames.length; i++) {

       am.addMacro("dumpDefName",mnames[i]);

       v._Text = am.getMacro(mnames[i]).toString();

       out.write(am.interpretCheck(format));

     }

                                 // reset to blank definitions - not

                                 // sure if we need to do this

     //    am.addMacro("dumpDefName",null);

     //    am.addMacro("dumpDefValue",null);

     /*

     String beforeAll = null;

     //    String beforeEach = ""+am.getStartMacroChar()+"define(\"";

     //    String betweenEach = "\",\"";

     //    String afterEach = "\")\n";

     String beforeEach = null;

     String betweenEach = "=";

     String afterEach = "\n";

     String afterAll = null;

     Enumeration keys = am.getMacroNames();

     while (keys.hasMoreElements()) {

       String name = keys.nextElement().toString();

       Object o = am.getMacro(name);

       if (beforeEach != null) out.write(beforeEach);

       out.write(name);

       out.write(betweenEach);

       out.write(o);

       out.write(afterEach);

     }

     */

   }

   //----------------------------------------------------------------

   /** @include(SOURCE,[IGNERR],[NOOUT]) insert and process other file(s).

    * 

    * <p>This macro is used to load and process the contents of another

    * file. Currently the full or relative path to the source must be

    * specified (in the future, path searching may be added).

    *

    * <p>It should be noted however, that the CLASSPATH and/or JAR

    * files are searched. For example, the file

    * "/com/ccg/macros/at/Jnlp.At" would be found as its included with

    * the distribution. Check the "/com/ccg/macros/at" directory for

    * "*.At" files which are available.

    *

    * <p>For example, to include the file

    * "/opt/include/atmacros/companies.atmacros", one could use the

    * following command:

    *

 <pre>

 @include("/etc/hosts")

 </pre>

    *

    * <p>The second parameter IGNERR is optional. It may be set to

    * either "true" or "false" (only first letter is checked). If

    * omitted, it defaults to a value of "false". When set to "true",

    * then no error will be thrown if the file is not found. If set to

    * "false" (or omitted), then an error will be thrown if the desired

    * SOURCE could not be found.

    *

    * <p>The third parameter DISOUT is optional. It may be set to

    * either "true", "false", "cdata" or "definitions" (only first letter is

    * checked). If omitted, it defaults to a value of "false". When set

    * to "true", then no output will be produced while interpretting

    * the file included (this allows one to load definition

    * files). When set to "false" (or omitted), any output produced as

    * a result of interpretting the file will be written to the current

    * output device. When set to "definition" (or "d"), no output will

    * be generated, AND the file will only be included if it has not be

    * included in the past (this is useful when you don't want to

    * bother processing macro definition files more than once).</p>

    *

    * <p>When the third parameter is set to "cdata" (or "c"), the

    * contents of the file are treated as character data (similar to

    * XML) and placed in the output verbatim.</p>

    *

    * <p>When using this directive to include definition files, it is

    * often handy to set the DISOUT value to "definition" (or "d") to

    * disable any output as a result of interpretting the definition

    * file (this allows one to enter comments in their definition

    * files). It also prevents the same definitions from being loaded

    * more than once during a run.</p>

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.