/***************************************************************** * clock - A flexible, efficient digital clock with date and memory watching * * Copyright 1994 by Peter Schachte * * This is an effecient titlebar digital clock, with date, day of week, * free chip/fast/total memory, largest free chip/fast/either memory * block, control over formatting, pen color for various parts of the * display, and refresh frequency. The clock can also show the local * time in a different time zone. Clock only updates parts of the * display that need updating, so CPU usage is kept low. This program * should work under AmigaOS 1.2 and up. * * This code is based on Mike Meyer's clock program, though by now * very little of his code remains. In fact, I've changed the * spirit of his program, which was quite small and simple; now * it's (relatively) large and complex, and probably has altogether * too many features. * * Nevertheless, here's Mike's original copyright notice: *================================================================ * clock - a dumb, digital clock in the upper right-hand corner. Designed * to be small, not flexible! * * Copyright (c) 1986, Mike Meyer * * Permission is hereby granted to distribute this program for any purposes * whatsoever, so long as this notice, including the above copyright, is * included with the distribution. Unlike other people, I don't care if you * make money off of this, so long as I get credit for having written it. *================================================================ * * I likewise hereby grant the right to distribute this program for * any purposes whatsoever, as long as this notice, including my * copyright and Mike's, is included with the distribution. * *****************************************************************/ static char version[] = "$VER: " PROGNAME " " VERSION " (" __DATE__ ") © 1994 Peter Schachte"; /* There is one feature that I have #ifdef'ed out of this program. If * CORRECTION is defined when this file is processed, this clock will * support the extra command line argument and tooltype "CORRECTION" * which should be set to the number of seconds until your system * clock gains or loses a second, positive if it loses a second or * negative if it gains a second. If this option is specified, then * the clock will automatically correct the system time as you * specify. * * This feature is only useful if your system clock gains or loses * time consistently. Mine doesn't, and I assume the same is true of * others, so I've left this feature out by default. But I may change * my mind and put it back sometime. */ #include "progargs.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* In case we're linked with cback.o */ char *__procname = PROGNAME; long __BackGroundIO = 0; /***************************************************************** Various Useful Constants *****************************************************************/ #define MINUTES_PER_DAY 1440 #define SECS_PER_DAY 86400 #define END_OF_TIME ((unsigned long) -1) /* (approx?) sizes of workbench gadgets for OS >=2.0 and OS <=1.3 */ #define WIDTH_OF_20_CLOSE_GADGET 20 #define WIDTH_OF_20_DEPTH_GADGET 23 #define WIDTH_OF_13_CLOSE_GADGET 27 #define WIDTH_OF_13_DEPTH_GADGET 27 #define INTUITION_REV 1L #define DEFAULT_FORMAT "%2Chip: %1%G%|%2Fast: %1%F%|%e %b %y%|%A%|%q:%M" /* An individual part of the display may need any of the following * data in order to be displayed. Some parts may need multiple parts, * so we use bit masks to represent them. */ #define NEED_CHIP 0 #define NEED_FAST 1 #define NEED_BIG_CHIP 2 #define NEED_BIG_FAST 3 #define NEED_TIME 4 #define MAX_NEED 4 #define NO_NEEDS_MASK 0 #define NEED_CHIP_MASK (1<= 2.0? */ int offset_secs; /* computed from offset_minutes */ #ifdef CORRECTION int correction = 1; /* secs to add every */ /* correction_interval */ #endif static struct display_element *win_content; /* all display elements */ /* separate chains (though next_of_kind member) for memory and time displays */ static struct display_element *mem_chain = NULL; static struct display_element *time_chain = NULL; struct GfxBase *GfxBase; struct IntuitionBase *IntuitionBase; /***************************************************************** Prototypes *****************************************************************/ static void plan_display(char *format, int *pixelpos, int *pen, struct display_element ***tailptr); static void add_display_space(int width, int *pixelpos, struct display_element ***tailptr); static void add_display_string(char *string, int len, int *pixelpos, int *pen, struct display_element ***tailptr); static void add_display_format(char code, int *pixelpos, int *pen, struct display_element ***tailptr); static struct display_element *add_element(int width, int *pixelpos, int pen, enum display_kind kind, struct display_element ***tailptr); static void insert_in_kind(struct display_element *elt, struct display_element **chainptr); static int widest(char **ptr, int count, int charcount); static void replan_display(int curr_day, int curr_wkday, int curr_month); static void display_strings(void); static void draw_bar(long x); static void display_data(void); static void draw_datum(struct display_element *ptr, int val, char **string_array, int len); static char *int_string(int n, int *minwidth); static void initialize(void); static void done(int code); /* this is defined in compute_date.c: */ void compute_date(long n, int *y, int *m, int *d, int *w, int *jul); /***************************************************************** Code *****************************************************************/ void main(int argc, char *argv[]) { int win_width; struct Layer *MyLayer; struct ClipRect *MyClip; struct IntuiMessage *Msg; struct Task *FindTask(); struct TextFont *font; unsigned long timersig, windowsig, sigmask, sig; unsigned long interval_micros; int pen; struct display_element **tail = &win_content; /* set up */ initialize(); handle_args(argc, argv, arg_desc); offset_secs = 60 * offset_minutes; pen = (background_pen==1 ? 0 : 1); inleft = (new_os ? WIDTH_OF_20_CLOSE_GADGET : WIDTH_OF_13_CLOSE_GADGET); win_width = inleft + horiz_padding; plan_display(format_string, &win_width, &pen, &tail); win_width += horiz_padding; New_Window.LeftEdge = (win_left<0 ? screen_info.Width-win_width+win_left : win_left); New_Window.Width = win_width; New_Window.Height = screen_info.Font->ta_YSize + screen_info.WBorTop + 1; New_Window.TopEdge = (win_top<0 ? screen_info.Height-New_Window.Height+win_top : win_top); Window = (struct Window *) OpenWindow(&New_Window); if (Window == NULL) done(20); /* set screen title to version string without leading "$VER: " */ SetWindowTitles(Window, NULL, (UBYTE*) &version[5]); /* We've opened the window, now store away some info about it */ win_rast = Window->RPort; my_screen = Window->WScreen; font = OpenFont(screen_info.Font); win_baseline = font->tf_Baseline+screen_info.WBorTop; SetAPen(win_rast, 1L); SetBPen(win_rast, background_pen); SetDrMd(win_rast, JAM2); SetFont(win_rast, font); intop = screen_info.WBorTop - 1; inright = win_width - 2; inbottom = New_Window.Height - 2; MyLayer = win_rast->Layer; timersig = 1L << delay_port->mp_SigBit; windowsig = 1L << Window->UserPort->mp_SigBit; sigmask = timersig | windowsig | SIGBREAKF_CTRL_C; interval_micros = interval_tenth_secs*100000; { int yr, month, dy, weekday, jul; /* display clock the first time. First get the current time */ DoIO((struct IORequest *) &time_req.tr_node); compute_date((time_req.tr_time.tv_secs+offset_secs)/SECS_PER_DAY, &yr, &month, &dy, &weekday, &jul); replan_display(dy, weekday, month); display_strings(); display_data(); } display_strings(); display_data(); (void) SetTaskPri(FindTask(NULL), priority); #ifdef CORRECTION if (correction_ratio != 0) { if (correction_ratio < 0) { correction = -1; correction_ratio = -correction_ratio; } need_time = 1; } #endif for (;;) { int strings_need_display = 0; sig = Wait(sigmask); if (sig & windowsig) { while (Msg=(struct IntuiMessage *)GetMsg(Window->UserPort)) { switch (Msg->Class) { case IDCMP_CLOSEWINDOW: ReplyMsg((struct Message *)Msg); done(0); break; default: strings_need_display = 1; break; } ReplyMsg((struct Message *)Msg); } } if ((sig & timersig) && GetMsg(delay_port)) { delay_req.tr_time.tv_secs = 0; delay_req.tr_time.tv_micro = interval_micros; SendIO((struct IORequest *) &delay_req.tr_node); } if (sig & SIGBREAKF_CTRL_C) done(20); /* no point doing anything if our screen is not in front */ if (my_screen != IntuitionBase->FirstScreen) continue; /* check if somone is on top of us */ MyClip = MyLayer->ClipRect; if (MyClip && (MyClip->Next || MyClip->lobs)) { WindowToFront(Window); /* keep us on top */ strings_need_display = 1; } if (strings_need_display) display_strings(); display_data(); } } /* Create a chain of display_elements describing the clock display, * and return the interior width of the clock window. format is the * format string. *pixelpos is the position at which to start the * next part of the display; on completion, it is the width of the * (inside of) the window. Pen is the pen color in which to draw the * next part of the display. tailptr points to a pointer to a (NULL) * pointer to the next display element, allowing us to keep adding to * the end of the chain. On return, *tailptr will point to the new * NULL next pointer. */ static void plan_display(char *format, int *pixelpos, int *pen, struct display_element ***tailptr) { char *ptr = format; do { if (*ptr==' ') { int width = 0; do {width += space_width;} while (*++ptr==' '); add_display_space(width, pixelpos, tailptr); } else if (*ptr == '%') { add_display_format(*++ptr, pixelpos, pen, tailptr); ++ptr; } else if (*ptr != '\0') { char *strstart = ptr; do {++ptr;} while (*ptr!='%' && *ptr!='\0'); /* we'll handle spaces in next iteration, so trim them */ while (*--ptr == ' '); /* trim trailing blanks */ ++ptr; /* point after string */ add_display_string(strstart, ptr-strstart, pixelpos, pen, tailptr); } } while (*ptr != '\0'); } static void add_display_space(int width, int *pixelpos, struct display_element ***tailptr) { add_element(width, pixelpos, 0, space, tailptr); } /* create a display_element for the string starting at string and * whose length is len. Add the width of this string to pixelpos. */ static void add_display_string(char *str, int len, int *pixelpos, int *pen, struct display_element ***tailptr) { struct display_element *elt = add_element(TextLength(scrn_rast,str,len), pixelpos, *pen, string, tailptr); elt->string.text = str; elt->string.length = len; } /* create a new display_element record or records for format character * code. I.e., we've seen a '%' followed by code, and now want to * handle it. */ static void add_display_format(char code, int *pixelpos, int *pen, struct display_element ***tailptr) { struct display_element *elt; enum display_kind kind = invalid; char *alias = NULL; int bits; int width; if (code >= 'A' && code <= 'Z') { if (code == 'C') alias = aliases_C; else if (code == 'D') alias = aliases_D; else if (code >= 'R' && code <= 'X') alias = aliases_RX[code-'R']; if (alias != NULL) { plan_display(alias, pixelpos, pen, tailptr); return; } else { kind = upper_codes[code-'A']; } } else if (code >= 'a' && code <= 'z') { if (code == 'c') alias = aliases_c; else if (code == 'r') alias = aliases_r; else if (code == 'x') alias = aliases_x; if (alias != NULL) { plan_display(alias, pixelpos, pen, tailptr); return; } else { kind = lower_codes[code-'a']; } } else if (code >= '0' && code <= '9') { *pen = code-'0'; return; } else if (code == '|') { kind = vbar; } else if (code == '%') { add_display_string("%", 1, pixelpos, pen, tailptr); return; } switch (kind) { case weekday_abbrev: width = widest(str_weekday, 7, 3); break; case weekday_full: width = widest(str_weekday, 7, 0); break; case month_abbrev: width = widest(str_month, 12, 3); break; case month_full: width = widest(str_month, 12, 0); break; case am_pm: width = widest(str_am_pm, 2, 0); break; case vbar: width = 2*horiz_padding + 1 + (new_os!=0); break; default: width = digit_width * field_digit_width[(int)kind]; break; } elt = add_element(width, pixelpos, *pen, kind, tailptr); elt->data.curr_value = -1; /* universal bogus value */ bits = field_requirements[(int)kind]; if (bits & NEED_CHIP_MASK) need_chip = 1; if (bits & NEED_FAST_MASK) need_fast = 1; if (bits & NEED_BIG_CHIP_MASK) need_big_chip = 1; if (bits & NEED_BIG_FAST_MASK) need_big_fast = 1; if (bits & NEED_TIME_MASK) { need_time = 1; insert_in_kind(elt, &time_chain); } else if (bits != NO_NEEDS_MASK) { /* must have been one of the memory items */ insert_in_kind(elt, &mem_chain); } } /* Create a new generic display_element, fill it in and return it. */ static struct display_element *add_element(int width, int *pixelpos, int pen, enum display_kind kind, struct display_element ***tailptr) { struct display_element *new = AllocMem(sizeof(struct display_element), MEMF_ANY); new->next = NULL; new->next_of_kind = NULL; new->left = *pixelpos; new->max_width = width; new->curr_width = width; *pixelpos += width; new->pen = pen; new->kind = kind; **tailptr = new; *tailptr = &(new->next); return new; } /* Insert a display_element into an existing chain (through the * next_of_kind field) in sorted order. */ static void insert_in_kind(struct display_element *elt, struct display_element **chainptr) { enum display_kind kind = elt->kind; struct display_element *ptr = *chainptr; while (ptr!=NULL && ptr->kindnext_of_kind); ptr = *chainptr; } elt->next_of_kind = ptr; *chainptr = elt; } /* Return the width of the widest of the count strings in the array * ptr of string pointers. If charcount is >0, then consider only the * first charcount characters of each string. */ static int widest(char **ptr, int count, int charcount) { int max = 0; int width; for (; count>0; --count, ++ptr) { width = TextLength(scrn_rast, *ptr, (charcount!=0 ? charcount : strlen(*ptr))); if (width > max) max = width; } return max; } /* Walk down the full display list recentering data in their part of * the display. A part of the display is delimited by vertical bars * (or the ends of the window). For each part, we traverse it once, * adding up the actual sizes of everything, and then traverse it * again placing everything where it should go. */ static void replan_display(int curr_day, int curr_wkday, int curr_month) { struct display_element *ptr = win_content; struct display_element *this_part; int left = inleft + horiz_padding; while(ptr != NULL) { int changed = 0; /* has this part changed? */ int total_width = 0; /* width of this part */ int total_max_width = 0; /* max width of this part */ this_part = ptr; for (; ptr!=NULL && ptr->kind!=vbar; ptr=ptr->next) { int width; switch (ptr->kind) { case day: /* remember: day is 0 origin, so '9' is the 10th */ width = digit_width * (curr_day<9 ? 1 : 2); break; case weekday_abbrev: width = TextLength(Window->RPort,str_weekday[curr_wkday],3); break; case weekday_full: width = TextLength(Window->RPort,str_weekday[curr_wkday], strlen(str_weekday[curr_wkday])); break; case month_abbrev: width = TextLength(Window->RPort,str_month[curr_month],3); break; case month_full: width = TextLength(Window->RPort,str_month[curr_month], strlen(str_month[curr_month])); break; default: width = ptr->max_width; /* width never changes */ break; } if (width != ptr->curr_width) { ptr->curr_width = width; changed = 1; } total_width += width; total_max_width += ptr->max_width; } if (changed) { left += (total_max_width-total_width)/2; for (ptr=this_part; ptr!=NULL && ptr->kind!=vbar; ptr=ptr->next) { ptr->left = left; left += ptr->curr_width; } } if (ptr != NULL) { left = ptr->left + ptr->max_width; ptr = ptr->next; } } } /* Clear the window and display all strings and bars. Also * invalidate all previous values for all update records, since after * this no values will be up-to-date. */ static void display_strings(void) { struct display_element *ptr; SetAPen(win_rast, background_pen); RectFill(win_rast, inleft, intop, inright, inbottom); for (ptr=win_content; ptr!=NULL; ptr=ptr->next) { switch(ptr->kind) { case invalid: case space: break; /* nothing to do */ case vbar: draw_bar(ptr->left+horiz_padding); break; case string: Move(Window->RPort, ptr->left, win_baseline); SetAPen(win_rast, ptr->pen); Text(Window->RPort, ptr->string.text, ptr->string.length); break; default: ptr->data.curr_value = -1; /* force later redisplay */ } } } /* draw a top-to-bottom bar in window at position x */ static void draw_bar(long x) { long bottom = Window->BorderTop-2; if (new_os) { /* a nice 3d bar */ SetAPen(win_rast, 1L); Move(Window->RPort, x, 1L); Draw(Window->RPort, x, bottom); SetAPen(win_rast, 2L); Move(Window->RPort, x+1, 1L); Draw(Window->RPort, x+1, bottom); } else { /* boring old single line for pre-2.0 systems*/ SetAPen(win_rast, 1L); Move(Window->RPort, x+1, 1L); Draw(Window->RPort, x+1, bottom); } } /* display all data in clock that have changed since last display. */ static void display_data(void) { struct display_element *ptr; unsigned long secs; int chip_free, fast_free, big_chip_free, big_fast_free; /* yr < 0 means we haven't computed yr, month, dy, weekday yet */ int yr=-1, month, dy, weekday, jul; if (need_time) { #ifdef CORRECTION static unsigned long next_correction = 0; #endif DoIO((struct IORequest *) &time_req.tr_node); secs = time_req.tr_time.tv_secs + offset_secs; #ifdef CORRECTION if (secs >= next_correction) { if (next_correction == 0) { /* need to set up next_correction */ next_correction = (correction_ratio==0 ? END_OF_TIME : secs + correction_ratio); } else { /* really need to make a one second correction now */ time_req.tr_node.io_Command = TR_SETSYSTIME; time_req.tr_time.tv_secs += correction; DoIO((struct IORequest *) &time_req.tr_node); time_req.tr_node.io_Command = TR_GETSYSTIME; next_correction += correction_ratio + correction; } } #endif for (ptr=time_chain; ptr!=NULL; ptr=ptr->next_of_kind) { int is_date = 0; int modulus; unsigned long val; /* the numeric value to show */ int len = 0; /* minimum int width, max string * width (0 means unlimited) */ char **string_array = NULL; /* the array whose val-th elt * to show, or NULL, to show * val as a number */ switch (ptr->kind) { case hour24: val=secs/3600; modulus=24; break; case hour12: val=secs/3600; modulus=12; break; case hour24_0: val=secs/3600; modulus=24; len=2; break; case hour12_0: val=secs/3600; modulus=12; len=2; break; case minute: val=secs/60; modulus=60; len=2; break; case second: val=secs; modulus=60; len=2; break; case am_pm: val=secs/43200;modulus= 2; string_array=str_am_pm; break; default : val=secs/SECS_PER_DAY; is_date=1; break; } /* chain is sorted, so when we get to an element that hasn't * changed, we know nothing later will have changed. */ if (val == ptr->data.curr_value) break; if (is_date) { if (yr < 0) { /* we haven't figured out the date yet, so do it now. */ compute_date(val, &yr, &month, &dy, &weekday, &jul); if (ptr->data.curr_value != -1) { replan_display(dy, weekday, month); display_strings(); display_data(); return; } } ptr->data.curr_value = val; switch (ptr->kind) { case year: val=yr; break; case year100: val=yr%100; len=2; break; case monthnum0: val=month+1; len=2; break; case monthnum: val=month+1; break; case month_abbrev: val=month; len=3; string_array=str_month; break; case month_full: val=month; string_array=str_month; break; case week_num_sun: val=(14+jul-((7+jul-weekday)%7))/7; break; case week_num_mon: val=(14+jul-((8+jul-weekday)%7))/7; break; case weekday_abbrev: val=weekday; len=3; string_array=str_weekday; break; case weekday_full: val=weekday; string_array=str_weekday; break; case weekday_num: val=1+weekday; break; case day0: val=dy+1; len=2; break; case day: val=dy+1; break; case julian: val=jul+1; break; } } else { val %= modulus; ptr->data.curr_value = val; } draw_datum(ptr, val, string_array, len); } } if (need_chip) chip_free = AvailMem(MEMF_CHIP); if (need_fast) fast_free = AvailMem(MEMF_FAST); if (need_big_chip) big_chip_free = AvailMem(MEMF_CHIP|MEMF_LARGEST); if (need_big_fast) big_fast_free = AvailMem(MEMF_FAST|MEMF_LARGEST); for (ptr=mem_chain; ptr!=NULL; ptr=ptr->next_of_kind) { int val; /* the numeric value to show */ switch (ptr->kind) { case chip_mem: val=chip_free; break; case chip_mem_K: val=(chip_free+512)>>10; break; case fast_mem: val=fast_free; break; case fast_mem_K: val=(fast_free+512)>>10; break; case total_mem: val=chip_free+fast_free; break; case total_mem_K: val=(chip_free+fast_free+512)>>10; break; case largest_chip: val=big_chip_free; break; case largest_chip_K: val=(big_chip_free+512)>>10; break; case largest_fast: val=big_fast_free; break; case largest_fast_K: val=(big_fast_free+512)>>10; break; case largest_mem: val=big_chip_free+big_fast_free; break; case largest_mem_K: val=(big_chip_free+big_fast_free+512)>>10; break; } draw_datum(ptr, val, NULL, 0); } } /* display a single datum in the window. *ptr describes where the * datum should be displayed, val is the value to display. If * string_array is non-NULL, then show its val-th element as a string, * rather than showing a number. If len is not 0, show only the first * len characters of the specified string, or show exactly len digits, * 0-filled if necessary, of val if string_array is NULL. */ static void draw_datum(struct display_element *ptr, int val, char **string_array, int len) { char *todraw; int pixelleft; if (string_array != NULL) { todraw = string_array[val]; if (len==0) len=strlen(todraw); } else { todraw = int_string(val, &len); } pixelleft = ptr->left + ptr->curr_width - TextLength(Window->RPort,todraw,len); if (ptr->left < pixelleft) { SetAPen(win_rast, background_pen); RectFill(win_rast, ptr->left, intop, pixelleft-1, inbottom); } Move(Window->RPort, pixelleft, win_baseline); SetAPen(win_rast, ptr->pen); Text(Window->RPort, todraw, len); } /* cheap int->string conversion. Doesn't handle negative numbers, and * always fills to the specified minimum width with 0's. It returns a * pointer to a static buffer, so one call's value is destroyed by the * next call to this function. But that's all we need for this clock. * Note that on completion we set *minwidth to the actual width. */ #define INT_STRING_BUFF_LEN 8 static char *int_string(int n, int *minwidth) { static char buffer[INT_STRING_BUFF_LEN]; char *ptr = &buffer[INT_STRING_BUFF_LEN-1]; int len=0, mw=*minwidth; *ptr = '\0'; do { *--ptr = '0'+n%10; n/=10; } while ((++len) 0); *minwidth = len; return ptr; } /* open libraries and initialize the timer device. */ static void initialize(void) { if ((IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library", INTUITION_REV)) == NULL) done(20); if ((GfxBase = (struct GfxBase *) OpenLibrary("graphics.library", 0L)) == NULL) done(20); /* set up delay clock, which will wake us every second */ if ((delay_port = CreatePort(NULL, 0L)) == NULL) done(20); if (OpenDevice(TIMERNAME, UNIT_VBLANK, (struct IORequest *) &delay_req, 0L) != NULL) done(20); delay_req.tr_node.io_Message.mn_ReplyPort = delay_port; delay_req.tr_node.io_Command = TR_ADDREQUEST; delay_req.tr_node.io_Flags = 0; delay_req.tr_node.io_Error = 0; delay_req.tr_time.tv_secs = 0; delay_req.tr_time.tv_micro = 1000000; /* send first request, to get us started */ SendIO((struct IORequest *) &delay_req.tr_node); /* set up time clock, which will get us system time */ if ((time_port = CreatePort(NULL, 0L)) == NULL) done(20); if (OpenDevice(TIMERNAME, UNIT_VBLANK /* does this matter? */, (struct IORequest *) &time_req, 0L) != NULL) done(20); time_req.tr_node.io_Message.mn_ReplyPort = time_port; time_req.tr_node.io_Command = TR_GETSYSTIME; time_req.tr_node.io_Flags = 0; time_req.tr_node.io_Error = 0; if (!GetScreenData(&screen_info, sizeof(screen_info), WBENCHSCREEN, NULL)) done(20); scrn_rast = &screen_info.RastPort; digit_width = TextLength(scrn_rast, "9", 1); space_width = TextLength(scrn_rast, " ", 1); new_os = ((struct Library *)IntuitionBase)->lib_Version >= 37; /* now we can set the default window left */ win_left = -2*(new_os ? WIDTH_OF_20_DEPTH_GADGET : WIDTH_OF_13_DEPTH_GADGET); } /* just clean up that which is open, and then leave. */ static void done(int code) { handle_args_finish(); /* cleanup arg handling */ if (Window) CloseWindow(Window); if (delay_req.tr_node.io_Message.mn_ReplyPort) { AbortIO((struct IORequest *) &delay_req.tr_node); CloseDevice((struct IORequest *) &delay_req); } if (delay_port) DeletePort(delay_port); if (time_req.tr_node.io_Message.mn_ReplyPort) CloseDevice((struct IORequest *) &time_req); if (time_port) DeletePort(time_port); if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase); if (GfxBase) CloseLibrary((struct Library *)GfxBase); /* free allocated memory */ while (win_content != NULL) { struct display_element *next = win_content->next; FreeMem(win_content, sizeof(*win_content)); win_content = next; } /* __exit() doesn't try to close files, so it makes a much * smaller executable than using exit(). This is the correct * thing to do, since we compile with the nostdio option. */ __exit((long)code); }