Applesoft Basic Interpreter

00001 #include <stdio.h>
00002 #include <string.h>
00003 #include <sys/types.h>
00004 #include <sys/stat.h>
00005 #include <unistd.h>
00006 #include <pthread.h>
00007 #include <sys/socket.h>
00008 #include <netinet/in.h>
00009 #include <sys/time.h>
00010 #include <signal.h>
00011 #include <arpa/telnet.h>
00012 #include <stdlib.h>
00013 #include <mysql/mysql.h>
00014 #include <libmysqlwrapped.h>
00015 #include <libeamon.h>
00016 
00017 #include "a.h"
00018 #include "ParserIO.h"
00019 #include "Parser.h"
00020 #include "THREAD.h"
00021 #include "eol.h"
00022 
00023 
00024 #define PRINT(x) \
00025         if (write_text(x) == -1) \
00026         { \
00027                 return -1; \
00028         }
00029 
00030 #define INPUT(x) \
00031         n = 200; \
00032         if (read_text(x, &n) == -1) \
00033         { \
00034                 perror("read() failed"); \
00035                 return -1; \
00036         }
00037 
00038 
00039 THREAD::THREAD()
00040 :next(NULL)
00041 ,running(0)
00042 ,socket(0)
00043 ,ib(0),it(0),iq(0)
00044 ,ob(0),ot(0),oq(0)
00045 ,account(NULL)
00046 ,current_event(NULL)
00047 ,selected(NULL)
00048 ,prompt_shown(0)
00049 ,adjust_case(0)
00050 {
00051         *last_print = 0;
00052         *prompt = 0;
00053         *instr = 0;
00054 
00055         pthread_mutex_lock(&event_mutex);
00056 
00057         current_event = eventbase;
00058         while (current_event -> next)
00059                 current_event = current_event -> next;
00060 
00061         pthread_mutex_unlock(&event_mutex);
00062 }
00063 
00064 
00065 THREAD::~THREAD()
00066 {
00067 }
00068 
00069 
00070 int THREAD::ioloop(char *s,int *l)
00071 {
00072         struct timeval tv;
00073         fd_set rfds;
00074         fd_set wfds;
00075         int n;
00076         int max_l = *l;
00077         char c;
00078         char buffer[1024];
00079 
00080         *l = 0;
00081         while (1)
00082         {
00083                 if (oq)
00084                 {
00085 printf(" - writing %d bytes from output buffer\n",oq);
00086                         if (ob + oq > OUTBUFSIZE)
00087                         {
00088                                 int l = OUTBUFSIZE - ob;
00089                                 n = write(socket, outbuf + ob, l);
00090                         }
00091                         else
00092                         {
00093                                 n = write(socket, outbuf + ob, oq);
00094                         }
00095 printf(" -- %d bytes written\n",n);
00096                         if (n == -1)
00097                         {
00098                                 perror("ioloop() write() failed");
00099 //                              return -1;
00100                         }
00101                         else
00102                         if (!n)
00103                         {
00104                                 cmdline.m_next_line = NULL;
00105                                 return 0;
00106                         }
00107                         else
00108                         {
00109                                 ob += n;
00110                                 if (ob >= OUTBUFSIZE)
00111                                         ob -= OUTBUFSIZE;
00112                                 oq -= n;
00113                         }
00114                 }
00115 
00116                 if (iq)
00117                 {
00118                         c = inbuf[ib++];
00119                         if (ib >= INBUFSIZE)
00120                                 ib -= INBUFSIZE;
00121                         iq--;
00122                         if (c == 13 || c == 10)
00123                         {
00124                                 if (iq && (inbuf[ib] == 13 || inbuf[ib] == 10))
00125                                 {
00126                                         ib++;
00127                                         if (ib >= INBUFSIZE)
00128                                                 ib -= INBUFSIZE;
00129                                         iq--;
00130                                 }
00131                                 if (*l < max_l)
00132                                         s[*l] = '\n';
00133                                 *l = *l + 1;
00134                                 return *l;
00135                         }
00136                         else
00137                         {
00138                                 if (adjust_case)
00139                                         if (c >= 'a' && c <= 'z')
00140                                                 c -= 32;
00141                                 if (*l < max_l)
00142                                         s[*l] = c;
00143                                 *l = *l + 1;
00144                                 if (*l >= max_l)
00145                                 {
00146                                         while (iq && (inbuf[ib] == 13 || inbuf[ib] == 10))
00147                                         {
00148                                                 ib++;
00149                                                 if (ib >= INBUFSIZE)
00150                                                         ib -= INBUFSIZE;
00151                                                 iq--;
00152                                         }
00153                                         return *l;
00154                                 }
00155                         }
00156                 }
00157 
00158                 FD_ZERO(&rfds);
00159                 FD_ZERO(&wfds);
00160                 FD_SET(socket, &rfds);
00161                 FD_SET(socket, &wfds);
00162                 tv.tv_sec = 1;
00163                 tv.tv_usec = 0;
00164                 n = select(socket + 1,&rfds,&wfds,NULL,&tv);
00165                 if (n == -1)
00166                 {
00167                         perror("ioloop() select() failed");
00168                         cmdline.m_next_line = NULL;
00169                         return -1;
00170                 }
00171                 if (!n)
00172                 {
00173                         return 0;       // timeout
00174                 }
00175                 else
00176                 {
00177                         if (FD_ISSET(socket, &rfds))
00178                         {
00179                                 n = read(socket, buffer, 1024);
00180                                 if (n == -1)
00181                                 {
00182                                         perror("ioloop() read() failed");
00183                                         cmdline.m_next_line = NULL;
00184                                         return -1;
00185                                 }
00186                                 if (!n)
00187                                 {
00188                                         cmdline.m_next_line = NULL;
00189                                         return 0;
00190                                 }
00191                                 else
00192                                 {
00193                                         if (it + n > INBUFSIZE)
00194                                         {
00195                                                 int l = INBUFSIZE - it;
00196                                                 memmove(inbuf + it,buffer,l);
00197                                                 memmove(inbuf,buffer + l,n - l);
00198                                         }
00199                                         else
00200                                         {
00201                                                 memmove(inbuf + it,buffer,n);
00202                                         }
00203                                         it += n;
00204                                         if (it >= INBUFSIZE)
00205                                                 it -= INBUFSIZE;
00206                                         iq += n;
00207                                 }
00208                         }
00209                         if (FD_ISSET(socket, &wfds) && oq)
00210                         {
00211                                 if (ob + oq > OUTBUFSIZE)
00212                                 {
00213                                         int l = OUTBUFSIZE - ob;
00214                                         n = write(socket, outbuf + ob, l);
00215                                 }
00216                                 else
00217                                 {
00218                                         n = write(socket, outbuf + ob, oq);
00219                                 }
00220                                 if (n == -1)
00221                                 {
00222                                         perror("ioloop() write() failed");
00223 //                                      return -1;
00224                                 }
00225                                 else
00226                                 if (!n)
00227                                 {
00228                                         cmdline.m_next_line = NULL;
00229                                         return 0;
00230                                 }
00231                                 else
00232                                 {
00233                                         ob += n;
00234                                         if (ob >= OUTBUFSIZE)
00235                                                 ob -= OUTBUFSIZE;
00236                                         oq -= n;
00237                                 }
00238                         }
00239                 }
00240         } // while (1)
00241 }
00242 
00243 #define USE_NEW
00244 #ifdef USE_NEW
00245 int THREAD::read_text(char *s,int *l)
00246 {
00247         FILE *fil;
00248         int n = 0;
00249         int i;
00250         int max_l = *l;
00251         int x;
00252         int crlf = 0;
00253         int iol;
00254         char slask[1024];
00255 
00256         if (strstr(last_print,"INSERT DISKETTE WITH ADVENTURE (OR KEEP") &&
00257             strstr(last_print,"THIS DISKETTE FOR BEGINNERS CAVE) IN") &&
00258             strstr(last_print,"DISK DRIVE IN SLOT SIX, DRIVE ONE THEN") &&
00259             strstr(last_print,"HIT 'C'"))
00260         {
00261 printf(" *** CHANGE DIR TO SELECTED ADVENTURE\n");
00262                 if (selected)
00263                 {
00264                         sprintf(slask,"../%s",selected -> dir);
00265                         if (chdir(slask) == -1)
00266                         {
00267                                 perror("chdir() failed");
00268                         }
00269                 }
00270                 strcpy(s,"C");
00271                 *l = 1;
00272                 return 1;
00273         }
00274 
00275         x = -1;
00276         for (i = 0; i < (int)strlen(last_print); i++)
00277                 if (last_print[i] == 13 || last_print[i] == 10)
00278                         x = i;
00279         strcpy(prompt, (x > -1) ? last_print + x + 1 : last_print);
00280         prompt_shown = 1;
00281 
00282         *l = 0;
00283         *instr = 0;
00284 
00285         while (1)
00286         {
00287                 // show events
00288                 if (catchup() == -1)
00289                         return -1;
00290 
00291                 if (!prompt_shown)
00292                 {
00293                         PRINT( prompt );
00294                         PRINT( instr );
00295                         prompt_shown = 1;
00296                 }
00297 
00298                 iol = max_l;
00299                 n = ioloop(slask, &iol);
00300 printf(" - ioloop() returns %d\n",n);
00301                 if (n == -1)
00302                 {
00303                         perror("read() failed");
00304                         cmdline.m_next_line = NULL;
00305                         return -1;
00306                 }
00307                 else
00308                 if (n == 0)
00309                 {
00310                         cmdline.m_next_line = NULL;
00311                         return 0;
00312                 }
00313                 else
00314                 {
00315                         for (i = 0; i < n; i++)
00316                         {
00317                                 if (*l < max_l) // check buffer overflow
00318                                 {
00319                                         instr[*l] = slask[i];
00320                                         s[*l] = slask[i];
00321                                 }
00322                                 if (slask[i] == 13 || slask[i] == 10)
00323                                         crlf = 1;
00324                                 *l = *l + 1;
00325                         }
00326                         instr[*l] = s[*l] = 0;
00327 
00328                         if (crlf || *l >= max_l)
00329                         {
00330                                 n = *l;
00331                                 s[*l] = 0;
00332                                 while (s[strlen(s) - 1] == 13 || s[strlen(s) - 1] == 10)
00333                                         s[strlen(s) - 1] = 0;
00334                                 switch (*s)
00335                                 {
00336                                 case '#':
00337                                         fil = fopen("/home/eamon/ends.txt","at");
00338                                         if (!fil)
00339                                                 fil = fopen("/home/eamon/ends.txt","wt");
00340                                         fprintf(fil,"%s\n\n",last_print);
00341                                         fclose(fil);
00342                                         PRINT("Ok.\n");
00343                                         break;
00344                                 case '"':
00345                                 case '\'':
00346                                         sprintf(slask,"%s says '%s'.",account -> login.c_str(),s + 1);
00347                                         add_event( slask );
00348                                         PRINT("Ok.\n");
00349                                         break;
00350                                 case '/':
00351                                         if (!strcasecmp(s, "/abort"))
00352                                         {
00353                                                 PRINT("Aborting program, press enter.\n");
00354                                                 cmdline.m_next_line = NULL;
00355                                         }
00356                                         else
00357                                         if (!strncasecmp(s, "/e", 2)) // emote
00358                                         {
00359                                                 x = -1;
00360                                                 for (i = 0; i < (int)strlen(s); i++)
00361                                                         if (s[i] == ' ')
00362                                                         {
00363                                                                 x = i;
00364                                                                 break;
00365                                                         }
00366                                                 if (x > -1)
00367                                                 {
00368                                                         sprintf(slask,"%s %s\n",account -> login.c_str(),s + x + 1);
00369                                                         add_event(slask);
00370                                                         PRINT( slask );
00371                                                 }
00372                                         }
00373                                         else
00374                                         if (!strncasecmp(s, "/w", 2))
00375                                         {
00376                                                 THREAD *t;
00377                                                 VARIABLE *v;
00378                                                 pthread_mutex_lock(&thread_mutex);
00379                                                 for (t = threadbase; t; t = t -> next)
00380                                                 if (t -> account) //login)
00381                                                 {
00382                                                         PRINT( (char *)t -> account -> login.c_str());
00383                                                         v = t -> cmdline.get_variable("NA$");
00384                                                         if (v)
00385                                                         {
00386                                                                 PRINT("  ");
00387                                                                 PRINT(v -> svalue);
00388                                                         }
00389                                                         v = t -> cmdline.get_variable("RO");
00390                                                         if (v)
00391                                                         {
00392                                                                 PRINT("  Room#");
00393                                                                 sprintf(slask,"%d",(int)v -> value);
00394                                                                 PRINT( slask );
00395                                                         }
00396                                                         PRINT("\n");
00397                                                 }
00398                                                 pthread_mutex_unlock(&thread_mutex);
00399                                         }
00400                                         break;
00401                                 default:
00402                                         // convert to eamon standard uppercase
00403                                         if (adjust_case)
00404                                         {
00405                                                 for (i = 0; i < (int)strlen(s); i++)
00406                                                         if (s[i] >= 'a' && s[i] <= 'z')
00407                                                                 s[i] -= 32;
00408                                         }
00409                                         return n;
00410                                 }
00411                         } // if (crlf)
00412                         if (crlf)
00413                         {
00414                                 prompt_shown = 0;
00415                                 *l = 0;
00416                                 crlf = 0;
00417                                 *instr = 0;
00418                         }
00419                 }
00420         } // while (1)
00421         return -1;
00422 }
00423 
00424 int THREAD::write_text(char *s,int ll)
00425 {
00426         int l = (ll == -1) ? strlen(s) : ll;
00427         int i;
00428         int cr = 0;
00429         int uc = 1;
00430         char c;
00431 
00432         strncpy(last_print, s, l);
00433         last_print[l] = 0;
00434 
00435         for (i = 0; i < l; i++)
00436         {
00437                 if (s[i] == '\n')
00438                 {
00439                         if (!cr)
00440                         {
00441 outbuf[ot++] = '\r';
00442 if (ot > OUTBUFSIZE)
00443         ot -= OUTBUFSIZE;
00444 oq++;
00445 outbuf[ot++] = '\n';
00446 if (ot > OUTBUFSIZE)
00447         ot -= OUTBUFSIZE;
00448 oq++;
00449                                 cr = 1;
00450                         }
00451                         else
00452                         {
00453                                 cr = 0;
00454                         }
00455                 }
00456                 else
00457                 {
00458                         c = s[i];
00459                         if (adjust_case)
00460                         {
00461                         switch (c)
00462                         {
00463                         case '.':
00464 //                      case '\'':
00465                         case '"':
00466                         case '!':
00467                         case ':':
00468                         case '?':
00469                         case '-':
00470                         case '=':
00471                         case '(':
00472                         case ')':
00473                                 uc = 1;
00474                                 break;
00475                         }
00476                         if (s[i] >= 'A' && s[i] <= 'Z')
00477                         {
00478                                 if (!uc)
00479                                         c += 32;
00480                                 uc = 0;
00481                         }
00482                         } // if (adjust_case)
00483 outbuf[ot++] = c;
00484 if (ot > OUTBUFSIZE)
00485         ot -= OUTBUFSIZE;
00486 oq++;
00487                         cr = 0;
00488                 }
00489         }
00490         return l;
00491 }
00492 
00493 #else
00494 int THREAD::read_text(char *s,int *l)
00495 {
00496         FILE *fil;
00497         struct timeval tv;
00498         fd_set rfds;
00499         int n;
00500         int i;
00501         int max_l = *l;
00502         int x;
00503         int crlf = 0;
00504         char slask[1024];
00505 
00506         if (strstr(last_print,"INSERT DISKETTE WITH ADVENTURE (OR KEEP") &&
00507             strstr(last_print,"THIS DISKETTE FOR BEGINNERS CAVE) IN") &&
00508             strstr(last_print,"DISK DRIVE IN SLOT SIX, DRIVE ONE THEN") &&
00509             strstr(last_print,"HIT 'C'"))
00510         {
00511 printf(" *** CHANGE DIR TO SELECTED ADVENTURE\n");
00512                 if (selected)
00513                 {
00514                         sprintf(slask,"../%s",selected -> dir);
00515                         if (chdir(slask) == -1)
00516                         {
00517                                 perror("chdir() failed");
00518                         }
00519                 }
00520                 strcpy(s,"C");
00521                 *l = 1;
00522                 return 1;
00523         }
00524 
00525         x = -1;
00526         for (i = 0; i < (int)strlen(last_print); i++)
00527                 if (last_print[i] == 13 || last_print[i] == 10)
00528                         x = i;
00529         strcpy(prompt, (x > -1) ? last_print + x + 1 : last_print);
00530         prompt_shown = 1;
00531 
00532         *l = 0;
00533         *instr = 0;
00534 
00535         while (1)
00536         {
00537         // show events
00538         if (catchup() == -1)
00539                 return -1;
00540 
00541         if (!prompt_shown)
00542         {
00543                 PRINT( prompt );
00544                 PRINT( instr );
00545                 prompt_shown = 1;
00546         }
00547 
00548         FD_ZERO(&rfds);
00549         FD_SET(socket, &rfds);
00550         tv.tv_sec = 1;
00551         tv.tv_usec = 0;
00552         n = select(socket + 1, &rfds, NULL, NULL, &tv);
00553         if (n == -1)
00554         {
00555                 perror("select() failed");
00556                 cmdline.m_next_line = NULL;
00557                 return -1;
00558         }
00559         else
00560         if (!n)         // timeout
00561         {
00562 /*
00563                 printf("select() returns 0 (?)\n");
00564                 cmdline.m_next_line = NULL;
00565                 return 0;
00566 */
00567         }
00568         else
00569         if (n > 0)
00570         {
00571         if (FD_ISSET(socket, &rfds))
00572         {
00573                 n = read(socket, slask, max_l);
00574                 if (n == -1)
00575                 {
00576                         perror("read() failed");
00577                         cmdline.m_next_line = NULL;
00578                         return -1;
00579                 }
00580                 else
00581                 if (n == 0)
00582                 {
00583                         cmdline.m_next_line = NULL;
00584                         return 0;
00585                 }
00586                 else
00587                 {
00588                         for (i = 0; i < n; i++)
00589                         {
00590                                 if (*l < max_l) // check buffer overflow
00591                                 {
00592                                         instr[*l] = slask[i];
00593                                         s[*l] = slask[i];
00594                                 }
00595                                 if (slask[i] == 13 || slask[i] == 10)
00596                                         crlf = 1;
00597                                 *l = *l + 1;
00598                         }
00599                         instr[*l] = s[*l] = 0;
00600 
00601                         if (crlf || *l >= max_l)
00602                         {
00603                                 n = *l;
00604                                 s[*l] = 0;
00605                                 while (s[strlen(s) - 1] == 13 || s[strlen(s) - 1] == 10)
00606                                         s[strlen(s) - 1] = 0;
00607                                 switch (*s)
00608                                 {
00609                                 case '#':
00610                                         fil = fopen("/home/eamon/ends.txt","at");
00611                                         if (!fil)
00612                                                 fil = fopen("/home/eamon/ends.txt","wt");
00613                                         fprintf(fil,"%s\n\n",last_print);
00614                                         fclose(fil);
00615                                         PRINT("Ok.\n");
00616                                         break;
00617                                 case '"':
00618                                 case '\'':
00619                                         sprintf(slask,"%s says '%s'.",account -> login,s + 1);
00620                                         add_event( slask );
00621                                         PRINT("Ok.\n");
00622                                         break;
00623                                 case '/':
00624                                         if (!strcasecmp(s, "/abort"))
00625                                         {
00626                                                 PRINT("Aborting program.\n");
00627                                                 cmdline.m_next_line = NULL;
00628                                         }
00629                                         else
00630                                         if (!strncasecmp(s, "/e", 2)) // emote
00631                                         {
00632                                                 x = -1;
00633                                                 for (i = 0; i < (int)strlen(s); i++)
00634                                                         if (s[i] == ' ')
00635                                                         {
00636                                                                 x = i;
00637                                                                 break;
00638                                                         }
00639                                                 if (x > -1)
00640                                                 {
00641                                                         sprintf(slask,"%s %s\n",account -> login,s + x + 1);
00642                                                         add_event(slask);
00643                                                         PRINT( slask );
00644                                                 }
00645                                         }
00646                                         else
00647                                         if (!strncasecmp(s, "/w", 2))
00648                                         {
00649                                                 THREAD *t;
00650                                                 VARIABLE *v;
00651                                                 pthread_mutex_lock(&thread_mutex);
00652                                                 for (t = threadbase; t; t = t -> next)
00653                                                 if (t -> account) //login)
00654                                                 {
00655                                                         PRINT(t -> account -> login);
00656                                                         v = t -> cmdline.get_variable("NA$");
00657                                                         if (v)
00658                                                         {
00659                                                                 PRINT("  ");
00660                                                                 PRINT(v -> svalue);
00661                                                         }
00662                                                         v = t -> cmdline.get_variable("RO");
00663                                                         if (v)
00664                                                         {
00665                                                                 PRINT("  Room#");
00666                                                                 sprintf(slask,"%d",(int)v -> value);
00667                                                                 PRINT( slask );
00668                                                         }
00669                                                         PRINT("\n");
00670                                                 }
00671                                                 pthread_mutex_unlock(&thread_mutex);
00672                                         }
00673                                         break;
00674                                 default:
00675                                         // convert to eamon standard uppercase
00676                                         if (adjust_case)
00677                                         {
00678                                                 for (i = 0; i < (int)strlen(s); i++)
00679                                                         if (s[i] >= 'a' && s[i] <= 'z')
00680                                                                 s[i] -= 32;
00681                                         }
00682                                         return n;
00683                                 }
00684                         } // if (crlf)
00685                         if (crlf)
00686                         {
00687                                 prompt_shown = 0;
00688                                 *l = 0;
00689                                 crlf = 0;
00690                                 *instr = 0;
00691                         }
00692                 }
00693         } // if (FD_ISSET(socket))
00694         } // if (n > 0)
00695         } // while (1)
00696         return -1;
00697 }
00698 
00699 int THREAD::write_text(char *s,int ll)
00700 {
00701         int l = (ll == -1) ? strlen(s) : ll;
00702         int n;
00703         int i;
00704         int p = 0;
00705         int cr = 0;
00706         int uc = 1;
00707         char c;
00708         char buf[1024];
00709 
00710         strncpy(last_print, s, l);
00711         last_print[l] = 0;
00712 
00713         for (i = 0; i < l; i++)
00714         {
00715                 if (s[i] == '\n')
00716                 {
00717                         if (!cr)
00718                         {
00719                                 if (p < 1024)
00720                                         buf[p++] = '\r';
00721                                 if (p < 1024)
00722                                         buf[p++] = '\n';
00723                                 cr = 1;
00724                         }
00725                         else
00726                         {
00727                                 cr = 0;
00728                         }
00729                 }
00730                 else
00731                 {
00732                         c = s[i];
00733                         if (adjust_case)
00734                         {
00735                         switch (c)
00736                         {
00737                         case '.':
00738 //                      case '\'':
00739                         case '"':
00740                         case '!':
00741                         case ':':
00742                         case '?':
00743                         case '-':
00744                         case '=':
00745                         case '(':
00746                         case ')':
00747                                 uc = 1;
00748                                 break;
00749                         }
00750                         if (s[i] >= 'A' && s[i] <= 'Z')
00751                         {
00752                                 if (!uc)
00753                                         c += 32;
00754                                 uc = 0;
00755                         }
00756                         } // if (adjust_case)
00757                         if (p < 1024)
00758                                 buf[p++] = c;
00759                         cr = 0;
00760                 }
00761         }
00762         if ( (n = write(socket, buf, p)) == -1)
00763         {
00764                 perror("write() failed");
00765         }
00766         return n;
00767 }
00768 #endif
00769 
00770 
00771 /*
00772 ** Turn off echoing (specific to telnet client)
00773 */
00774 
00775 void    THREAD::echo_off()
00776 {
00777         char    off_string[] = 
00778         {
00779                 (char) IAC,
00780                 (char) WILL,
00781                 (char) TELOPT_ECHO,
00782                 (char)  0,
00783         };
00784 
00785         write(socket, off_string, 3);
00786 }
00787 
00788 
00789 /*
00790 ** Turn on echoing (specific to telnet client)
00791 */
00792 
00793 
00794 void    THREAD::echo_on()
00795 {
00796         char    off_string[] = 
00797         {
00798                 (char) IAC,
00799                 (char) WONT,
00800                 (char) TELOPT_ECHO,
00801                 (char) TELOPT_NAOFFD,
00802                 (char) TELOPT_NAOCRD,
00803                 (char)  0,
00804         };
00805 
00806         write(socket, off_string, 5);
00807 }
00808 
00809 
00810 void THREAD::add_event(char *s)
00811 {
00812         EVENT *e;
00813         EVENT *q;
00814 
00815         e = new EVENT;
00816         e -> next = NULL;
00817         e -> source = this;
00818         strcpy(e -> text,s);
00819 
00820         pthread_mutex_lock(&event_mutex);
00821 
00822         for (q = eventbase; q -> next; q = q -> next)
00823                 ;
00824         q -> next = e;
00825 
00826         pthread_mutex_unlock(&event_mutex);
00827 }
00828 
00829 
00830 int THREAD::catchup()
00831 {
00832         int dirty = 0;
00833 
00834         if (current_event -> next)
00835         {
00836                 pthread_mutex_lock(&event_mutex);
00837 
00838                 while (current_event -> next)
00839                 {
00840                         current_event = current_event -> next;
00841                         if (current_event -> source != this)
00842                         {
00843                                 if (!dirty)
00844                                 {
00845                                         PRINT("\n");            // destroys last_print
00846                                 }
00847                                 PRINT( current_event -> text );
00848                                 dirty = 1;
00849                         }
00850                 }
00851 
00852                 pthread_mutex_unlock(&event_mutex);
00853 
00854                 if (dirty)
00855                 {
00856                         PRINT("\n");
00857                         PRINT( prompt );
00858                         PRINT( instr );
00859                         prompt_shown = 1;
00860                 }
00861         }
00862         return 0;
00863 }
00864 
00865 
00866 int THREAD::get_adv()
00867 {
00868         ADV *adv;
00869         ADV *adv2;
00870         int i;
00871         int n;
00872         char slask[200];
00873 
00874         i = 0;
00875         adv2 = NULL;
00876         for (adv = advbase; adv; adv = adv -> next, i++)
00877         {
00878                 sprintf(slask,"%4d) %s\n",adv -> num,adv -> descr);
00879                 PRINT( slask );
00880                 if (i >= 10 && adv -> next)
00881                 {
00882                         PRINT("#/Q/[M]ORE? ");
00883                         INPUT(slask)
00884                         else
00885                         {
00886                                 slask[n] = 0;
00887                                 if (*slask == 'Q')
00888                                 {
00889                                         break;
00890                                 }
00891                                 else
00892                                 if (*slask >= '0' && *slask <= '9')
00893                                 {
00894                                         i = atoi(slask);
00895                                         for (adv2 = advbase; adv2; adv2 = adv2 -> next)
00896                                                 if (adv2 -> num == i)
00897                                                         break;
00898                                         if (adv2)
00899                                                 break;
00900                                 }
00901                         }
00902                         i = 0;
00903                 }
00904         }
00905         if (!adv2 && *slask != 'Q')
00906         {
00907                 PRINT("Adventure #? ");
00908                 INPUT(slask)
00909                 else
00910                 {
00911                         slask[n] = 0;
00912                         if (*slask >= '0' && *slask <= '9')
00913                         {
00914                                 i = atoi(slask);
00915                                 for (adv2 = advbase; adv2; adv2 = adv2 -> next)
00916                                         if (adv2 -> num == i)
00917                                                 break;
00918                         }
00919                 }
00920         }
00921         selected = adv2;
00922         if (adv2)
00923         {
00924                 sprintf(slask,"../%s",adv2 -> dir);
00925                 if (chdir(slask) == -1)
00926                 {
00927                         sprintf(slask,"cp -a %s/%s ..",
00928                                 EA_DISKS,adv2 -> dir);
00929                         printf("Copying Adventure: %s\n",slask);
00930                         system(slask);
00931                 }
00932                 else
00933                 {
00934                         chdir("../ea.master");
00935                 }
00936         }
00937         return 0;
00938 }
00939
THREAD.cpp
