GridLAB-D: core/output.c Source File

00001 
00033 #include <stdlib.h>
00034 #include <stdarg.h>
00035 #include <stdio.h>
00036 #include <errno.h>
00037 #include <string.h>
00038 #include "output.h"
00039 #include "globals.h"
00040 #include "exception.h"
00041 
00042 static char buffer[65536];
00043 #define CHECK 0xcdcd
00044 int overflow=CHECK;
00045 
00049 static struct s_redirection {
00050     FILE *output;
00051     FILE *error;
00052     FILE *warning;
00053     FILE *debug;
00054     FILE *verbose;
00055     FILE *profile;
00056     FILE *progress;
00057 } redirect;
00058 FILE* output_redirect_stream(char *name, FILE *fp)
00059 {
00060     struct {
00061         char *name;
00062         FILE **file;
00063         char *defaultfile;
00064     } map[] = {
00065         {"output",&redirect.output,"gridlabd.out"},
00066         {"error",&redirect.error,"gridlabd.err"},
00067         {"warning",&redirect.warning,"gridlabd.wrn"},
00068         {"debug",&redirect.debug,"gridlabd.dbg"},
00069         {"verbose",&redirect.verbose,"gridlabd.inf"},
00070         {"profile",&redirect.profile,"gridlabd.pro"},
00071         {"progress",&redirect.progress,"gridlabd.prg"},
00072     };
00073     int i;
00074     for (i=0; i<sizeof(map)/sizeof(map[0]); i++) 
00075     {
00076         if (strcmp(name,map[i].name)==0)
00077         {
00078             char *mode = "w";
00079             FILE *oldfp = *(map[i].file);
00080             *(map[i].file) = fp;
00081 #ifndef WIN32
00082             if (*(map[i].file))
00083                 setlinebuf(*(map[i].file));
00084 #endif
00085             return oldfp;
00086         }
00087     }
00088     return NULL;
00089 }
00090 
00091 void (*notify_error)(void) = NULL;
00092 int output_notify_error(void (*notify)(void))
00093 {
00094     notify_error = notify;
00095     return 0;
00096 }
00097 
00098 FILE* output_redirect(char *name, char *path)
00099 {
00100     struct {
00101         char *name;
00102         FILE **file;
00103         char *defaultfile;
00104     } map[] = {
00105         {"output",&redirect.output,"gridlabd.out"},
00106         {"error",&redirect.error,"gridlabd.err"},
00107         {"warning",&redirect.warning,"gridlabd.wrn"},
00108         {"debug",&redirect.debug,"gridlabd.dbg"},
00109         {"verbose",&redirect.verbose,"gridlabd.inf"},
00110         {"profile",&redirect.profile,"gridlabd.pro"},
00111         {"progress",&redirect.progress,"gridlabd.prg"},
00112     };
00113     int i;
00114     for (i=0; i<sizeof(map)/sizeof(map[0]); i++) 
00115     {
00116         if (strcmp(name,map[i].name)==0)
00117         {
00118             char *mode = "w";
00119             if (*(map[i].file)!=NULL)
00120                 fclose(*(map[i].file));
00121             
00122             /* test for append mode, path led with + */
00123             if (path != NULL && path[0]=='+')
00124             {   mode = "a";
00125                 path++;
00126             }
00127             *(map[i].file) = fopen(path?path:map[i].defaultfile,"w");
00128 #ifndef WIN32
00129             if (*(map[i].file))
00130                 setlinebuf(*(map[i].file));
00131 #endif
00132             return *(map[i].file);
00133         }
00134     }
00135     return NULL;
00136 }
00137 
00141 static FILE *curr_stream[3] = {NULL, NULL, NULL};
00142 static int stream_prep = 0;
00143 static void prep_stream(){
00144     if(stream_prep)
00145         return;
00146     stream_prep = 1;
00147     if(curr_stream[FS_IN] == NULL){
00148         curr_stream[FS_IN] = stdin;
00149 #ifdef DEBUG
00150         if (global_verbose_mode) printf("    ... prep_stream() set FS_IN to stdin\n");
00151 #endif
00152     }
00153     if(curr_stream[FS_STD] == NULL){
00154         curr_stream[FS_STD] = stdout;
00155 #ifdef DEBUG
00156         if (global_verbose_mode) printf("    ... prep_stream() set FS_STD to stdout\n");
00157 #endif
00158     }
00159     if(curr_stream[FS_ERR] == NULL){
00160         curr_stream[FS_ERR] = stderr;
00161 #ifdef DEBUG
00162         if (global_verbose_mode) printf("    ... prep_stream() set FS_ERR to stderr\n");
00163 #endif
00164     }
00165     return;
00166 }
00167 
00168 int output_init(int argc,char *argv[])
00169 {
00170     atexit(output_cleanup);
00171     return 1;
00172 }
00173 
00174 void output_cleanup(void)
00175 {
00176     /* NULL purges buffers */
00177     output_verbose(NULL);
00178     output_warning(NULL);
00179     output_error(NULL);
00180     output_fatal(NULL);
00181     output_message(NULL);
00182     output_debug(NULL);
00183 }
00184 
00185 static int default_printstd(char *format,...)
00186 {
00187     int count;
00188     va_list ptr;
00189     prep_stream();
00190     va_start(ptr,format);
00191     count = vfprintf(curr_stream[FS_STD],format,ptr);
00192     va_end(ptr);
00193     return count;
00194 }
00195 
00196 static int default_printerr(char *format,...)
00197 {
00198     int count;
00199     va_list ptr;
00200     prep_stream();
00201     va_start(ptr,format);
00202     count = vfprintf(curr_stream[FS_ERR],format,ptr);
00203     va_end(ptr);
00204     fflush(curr_stream[FS_ERR]);
00205     return count;
00206 }
00207 
00208 FILE *output_set_stream(FILESTREAM fs, FILE *newfp){
00209     FILE *oldfp = curr_stream[fs];
00210     if(fs > FS_ERR) /* input check */
00211         return NULL;
00212     if(newfp == NULL)
00213         return NULL;
00214     curr_stream[fs] = newfp;
00215     return oldfp;
00216 }
00217 
00218 static PRINTFUNCTION printstd=default_printstd, printerr=default_printerr;
00219 
00226 void output_both_stdout(){
00227     curr_stream[FS_STD] = stdout;
00228     curr_stream[FS_ERR] = stdout;
00229 }
00230 
00237 PRINTFUNCTION output_set_stdout(PRINTFUNCTION call) 
00238 {
00239     PRINTFUNCTION old = printstd;
00240     printstd = call;
00241     return old;
00242 }
00243 
00250 PRINTFUNCTION output_set_stderr(PRINTFUNCTION call) 
00251 {
00252     PRINTFUNCTION old = printerr;
00253     printerr = call;
00254     return old;
00255 }
00256 
00257 static char time_context[256]="INIT";
00258 void output_set_time_context(TIMESTAMP ts)
00259 {
00260     convert_from_timestamp(ts,time_context,sizeof(time_context)-1);
00261 }
00262 char *output_get_time_context(void)
00263 {
00264     return time_context;
00265 }
00266 
00273 int output_fatal(char *format,...) 
00274 {
00275     /* check for repeated message */
00276     static char lastfmt[4096] = "";
00277     static int count=0;
00278     if (format!=NULL && strcmp(lastfmt,format)==0 && global_suppress_repeat_messages && !global_verbose_mode)
00279     {
00280         count++;
00281         return 0;
00282     }
00283     else
00284     {
00285         va_list ptr;
00286         int len=0;
00287         strncpy(lastfmt,format?format:"",sizeof(lastfmt)-1);
00288         if (count>0 && global_suppress_repeat_messages && !global_verbose_mode)
00289         {
00290             len = sprintf(buffer,"last fatal error message was repeated %d times", count);
00291             count = 0;
00292             if(format == NULL) goto Output;
00293             else len += sprintf(buffer+len,"\nFATAL [%s] : ",time_context);
00294         }
00295         else if (format==NULL)
00296             return 0;
00297         va_start(ptr,format);
00298         vsprintf(buffer+len,format,ptr); /* note the lack of check on buffer overrun */
00299         va_end(ptr);
00300     }
00301 Output:
00302     if (redirect.error)
00303         return fprintf(redirect.error,"FATAL [%s] : %s\n", time_context, buffer);
00304     else
00305         return (*printerr)("FATAL [%s] : %s\n", time_context, buffer);
00306 }
00307 
00314 int output_error(char *format,...) 
00315 {
00316     /* check for repeated message */
00317     static char lastfmt[4096] = "";
00318     static int count=0;
00319     if (format!=NULL && strcmp(lastfmt,format)==0 && global_suppress_repeat_messages && !global_verbose_mode)
00320     {
00321         count++;
00322         return 0;
00323     }
00324     else
00325     {
00326         va_list ptr;
00327         int len=0;
00328         strncpy(lastfmt,format?format:"",sizeof(lastfmt)-1);
00329         if (count>0 && global_suppress_repeat_messages && !global_verbose_mode)
00330         {
00331             len = sprintf(buffer,"last error message was repeated %d times", count);
00332             count = 0;
00333             if(format == NULL) goto Output;
00334             else len += sprintf(buffer+len,"\nERROR [%s] : ",time_context);
00335         }
00336         else if (format==NULL)
00337             return 0;
00338         va_start(ptr,format);
00339         vsprintf(buffer+len,format,ptr); /* note the lack of check on buffer overrun */
00340         va_end(ptr);
00341     }
00342 Output:
00343 
00344     if (notify_error!=NULL)
00345         (*notify_error)();
00346 
00347     if (redirect.error)
00348         return fprintf(redirect.error,"ERROR [%s] : %s\n",time_context, buffer);
00349     else
00350         return (*printerr)("ERROR [%s] : %s\n", time_context, buffer);
00351 }
00352 
00359 int output_error_raw(char *format,...) 
00360 {
00361     /* check for repeated message */
00362     static char lastfmt[4096] = "";
00363     static int count=0;
00364     if (format!=NULL && strcmp(lastfmt,format)==0 && global_suppress_repeat_messages && !global_verbose_mode)
00365     {
00366         count++;
00367         return 0;
00368     }
00369     else
00370     {
00371         va_list ptr;
00372         int len=0;
00373         strncpy(lastfmt,format?format:"",sizeof(lastfmt)-1);
00374         if (count>0 && global_suppress_repeat_messages && !global_verbose_mode)
00375         {
00376             len = sprintf(buffer,"last error message was repeated %d times", count);
00377             count = 0;
00378             if(format == NULL) goto Output;
00379             else len += sprintf(buffer+len,"\n");
00380         }
00381         else if (format==NULL)
00382             return 0;
00383         va_start(ptr,format);
00384         vsprintf(buffer+len,format,ptr); /* note the lack of check on buffer overrun */
00385         va_end(ptr);
00386     }
00387 Output:
00388 
00389     if (notify_error!=NULL)
00390         (*notify_error)();
00391 
00392     if (redirect.error)
00393         return fprintf(redirect.error,"%s\n", buffer);
00394     else
00395         return (*printerr)("%s\n", buffer);
00396 }
00397 
00404 int output_test(char *format,...) 
00405 {
00406     static FILE *fp = NULL;
00407     char minor_b[32], major_b[32];
00408     va_list ptr;
00409 
00410     if(format == NULL){
00411         return 0;
00412     }
00413 
00414     va_start(ptr,format);
00415     vsprintf(buffer,format,ptr); /* note the lack of check on buffer overrun */
00416     va_end(ptr);
00417 
00418     if (fp==NULL)
00419     {
00420         time_t now = time(NULL);
00421         fp = fopen(global_getvar("testoutputfile", NULL, 0), "w"); /* new style - mh*/
00422         /* fp = fopen(global_testoutputfile,"w"); */ /* old style -mh */
00423         if (fp==NULL)
00424         {
00425             /* can't write to output file, write to stderr instead */
00426             return (*printerr)("TEST: %s\n",buffer);
00427         }
00428         /* fprintf(fp,"GridLAB-D Version %d.%d\n", global_version_major, global_version_minor); */
00429         fprintf(fp,"GridLAB-D Version %s.%s\n", global_getvar("version.major", major_b, 32), global_getvar("version.minor", minor_b, 32));
00430         fprintf(fp,"Test results from run started %s", asctime(localtime(&now)));
00431         fprintf(fp,"Command line: %s\n", global_getvar("command_line", NULL, 0));
00432     }
00433 
00434     return fprintf(fp,"%s\n", buffer);
00435 }
00436 
00443 int output_warning(char *format,...) 
00444 {
00445     if (global_warn_mode)
00446     {
00447         /* check for repeated message */
00448         static char lastfmt[4096] = "";
00449         static int count=0;
00450         if (format!=NULL && strcmp(lastfmt,format)==0 && global_suppress_repeat_messages && !global_verbose_mode)
00451         {
00452             count++;
00453             return 0;
00454         }
00455         else
00456         {
00457             va_list ptr;
00458             int len=0;
00459             strncpy(lastfmt,format?format:"",sizeof(lastfmt)-1);
00460             if (count>0 && global_suppress_repeat_messages && !global_verbose_mode)
00461             {
00462                 len = sprintf(buffer,"last warning message was repeated %d times", count);
00463                 count = 0;
00464                 if(format == NULL) goto Output;
00465                 else len += sprintf(buffer+len,"\nWARNING [%s] : ", time_context);
00466             }
00467             else if (format==NULL)
00468                 return 0;
00469             va_start(ptr,format);
00470             vsprintf(buffer+len,format,ptr); /* note the lack of check on buffer overrun */
00471             va_end(ptr);
00472         }
00473 Output:
00474         if (redirect.warning)
00475             return fprintf(redirect.warning,"WARNING [%s] : %s\n",time_context, buffer);
00476         else
00477             return (*printerr)("WARNING [%s] : %s\n", time_context, buffer);
00478     }
00479     return 0;
00480 }
00481 
00488 int output_debug(char *format,...) 
00489 {
00490     if (global_debug_output)
00491     {
00492         /* check for repeated message */
00493         static char lastfmt[4096] = "";
00494         static int count=0;
00495         if (format!=NULL && strcmp(lastfmt,format)==0 && global_suppress_repeat_messages && !global_verbose_mode)
00496         {
00497             count++;
00498             return 0;
00499         }
00500         else
00501         {
00502             va_list ptr;
00503             int len=0;
00504             strncpy(lastfmt,format?format:"",sizeof(lastfmt)-1);
00505             if (count>0 && global_suppress_repeat_messages && !global_verbose_mode)
00506             {
00507                 len = sprintf(buffer,"last debug message was repeated %d times", count);
00508                 count = 0;
00509                 if(format == 0) goto Output;
00510                 else len += sprintf(buffer+len,"\nDEBUG [%s] : ",time_context);
00511             }
00512             else if (format==NULL)
00513                 return 0;
00514             va_start(ptr,format);
00515             vsprintf(buffer+len,format,ptr); /* note the lack of check on buffer overrun */
00516             va_end(ptr);
00517         }
00518 Output:
00519         if (redirect.debug)
00520             return fprintf(redirect.debug,"DEBUG [%s] : %s\n",time_context, buffer);
00521         else
00522             return (*printerr)("DEBUG [%s] : %s\n", time_context, buffer);
00523     }
00524     return 0;
00525 }
00526 
00534 int output_verbose(char *format,...) 
00535 {
00536     if (global_verbose_mode)
00537     {
00538         /* check for repeated message */
00539         static char lastfmt[4096] = "";
00540         static int count=0;
00541         if (format!=NULL && strcmp(lastfmt,format)==0 && global_suppress_repeat_messages && !global_verbose_mode)
00542         {
00543             count++;
00544             return 0;
00545         }
00546         else
00547         {
00548             va_list ptr;
00549             int len=0;
00550             strncpy(lastfmt,format?format:"",sizeof(lastfmt)-1);
00551             if (count>0 && global_suppress_repeat_messages && !global_verbose_mode)
00552             {
00553                 len = sprintf(buffer,"last verbose message was repeated %d times\n   ... ",count);
00554                 count = 0;
00555                 if(format == 0) goto Output;
00556             }
00557             else if (format==NULL)
00558                 return 0;
00559             va_start(ptr,format);
00560             vsprintf(buffer+len,format,ptr); /* note the lack of check on buffer overrun */
00561             va_end(ptr);
00562         }
00563 Output:
00564         if (redirect.verbose)
00565             return fprintf(redirect.verbose,"%s\n",buffer);
00566         else
00567             return (*printerr)("   ... %s\n",buffer);
00568     }
00569     return 0;
00570 }
00576 int output_message(char *format,...) 
00577 {
00578     if (!global_quiet_mode)
00579     {
00580         /* check for repeated message */
00581         static char lastfmt[4096] = "";
00582         static int count=0;
00583         size_t sz = strlen(format?format:"");
00584         if (format!=NULL && strcmp(lastfmt,format)==0 && global_suppress_repeat_messages && !global_verbose_mode)
00585         {
00586             count++;
00587             return 0;
00588         }
00589         else
00590         {
00591             va_list ptr;
00592             int len=0;
00593             strncpy(lastfmt,format?format:"",sizeof(lastfmt)-1);
00594             if (count>0 && global_suppress_repeat_messages && !global_verbose_mode)
00595             {
00596                 len = sprintf(buffer,"last message was repeated %d times\n",count);
00597                 count = 0;
00598                 if(format == NULL) goto Output;
00599             }
00600             if (format==NULL)
00601                 return 0;
00602             va_start(ptr,format);
00603             vsprintf(buffer+len,format,ptr); /* note the lack of check on buffer overrun */
00604             va_end(ptr);
00605         }
00606 Output:
00607         if (redirect.output)
00608             return fprintf(redirect.output,"%s\n",buffer);
00609         else
00610             return (*printstd)("%s\n",buffer);
00611     }
00612     return 0;
00613 }
00614 
00617 int output_profile(char *format, ...) 
00618 {
00619     char tmp[1024];
00620     va_list ptr;
00621 
00622     va_start(ptr,format);
00623     vsprintf(tmp,format,ptr);
00624     va_end(ptr);
00625 
00626     if (redirect.profile!=NULL)
00627         return fprintf(redirect.profile,"%s\n",tmp);
00628     else
00629         return (*printstd)("%s\n",tmp);
00630 }
00631 
00634 int output_progress()
00635 {
00636     char buffer[64];
00637     int res = 0;
00638     char *ts = convert_from_timestamp(global_clock,buffer,sizeof(buffer))>0?buffer:"(invalid)";
00639     if (redirect.progress)
00640     {
00641         res = fprintf(redirect.progress,"%s\n",ts);
00642         fflush(redirect.progress);
00643     }
00644     else if (global_keep_progress)
00645         res = output_message("Processing %s...", ts);
00646     else
00647     {
00648         static int len=0;
00649         int i=len, slen = (int)strlen(ts)+15;
00650         while (i--) putchar(' ');
00651         putchar('\r');
00652         if (slen>len) len=slen;
00653         res = output_raw("Processing %s...\r", ts);
00654     }
00655     return res;
00656 }
00657 
00663 int output_raw(char *format,...) 
00664 {
00665     if (!global_quiet_mode)
00666     {
00667         va_list ptr;
00668 
00669         va_start(ptr,format);
00670         vsprintf(buffer,format,ptr); /* note the lack of check on buffer overrun */
00671         va_end(ptr);
00672 
00673             if (redirect.output)
00674             {   int len = fprintf(redirect.output,"%s",buffer);
00675                 fflush(redirect.output);
00676                 return len;
00677             }
00678             else
00679                 return (*printerr)("%s",buffer);
00680     }
00681     return 0;
00682 }
00683 
00684 #include "module.h"
00685 
00687 int output_xsd(char *spec)
00688 {
00689     MODULE *mod = NULL;
00690     CLASS *oclass = NULL;
00691     char modulename[1024], classname[1024]="";
00692     char buffer[65536];
00693     /*if(sscanf(spec, "%[A-Za-z_0-9]::%[A-Za-z_0-9]:%s",modulename, submodulename, classname) == 3)
00694     {
00695         sprintf(jointname, "%s::%s", modulename, submodulename);
00696         mod = module_load(jointname, 0, NULL);
00697         if(mod == NULL){
00698             output_error("unable to load parent module %s", modulename);
00699             return 0;
00700         }
00701         
00702     }
00703     else if(sscanf(spec, "%[A-Za-z_0-9]::%[A-Za-z_0-9]",modulename, submodulename) == 2)
00704     {
00705         sprintf(jointname, "%s::%s", modulename, submodulename);
00706         mod = module_load(jointname, 0, NULL);
00707         if(mod == NULL){
00708             output_error("unable to load parent module %s", modulename);
00709             return 0;
00710         }
00711     }
00712     else */if (sscanf(spec,"%[A-Za-z_0-9]:%s",modulename,classname)<1)
00713     {
00714         output_error("improperly formatted XSD dump specification");
00715         return 0;
00716     }
00717     if (mod == NULL)
00718         mod = module_load(modulename,0,NULL);
00719     if (mod==NULL)
00720     {
00721         output_error("unable to find module '%s'", spec);
00722         return 0;
00723     }
00724     if (classname[0]!='\0' && (oclass=class_get_class_from_classname(classname))==NULL)
00725     {
00726         output_error("unable to find class '%s' in module '%s'", classname, modulename);
00727         return 0;
00728     }
00729     //if ((strlen(submodulename) > 1))
00730     //  strcpy(modulename, submodulename);
00731     output_message("<?xml version=\"1.0\" encoding=\"utf-%d\"?>",global_xml_encoding);
00732     output_message("<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" targetNamespace=\"http://www.w3.org/\" xmlns=\"http://www.w3.org/\" elementFormDefault=\"qualified\">\n");
00733     for (oclass=(classname[0]!='\0'?oclass:class_get_first_class()); oclass!=NULL; oclass=oclass->next) 
00734     {
00735         if (class_get_xsd(oclass,buffer,sizeof(buffer))<=0)
00736         {
00737             output_error("unable to convert class '%s' to XSD", oclass->name);
00738             return 0;
00739         }
00740         output_message(buffer);
00741         if (classname[0]!='\0') 
00742             break;
00743     }
00744     output_message("</xs:schema>\n");
00745     return 0;
00746 }
00747 
00748 int output_xsl(char *fname, int n_mods, char *p_mods[])
00749 {
00750     FILE *fp;
00751 
00752     /* load modules */
00753     while (n_mods-->0)
00754     {
00755         MODULE *mod = module_load(*p_mods,0,NULL);
00756         if (mod==NULL)
00757         {
00758             output_error("module %s not found", *p_mods);
00759             return FAILED;
00760         }
00761         p_mods++;
00762     }
00763 
00764     /* open the output file */
00765     fp = fopen(fname,"w");
00766     if (fp==NULL)
00767     {
00768         output_error("%s open failed: %s", fname, strerror(errno));
00769         return errno;
00770     }
00771 
00772     /* heading */
00773     fprintf(fp,"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
00774     fprintf(fp,"<!-- output by GridLAB-D -->\n");
00775     
00776     /* document */
00777     fprintf(fp,"<html xsl:version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" xmlns=\"http://www.w3.org/1999/xhtml\">\n");
00778     {
00779         fprintf(fp,"<xsl:for-each select=\"/gridlabd\">\n");
00780         {
00781             fprintf(fp,"<head>\n");
00782             {
00783                 GLOBALVAR *stylesheet = global_find("stylesheet");
00784                 fprintf(fp,"<title>GridLAB-D <xsl:value-of select=\"version.major\"/>.<xsl:value-of select=\"version.minor\"/> - <xsl:value-of select=\"modelname\"/></title>\n");
00785                 if (stylesheet==NULL || stylesheet->prop->ptype!=PT_char1024) /* only char1024 is allowed */
00786                     fprintf(fp,"<link rel=\"stylesheet\" href=\"%sgridlabd-%d_%d.css\" type=\"text/css\"/>\n",global_urlbase,global_version_major,global_version_minor);
00787                 else
00788                     fprintf(fp,"<link rel=\"stylesheet\" href=\"%s.css\" type=\"text/css\"/>\n",stylesheet->prop->addr);
00789             }
00790             fprintf(fp,"</head>\n");
00791             fprintf(fp,"<body>\n");
00792             {
00793                 GLOBALVAR *var=NULL;
00794                 MODULE *mod;
00795                 
00796                 fprintf(fp,"<H1><xsl:value-of select=\"modelname\"/></H1>\n");
00797 
00798                 /* table of contents */
00799                 fprintf(fp,"<H2>Table of Contents</H2>\n");
00800                 fprintf(fp,"<OL TYPE=\"1\">\n");
00801                 fprintf(fp,"<LI><A HREF=\"#global_variables\">Global variables</A></LI>\n");
00802                 fprintf(fp,"<LI><A HREF=\"#solver_ranks\">Solver ranks</A></LI>\n");
00803                 fprintf(fp,"<LI><A HREF=\"#modules\">Modules</A></LI><OL TYPE=\"a\">\n");
00804                 for (mod=module_get_first(); mod!=NULL; mod=mod->next)
00805                     fprintf(fp,"<LI><A HREF=\"#modules_%s\">%s</A></LI>\n",mod->name,mod->name);
00806                 fprintf(fp,"</OL>\n");
00807                 fprintf(fp,"<LI><A HREF=\"#output\">Output</A></LI>\n");
00808                 fprintf(fp,"</OL>\n");
00809 
00810                 /* global variable dump */
00811                 fprintf(fp,"<H2><A NAME=\"global_variables\">GridLAB-D system variables</A></H2>\n");
00812                 fprintf(fp,"<TABLE BORDER=\"1\">\n");
00813                 while (var=global_getnext(var))
00814                 {
00815                     if (strstr(var->name,"::"))
00816                         continue; /* skip module globals (they'll get dumped later) */
00817                     fprintf(fp,"<TR><TH>%s</TH><TD><xsl:value-of select=\"%s\"/></TD></TR>\n",var->name,var->name);
00818                 }
00819                 fprintf(fp,"</TABLE>\n");
00820 
00821                 /* processing sequence dump */
00822                 fprintf(fp,"<H2><A NAME=\"solver_ranks\">Solver ranks</A></H2>\n");
00823                 fprintf(fp,"<TABLE BORDER=\"1\">\n");
00824                     fprintf(fp,"<TR>");
00825                         fprintf(fp,"<xsl:for-each select=\"sync-order/pass\">\n");
00826                             fprintf(fp,"<TH>Pass <xsl:value-of select=\"name\"/></TH>\n");
00827                         fprintf(fp,"</xsl:for-each>\n");
00828                     fprintf(fp,"</TR>\n");
00829                     fprintf(fp,"<TR>\n");
00830                         fprintf(fp,"<xsl:for-each select=\"sync-order/pass\"><TD><DL>\n");
00831                             fprintf(fp,"<xsl:for-each select=\"rank\">\n");
00832                                 fprintf(fp,"<xsl:sort select=\"ordinal\" data-type=\"number\" order=\"descending\"/>\n");
00833                                 fprintf(fp,"<DT>Rank <xsl:value-of select=\"ordinal\"/></DT>");
00834                                 fprintf(fp,"<xsl:for-each select=\"object\">\n");
00835                                 fprintf(fp,"<DD><a href=\"#{name}\"><xsl:value-of select=\"name\"/></a></DD>\n");
00836                                 fprintf(fp,"</xsl:for-each>\n");
00837                             fprintf(fp,"</xsl:for-each>\n");
00838                         fprintf(fp,"</DL></TD></xsl:for-each>\n");
00839                     fprintf(fp,"</TR>\n");
00840                 fprintf(fp,"</TABLE>\n");
00841 
00842                 /* module object dumps */
00843                 fprintf(fp,"<H2><A NAME=\"modules\">Modules</A></H2>\n");
00844                 for (mod=module_get_first(); mod!=NULL; mod=mod->next)
00845                 {
00846                     CLASS *oclass;
00847                     PROPERTY *prop;
00848 
00849                     fprintf(fp,"<H3><A NAME=\"modules_%s\">%s</A></H3>", mod->name,mod->name);
00850 
00851                     /* globals */
00852                     fprintf(fp,"<TABLE BORDER=\"1\">\n");
00853                     fprintf(fp,"<TR><TH>version.major</TH><TD><xsl:value-of select=\"%s/version.major\"/></TD></TR>",mod->name);
00854                     fprintf(fp,"<TR><TH>version.minor</TH><TD><xsl:value-of select=\"%s/version.minor\"/></TD></TR>",mod->name);
00855                     while (var=global_getnext(var))
00856                     {
00857                         if (strncmp(var->name,mod->name,strlen(mod->name))==0)
00858                         {
00859                             char *name = var->name + strlen(mod->name)+2; // offset name to after ::
00860                             fprintf(fp,"<TR><TH>%s</TH><TD><xsl:value-of select=\"%s/%s\"/></TD></TR>",name,mod->name,name);
00861                         }
00862                     }
00863                     fprintf(fp,"</TABLE>\n");
00864 
00865                     /* object dump */
00866                     for (oclass=mod->oclass; oclass!=NULL && oclass->module==mod; oclass=oclass->next)
00867                     {
00868                         CLASS *pclass = oclass;
00869                         fprintf(fp,"<H4>%s objects</H4>", oclass->name);
00870                         fprintf(fp,"<TABLE BORDER=\"1\">\n");
00871                         fprintf(fp,"<TR><TH>Name</TH>");
00872                         for (pclass=oclass; pclass!=NULL; pclass=pclass->parent)
00873                             for (prop=class_get_first_property(pclass); prop!=NULL; prop=class_get_next_property(prop))
00874                                 fprintf(fp,"<TH>%s</TH>",prop->name);
00875                         fprintf(fp,"</TR>\n");
00876                         {
00877                             fprintf(fp,"<xsl:for-each select=\"%s/%s_list/%s\">", mod->name,oclass->name,oclass->name);
00878                             {
00879                                 fprintf(fp,"<TR><TD><a name=\"#{name}\"/><xsl:value-of select=\"name\"/> (#<xsl:value-of select=\"id\"/>)</TD>");
00880                                 for (pclass=oclass; pclass!=NULL; pclass=pclass->parent)
00881                                     for (prop=class_get_first_property(pclass); prop!=NULL; prop=class_get_next_property(prop))
00882                                     {
00883                                         if (prop->ptype==PT_object)
00884                                             fprintf(fp,"<TD><a href=\"#{%s}\"><xsl:value-of select=\"%s\"/></a></TD>",prop->name,prop->name);
00885                                         else
00886                                             fprintf(fp,"<TD><xsl:value-of select=\"%s\"/></TD>",prop->name);
00887                                     }
00888                                 fprintf(fp,"</TR>\n");
00889                             }
00890                             fprintf(fp,"</xsl:for-each>");
00891                         }
00892                         fprintf(fp,"</TABLE>\n");
00893                     }
00894                 }
00895 
00896                 /* GLM output */
00897                 fprintf(fp,"<H2><A NAME=\"output\">GLM Output</A></H2>\n");
00898                 fprintf(fp,"<table border=\"1\" width=\"100%%\"><tr><td><pre>\n");
00899                 {
00900 
00901                     /* heading info */
00902                     fprintf(fp,"# Generated by GridLAB-D <xsl:value-of select=\"version.major\"/>.<xsl:value-of select=\"version.minor\"/>\n");
00903                     fprintf(fp,"# Command line..... <xsl:value-of select=\"command_line\"/>\n");
00904                     fprintf(fp,"# Model name....... <xsl:value-of select=\"modelname\"/>\n");
00905                     fprintf(fp,"# Start at......... <xsl:value-of select=\"starttime\"/>\n");
00906                     fprintf(fp,"#\n");
00907 
00908                     /* clock info */
00909                     fprintf(fp,"clock {\n");
00910                     fprintf(fp,"\ttimestamp '<xsl:value-of select=\"clock\"/>';\n");
00911                     fprintf(fp,"\ttimezone <xsl:value-of select=\"timezone\"/>;\n");
00912                     fprintf(fp,"}\n");
00913 
00914                     /* module blocks */
00915                     for (mod=module_get_first(); mod!=NULL; mod=mod->next)
00916                     {
00917                         GLOBALVAR *var=NULL;
00918                         fprintf(fp,"<xsl:for-each select=\"%s\">", mod->name);
00919                         {
00920                             CLASS *oclass;
00921 
00922                             fprintf(fp,"\n##############################################\n");
00923                             fprintf(fp,"# %s module\n", mod->name);
00924                             fprintf(fp,"module %s {\n", mod->name);
00925                             fprintf(fp,"\tversion.major <xsl:value-of select=\"version.major\"/>;\n");
00926                             fprintf(fp,"\tversion.minor <xsl:value-of select=\"version.minor\"/>;\n");
00927                             while (var=global_getnext(var))
00928                             {
00929                                 if (strncmp(var->name,mod->name,strlen(mod->name))==0)
00930                                 {
00931                                     char *name = var->name + strlen(mod->name)+2; // offset name to after ::
00932                                     fprintf(fp,"\t%s <xsl:value-of select=\"%s\"/>;\n",name,name);
00933                                 }
00934                             }
00935                             fprintf(fp,"}\n");
00936 
00937                             for (oclass=mod->oclass; oclass!=NULL && oclass->module==mod; oclass=oclass->next)
00938                             {
00939                                 fprintf(fp,"\n# %s::%s objects\n", mod->name, oclass->name);
00940                                 {
00941                                     fprintf(fp,"<xsl:for-each select=\"%s_list/%s\">", oclass->name,oclass->name);
00942                                     {
00943                                         PROPERTY *prop;
00944                                         fprintf(fp,"<a name=\"#GLM.{name}\"/>object %s:<xsl:value-of select=\"id\"/> {\n", oclass->name);
00945                                         fprintf(fp,"<xsl:if test=\"name!=''\">\tname \"<xsl:value-of select=\"name\"/>\";\n</xsl:if>");
00946                                         fprintf(fp,"<xsl:if test=\"parent!=''\">\tparent \"<a href=\"#GLM.{parent}\"><xsl:value-of select=\"parent\"/></a>\";\n</xsl:if>");
00947                                         fprintf(fp,"<xsl:if test=\"clock!=''\">\tclock '<xsl:value-of select=\"clock\"/>';\n</xsl:if>");
00948                                         fprintf(fp,"<xsl:if test=\"in_svc!=''\">\tin_svc '<xsl:value-of select=\"in_svc\"/>';\n</xsl:if>");
00949                                         fprintf(fp,"<xsl:if test=\"out_svc!=''\">\tout_svc '<xsl:value-of select=\"out_svc\"/>';\n</xsl:if>");
00950                                         fprintf(fp,"<xsl:if test=\"latitude!=''\">\tlatitude <xsl:value-of select=\"latitude\"/>;\n</xsl:if>");
00951                                         fprintf(fp,"<xsl:if test=\"longitude!=''\">\tlongitude <xsl:value-of select=\"longitude\"/>;\n</xsl:if>");
00952                                         fprintf(fp,"<xsl:if test=\"rank!=''\">\trank <xsl:value-of select=\"rank\"/>;\n</xsl:if>");
00953                                         for (prop=class_get_first_property(oclass); prop!=NULL; prop=class_get_next_property(prop))
00954                                         {
00955                                             if (prop->ptype==PT_object)
00956                                                 fprintf(fp,"<xsl:if test=\"%s\">\t%s <a href=\"#GLM.{%s}\"><xsl:value-of select=\"%s\"/></a>;\n</xsl:if>",prop->name,prop->name,prop->name,prop->name);
00957                                             else
00958                                                 fprintf(fp,"<xsl:if test=\"%s\">\t%s <xsl:value-of select=\"%s\"/>;\n</xsl:if>",prop->name,prop->name,prop->name);
00959                                         }
00960                                         fprintf(fp,"}\n");
00961                                     }
00962                                     fprintf(fp,"</xsl:for-each>");
00963                                 }
00964                             }
00965                         }
00966                         fprintf(fp,"</xsl:for-each>");
00967                     }
00968                 }
00969                 fprintf(fp,"</pre></td></tr></table>\n");
00970             }
00971             fprintf(fp,"</body>\n");
00972         }
00973         fprintf(fp,"</xsl:for-each>");
00974     }
00975     fprintf(fp,"</html>\n");
00976 
00977     fclose(fp);
00978     return 0;
00979 }
00980