home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Utilities / CommentConverter 1.0.0 / Think C 7.0 Project / Sources / Help.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-07  |  38.4 KB  |  951 lines  |  [TEXT/KAHL]
  1. #ifndef bsioc
  2. #define bsioc
  3.  
  4. //Alternativ: #pragma once
  5.  
  6. /***************************************************************************/
  7. /*****   Datei, die alle innerhalb von SETI benötigten E/A-Routinen    *****/
  8. /*****   bereitstellt.                                                 *****/
  9. /*****   Autor:    Andreas Amoroso                                     *****/
  10. /*****   Datum:    11.8.1993                                           *****/
  11. /***************************************************************************/
  12.  
  13.  
  14. //SCREENSIZE 80 * 24
  15. //80 Dots ................................................................................ 
  16. //80 Dots ................................................................................ 
  17. //80 Dots ................................................................................ 
  18. //80 Dots ................................................................................ 
  19. //80 Dots ................................................................................ 
  20. //80 Dots ................................................................................ 
  21. //80 Dots ................................................................................ 
  22. //80 Dots ................................................................................
  23. //80 Dots ................................................................................ 
  24. //80 Dots ................................................................................ 
  25. //80 Dots ................................................................................ 
  26. //80 Dots ................................................................................ 
  27. //80 Dots ................................................................................ 
  28. //80 Dots ................................................................................ 
  29. //80 Dots ................................................................................ 
  30. //80 Dots ................................................................................ 
  31. //80 Dots ................................................................................ 
  32. //80 Dots ................................................................................ 
  33. //80 Dots ................................................................................ 
  34. //80 Dots ................................................................................ 
  35. //80 Dots ................................................................................ 
  36. //80 Dots ................................................................................ 
  37. //80 Dots ................................................................................ 
  38. //80 Dots ................................................................................ 
  39.  
  40.  
  41.  
  42.  
  43. //INCLUDES                      //  INCLUDE ALL OF THIS IN YOUR FILE!!!
  44.                                 //  ===================================
  45. #include <fcntl.h>
  46. #include <float.h>
  47. #include <limits.h>
  48. #ifdef ibm
  49. #include <stddef.h>
  50. #endif // ifdef ibm
  51. #ifdef apple
  52. #include <size_t.h>
  53. #include <stat.h>
  54. #endif // ifdef apple
  55. #include <stdarg.h>
  56.  
  57. #include <stdio.h>
  58. #include <string.h>
  59. #include <ctype.h>
  60. #include <stdlib.h>
  61. #include <time.h>
  62. #include <stddef.h>
  63. #include <math.h>
  64.  
  65. #ifdef modus_inter
  66. #ifdef apple
  67. #include <console.h>
  68. #include <pascal.h>
  69. #endif // apple
  70. #endif // modus_inter
  71.  
  72. #include "Apple.h"
  73. #include "Help.h"
  74.  
  75.  
  76.  
  77.  
  78. //DEFINITIONS
  79.  
  80. void ConInit(char * modul)                              //  Sets 24 * 80 mode on mac, call before first console i/o
  81. //      ConInit("RedEX\0");                             //  Example call
  82. {
  83. #ifdef modus_inter
  84. #ifdef apple
  85.     console_options.nrows=24;
  86.     console_options.ncols=80;
  87.     console_options.title = CtoPstr(modul);
  88. #ifndef testmode
  89.     console_options.pause_atexit = 0;
  90. #endif //testmode
  91.     cshow(stdin);
  92. #endif // ifdef apple
  93. #endif // ifdef modus_inter
  94. }
  95.  
  96.      
  97. int GenOutHeader(char *modul,char *version,char *funktion) 
  98. // N.B.: Maximale Länge der übergebenen Zeichenketten :44 inkl. \0!
  99. // modul = Modulname
  100. // funktion = Funktionsbschreibung in wenigen Worten 
  101. {
  102.     char modmax[MaxHeadOutLen],vermax[MaxHeadOutLen],funmax[MaxHeadOutLen],timmax[MaxHeadOutLen];
  103.     struct tm *time_now;
  104.     time_t secs_now;
  105.     int i=0,
  106.         modlen=0,
  107.         verlen=0,
  108.         funlen=0,
  109.         timlen=0,
  110.         error=0;
  111.     error = ((modul == (char *)NULL) || (version == (char *)NULL) || (funktion == (char *)NULL));
  112.     error = (NULL == (time_now = (struct tm *) malloc(sizeof(struct tm))));
  113.     if ((long) strlen(modul) >= (long) MaxModulNamLen) error = 1; 
  114.     if ((long) strlen(version) >= (long) MaxHeadOutLen) error = 1;
  115.     if ((long) strlen(funktion) >= (long) MaxHeadOutLen) error = 1;
  116.     if (!error)
  117.     {
  118.         strncpy(modmax,modul,MaxModulNamLen);
  119.         strncpy(vermax,version,MaxHeadOutLen);
  120.         strncpy(funmax,funktion,MaxHeadOutLen);
  121. #ifdef ibm
  122.         tzset(); // DOS/UNIX-Kommando zum setzen der Zeit, auf Mac unnötig!!!
  123. #endif // ifdef ibm
  124.         time(&secs_now);
  125.         time_now = localtime(&secs_now);
  126.         strftime(timmax, MaxTimeDateLen,"%d.%b.%y, %H:%M:%S",time_now);
  127.         *(modmax+MaxHeadOutLen-1) = '\0';
  128.         *(vermax+MaxHeadOutLen-1) = '\0';
  129.         *(funmax+MaxHeadOutLen-1) = '\0';
  130.         *(timmax+MaxHeadOutLen-1) = '\0';
  131.         modlen = (int) strlen(modmax);
  132.         funlen = (int) strlen(funmax);
  133.         verlen = (int) strlen(vermax);
  134.         timlen = (int) strlen(timmax);
  135.         for (i=(int)modlen; i< (MaxHeadOutLen-1); i++)
  136.             *(modmax+i)=' ';
  137.         for (i=(int)verlen; i< (MaxHeadOutLen-1); i++)
  138.             *(vermax+i)=' ';
  139.         for (i=(int)funlen; i< (MaxHeadOutLen-1); i++)
  140.             *(funmax+i)=' ';
  141.         for (i=(int)timlen; i< (MaxHeadOutLen-1); i++)
  142.             *(timmax+i)=' ';
  143.         if (EOF == printf("\n\n")) error =1;
  144.         if (EOF == printf("\n           .........................................................")) error =1;
  145.         if (EOF == printf("\n           .            __       ____    _______                   .")) error =1;
  146.         if (EOF == printf("\n           .           /         |          |        |             .")) error =1;
  147.         if (EOF == printf("\n           .           \\__       |__        |        |             .")) error =1;
  148.         if (EOF == printf("\n           .              \\      |          |        |             .")) error =1;
  149.         if (EOF == printf("\n           .            __/      |____      |        |             .")) error =1;
  150.         if (EOF == printf("\n           .                                                       .")) error =1;
  151.     if (EOF == printf("\n           . Development System for SElf TImed sequential Circuits .")) error =1;
  152.         if (EOF == printf("\n           .                                                       .")) error =1;
  153.         if (EOF == printf("\n           .        (c)1993  Universitaet Kaiserslautern           .")) error =1;
  154.         if (EOF == printf("\n           .                     AG Beister                        .")) error =1;
  155.         if (EOF == printf("\n           .........................................................")) error =1;
  156.         if (EOF == printf("\n           . Module:   %s .",modmax)) error =1;
  157.         if (EOF == printf("\n           . Version:  %s .",vermax)) error =1;
  158.         if (EOF == printf("\n           . Function: %s .",funmax)) error =1;
  159.         if (EOF == printf("\n           . Time:     %s .",timmax)) error =1;
  160.         if (EOF == printf("\n           .........................................................")) error =1;
  161.         if (EOF == printf("\n\n\n\a\a")) error =1;
  162.     }
  163.     if (EOF == GenOutAcknowledge(ModusReturn)) error =1;
  164.     free(time_now);
  165.     return(error ? EOF : 0);
  166. }
  167.  
  168. #ifdef modus_inter
  169. int GenOutTrailer(void) 
  170. {
  171.     int error = 0;
  172.     
  173.     GenOutClrScr(MaxLineCntS,(char *) NULL);
  174.     if (EOF == printf("\n           .........................................................")) error =1;
  175.     if (EOF == printf("\n           . Good bye...                                           .")) error =1;
  176.     if (EOF == printf("\n           .........................................................")) error =1;
  177.     if (EOF == printf("\n\n\n\n\a")) error =1;
  178.     return(error ? EOF : 0);
  179. }
  180. #endif // ifdef modus_inter
  181.  
  182. #ifdef modus_inter
  183. int GenOutMenu(char *menu[], char *menustring, char *modul, int PktZahl)
  184.                                                                     // PktZahl = Arraylänge PLUS 1 (öberschrift!)
  185. {
  186.     int i = 0, space = 0, length = 0, error = 0;
  187.     char title[MaxMenuTitleLen], modmax[MaxModulNamLen], helpstr[MaxLineS], formstr[MaxLineS],
  188. //       *menumax[MaxMenuPointCnt];
  189.          menumax[MaxMenuPointCnt][MaxMenuPointLen+1];
  190.     div_t res;
  191.     
  192.     error = ((menustring == (char *)NULL) || (modul == (char *)NULL));
  193.     for (i=0; i<= PktZahl; i++)
  194.         error = ((char *)NULL == menu[i]);
  195.     if ( (long) strlen(modul) >= (long) MaxModulNamLen) error = 1;
  196.     if (PktZahl >= MaxMenuPointCnt) error = 1;                      // Menüpunkte PLUS öberschrift!
  197.     if ((long) strlen(menu[0]) >= (long) MaxMenuTitleLen) error = 1;
  198.     for (i=1; i<= PktZahl; i++)
  199.         if ((long) strlen(menu[i]) >= (long) MaxMenuPointLen) error = 1;
  200.     strncpy(modmax,modul,MaxModulNamLen);
  201. //    if (NULL != (menumax[0] = (char *) calloc(sizeof(char),MaxMenuTitleLen)))
  202. //            strncpy(menumax[0],menu[0],MaxMenuTitleLen);
  203. //    for (i=1; i<= PktZahl; i++)
  204. //    {
  205. //        menumax[i] = (char *) calloc(sizeof(char),MaxMenuPointLen);
  206. //        if (NULL != menumax[i])
  207. //            strncpy(menumax[i],menu[i],MaxMenuPointLen);
  208. //        else
  209. //            error = 1;
  210. //    }
  211.     strncpy(menumax[0],menu[0],MaxMenuTitleLen);
  212.     for (i=1; i<= PktZahl; i++)
  213.         strncpy(menumax[i],menu[i],MaxMenuPointLen);
  214.     
  215.     length = (int) (long) strlen(modmax);
  216.     length += (int) (long) strlen(MenuTitle);
  217.     length += (int) (long) strlen(menu[0]);
  218.     strcpy(title,strcat(modmax, MenuTitle));
  219.     strcpy(title,strcat(title, menu[0]));
  220.     if(!error)
  221.     {   
  222.         space = MaxLineS - (int) strlen(title);
  223.         res = div(space,2);
  224.         space = res.quot;
  225.         GenOutClrScr(MaxLineCntS,menustring);
  226.         for (i=1; i<=space; i++)
  227.         {
  228.             if (!error)
  229.                 strcat(menustring," \0");
  230.         }
  231.         if (!error)
  232.             strcat(menustring,title);
  233.         if (!error)
  234.             strcat(menustring,"\n\0");
  235.         for (i=1; i<=space; i++)
  236.         {
  237.             if (!error)
  238.                 strcat(menustring," \0");
  239.         }
  240.         for (i=1; i<=(int)((long) strlen(title)); i++)
  241.         {
  242.             if (!error)
  243.                 strcat(menustring,"=\0"); 
  244.         }
  245.         if (!error)
  246.             strcat(menustring,"\n\0");
  247.         for(i=1; i<=PktZahl; i++)
  248.         {   
  249.             if (EOF == sprintf(helpstr,"\n  %2i.   %s", i, menumax[i])) 
  250.                 error =1;
  251.             if (!error)
  252.                 strcat(menustring,helpstr); 
  253.         }
  254.         if (!error)
  255.         {   
  256.             strcat(menustring,"\n\n   H.   Help...\0");
  257.             strcat(menustring,"\n   X.   eXit\0");
  258.             for (i=1; i<(MaxLineCntS - (PktZahl +8)); i++)
  259.                 strcat(menustring,"\n\0"); 
  260.         }
  261.         return(error ? EOF : 0);
  262.     }
  263. }
  264. #endif // ifdef modus_inter  
  265.  
  266. int GenOutLine(int outform,int outtype,int inlen,char outstr1[],char outstr2[],char *modul,char *mess,char *auxmess,char *defstr)
  267. {
  268.     int error = 0;
  269.     
  270.     error = ((outstr1 == (char *)NULL) || (outstr2 == (char *)NULL) || (modul == (char *)NULL) || (mess == (char *)NULL)
  271.              || (auxmess == (char *)NULL) || (defstr == (char *)NULL));
  272.     if (!error)
  273.     {
  274.         if (outform == 0) 
  275.             error = GenOutLine0(outtype,inlen,outstr1,mess,defstr);
  276.             else if ((outform == 1) || (outform == 3))
  277.                 error = GenOutLine2(outform,outtype,inlen,outstr1,outstr2,modul,mess,auxmess,defstr);
  278.                 else 
  279.                     error=1; 
  280.     }
  281.     return(error ? EOF : 0);       
  282. }
  283.  
  284.  
  285. int GenOutLine0(int outtype,int inlen,char outstr1[],char *mess, char *defstr)
  286. {
  287.     int error = 0,i = 0,defstrlen = 0;
  288.     
  289.     error = ((outstr1 == (char *)NULL) || (mess == (char *)NULL) || (defstr == (char *)NULL));
  290.     error = !(MaxMessLen >= (int) (long) strlen(mess));
  291.     error = !(MaxDefStrLen >= (defstrlen = (int) (long) strlen(defstr)));
  292.     if (!error)
  293.     {   
  294.         switch (outtype)
  295.         {
  296.             case 100:   
  297.             case 101:
  298.             case 102:
  299.             case 103:
  300.             case 104:
  301.                     {                       
  302.                         error = (EOF == sprintf(outstr1,"%s%s%s",ReqStr,mess,ReqTStr2));
  303.                         if (!error)
  304.                            {
  305.                             for (i=1;i<=(inlen - defstrlen);i++)
  306.                                 strcat(outstr1," \0");                          
  307.                             strcat(outstr1,defstr);
  308.                             strcat(outstr1,ReqTStr3);
  309.                             for (i=1;i<=(inlen+1);i++)
  310.                             strcat(outstr1,"\b");
  311.                             }                           
  312.                         break;
  313.                     }
  314.             case 105:
  315.                     {
  316.                         if (defstrlen == 0)
  317.                             error = (EOF == sprintf(outstr1,"%s%s%s",ReqStr,mess,ReqTStr1));
  318.                         else
  319.                             error = (EOF == sprintf(outstr1,"%s%s%s%s",ReqStr,mess,ReqTStr1,defstr));                       
  320.                         break;
  321.                     }
  322.  
  323.             case 200:
  324.             case 201:
  325.             case 202:
  326.                     {
  327.                         error = (EOF == sprintf(outstr1,"%s%s\n",InfStr,mess));
  328.                         break;
  329.                     }
  330.             case 300:
  331.             case 301:
  332.             case 302:
  333.             case 303:
  334.             case 304:
  335.             case 305:
  336.                     {
  337.                         error = (EOF == sprintf(outstr1,"%s%s\n",SnfStr,mess));
  338.                         break;
  339.                     }
  340.             case 400:
  341.             case 401:
  342.             case 402:
  343.             case 403:
  344.             case 404:
  345.             case 405:
  346.             case 406:
  347.                     {
  348.                         error = (EOF == sprintf(outstr1,"%s%s\n",WrnStr,mess));
  349.                         break;
  350.                     }
  351.             default:    
  352.                     {
  353.                         printf("\nUse Format LongScr/LongFile for Errors and Severe Errors!");
  354.                         printf("\nIf this doesn't apply to this call of GenOutLine0");
  355.                         printf("\nthen please check your arguments!");
  356.                         error= GenOutAcknowledge(ModusReturn);
  357.                         printf("\nProgramm exiting...");
  358.                         exit(1);                     
  359.                         break;
  360.                     }
  361.             }       
  362.     }
  363.     return(error);
  364. }           
  365.  
  366.  
  367. int GenOutLine2(int outform,int outtype,int inlen,char outstr1[],char outstr2[],char *modul,char *mess,char *auxmess,char *defstr)
  368. {
  369.     int error = 0,i = 0,defstrlen = 0;
  370. //    char *helpstr,*helpstr2;
  371.     char helpstr[MaxTimeDateLen],helpstr2[MaxErrMessLen];
  372.     struct tm *time_now;
  373.     time_t secs_now;
  374.     
  375.     error = ((outstr1 == (char *)NULL) || (outstr2 == (char *)NULL) || (modul == (char *)NULL) || (mess == (char *)NULL)
  376.              || (auxmess == (char *)NULL) || (defstr == (char *)NULL));
  377. //    error = (NULL == (helpstr = (char *) calloc(MaxTimeDateLen,sizeof(char))));
  378. //    error = (NULL == (helpstr2 = (char *) calloc(MaxTimeDateLen,sizeof(char))));
  379.     error = (NULL == (time_now = (struct tm *) malloc(sizeof(struct tm))));
  380.     error = !(MaxModulNamLen >= (int) (long) strlen(modul));
  381.     error = !(MaxMessLen >= (int) (long) strlen(mess));
  382.     error = !(MaxAuxMessLen >= (int) (long) strlen(auxmess));
  383.     error = !(MaxDefStrLen >= (defstrlen = (int) (long) strlen(defstr)));
  384. #ifdef ibm
  385.     tzset(); // DOS/UNIX-Kommando zum setzen der Zeit, auf Mac unnötig!!!
  386. #endif // ifdef ibm
  387.     time(&secs_now);
  388.     time_now = localtime(&secs_now);
  389.     error = (!strftime(helpstr, MaxTimeDateLen-1,"%d.%b.%y, %H:%M:%S",time_now));
  390.     if (!error)
  391.     {   
  392.         switch (outtype)
  393.         {
  394.             case 100:   
  395.             case 101:
  396.             case 102:
  397.             case 103:
  398.             case 104:
  399.                     {   
  400.                         error = GenCorStr(outtype,helpstr2); 
  401.                         if (!error)             
  402.                             error = (EOF == sprintf(outstr1,"%s<<%s / %s / %i>> %s",LotStr,modul,helpstr,outtype,helpstr2));
  403.                         if (!error && (outform == 1))
  404.                             strcat(outstr1,"\n\0"); 
  405.                         if (!error) 
  406.                             error = (EOF == sprintf(outstr2,"%s%s%s",ReqStr,mess,ReqTStr1));
  407.                         if (!error)
  408.                            {
  409.                             strcat(outstr2,ReqTStr2);
  410.                             for (i=1;i<=(inlen - defstrlen);i++)
  411.                                 strcat(outstr2," \0");                          
  412.                             strcat(outstr1,defstr);
  413.                             strcat(outstr2,ReqTStr3);
  414.                             for (i=1;i<=(inlen+1);i++)
  415.                                 strcat(outstr2,"\b");
  416.                             }                           
  417.                         break;
  418.                     }
  419.             case 105:
  420.                     {
  421.                         error = GenCorStr(outtype,helpstr2); 
  422.                         if (!error)             
  423.                             error = (EOF == sprintf(outstr1,"%s<<%s / %s / %i>> %s",LotStr,modul,helpstr,outtype,helpstr2));
  424.                         if (!error && (outform == 1))
  425.                             strcat(outstr1,"\n\0"); 
  426.                         if ((!error) && (defstrlen == 0))
  427.                             error = (EOF == sprintf(outstr2,"%s%s%s",ReqStr,mess,ReqTStr1));
  428.                         else if(!error)
  429.                             error = (EOF == sprintf(outstr2,"%s%s%s%s",ReqStr,mess,ReqTStr1,defstr));                       
  430.                         break;
  431.                     }
  432.  
  433.             case 200:
  434.             case 201:
  435.             case 202:
  436.             case 300:
  437.             case 301:
  438.             case 302:
  439.             case 303:
  440.             case 304:
  441.             case 305:
  442.             case 400:
  443.             case 401:
  444.             case 402:
  445.             case 403:
  446.             case 404:
  447.             case 405:
  448.             case 406:
  449.             case 500:
  450.             case 501:
  451.             case 502:
  452.             case 503:
  453.             case 504:
  454.             case 505:
  455.             case 506:
  456.             case 507:
  457.             case 508:
  458.             case 509:
  459.             case 510:
  460.             case 600:
  461.             case 601:
  462.             case 602:
  463.             case 603:
  464.             case 604:
  465.             case 605:
  466.             case 606:
  467.             case 607:
  468.             case 608:
  469.             case 609:
  470.             case 610:
  471.                     {
  472.                         error = GenCorStr(outtype,helpstr2); 
  473.                         if (!error)             
  474.                             error = (EOF == sprintf(outstr1,"%s<<%s / %s / %i>> %s",LotStr,modul,helpstr,outtype,helpstr2));
  475.                         if (!error && (outform == 1))
  476.                             strcat(outstr1,"\n\0"); 
  477.                         if (!error) 
  478.                             error = (EOF == sprintf(outstr2,"%s\n",mess));
  479.                         break;
  480.                     }
  481.             default:    
  482.                     {
  483.                         printf("\nUse Format LongScr/LongFile for Errors and Severe Errors!");
  484.                         printf("\nIf this doesn't apply to this call of GenOutLine0");
  485.                         printf("\nthen please check your arguments!");
  486.                         printf("\nProgramm exiting...");
  487.                         error= GenOutAcknowledge(ModusReturn);
  488.                         exit(1);                     
  489.                         break;
  490.                     }
  491.             }       
  492.     }
  493.     free(time_now);
  494.     return(error);
  495. }           
  496.  
  497. #ifdef modus_inter
  498. int GenInAnswer(int intype,int inlen, bsBoolean *inbool,char *inchar, char incharmax, int *inint, int inintmin, int inintmax, 
  499.                 char *instring, char *inhelpstr, char *inerrstring,char *headstring, char *promptstring)
  500.                                 // ATTENTION: INPUT IS RETURNED IN CASE UESR JUST HITS RETURN WHENEVER
  501.                                 // PRECEEDING REQUEST STRING SHOWS A DIFFERENT FROM NONE!!!
  502.                                 // THEREFORE: BEFORE CALLING THIS ROUTINE SET VALUES APPROPRIATELY!
  503. {
  504.     int helpint = 0,
  505.         error = 0,
  506.         i = 0;
  507.     char helpchar=' ',
  508.          helplong[MaxFullPathName+2],
  509.          *helpstring,
  510.          *occur;
  511.     bsBoolean answerok=bsFalse,
  512.               answerquit=bsFalse,
  513.               answerhelp=bsFalse,
  514.               answervoid=bsFalse; 
  515.     
  516.     error = ((inbool == (bsBoolean *)NULL) || (inchar == (char *)NULL) || (inint == (int *)NULL) || (instring == (char *)NULL) || 
  517.             (inhelpstr == (char *)NULL) || (inerrstring == (char *)NULL) || (headstring == (char *)NULL) || (promptstring == (char *)NULL));
  518.     error = (NULL == (helpstring = calloc(sizeof(char),inlen+1)));
  519.     error = (EOF == printf("%s", headstring));
  520.     error = (EOF == printf("%s", promptstring));
  521.     if (!error)
  522.     {
  523.         fflush(stdin);
  524.         switch(intype)
  525.         {
  526.             case AReq:  error = GenOutAcknowledge(ModusReturn);
  527.                         break;
  528.             case BReq:  helpchar = getchar();
  529.                         helpchar = (char) tolower((int)helpchar);
  530.                         if (helpchar == (NEWLINE))   
  531.                         {
  532.                               answerok = bsTrue;          // DEFAULT!!!
  533.                               answervoid = bsTrue;            
  534.                         }
  535.                         else if ((helpchar == KEYN) || (helpchar == KEYn) || (helpchar == KEYS) || (helpchar == KEYs))
  536.                         {
  537.                               *inbool = bsFalse;
  538.                               answerok = bsTrue;
  539.                         }
  540.                         else if ((helpchar == KEYY) || (helpchar == KEYy) || (helpchar == KEYJ) || (helpchar == KEYj) || (helpchar == KEYL) || (helpchar == KEYl))
  541.                         {
  542.                               *inbool = bsTrue;
  543.                               answerok = bsTrue;
  544.                         }
  545.                         else if ((helpchar == KEYH) || (helpchar == KEYh) || (helpchar == HELP))
  546.                         {
  547.                               printf("%s ",inhelpstr);
  548.                               GenOutAcknowledge(ModusNoRet);
  549.                               answerhelp = bsTrue;
  550.                               answerok = bsTrue;
  551.                         }
  552.                         else if ((helpchar == KEYq) || (helpchar == KEYQ) || (helpchar == HELP))
  553.                         {
  554.                               answerquit = bsTrue;
  555.                               answerok = bsTrue;
  556.                         }
  557.                         else
  558.                         {
  559.                               printf("%s ",inerrstring);
  560.                               GenOutAcknowledge(ModusNoRet);
  561.                         }
  562.                         break;
  563.             case MReq:  fgets(helplong,(inlen + 1),stdin);
  564.                         if (helplong[0] == NEWLINE)   
  565.                         {
  566.                             answerok = bsTrue;          // DEFAULT!!!
  567.                             answervoid = bsTrue;
  568.                         }
  569.                         else if ((char *)NULL != (occur = strpbrk((const char *)helplong,(const char *)"\n\0")))
  570.                             *occur = '\0';                      
  571.                         if(!answerok)
  572.                         {
  573.                             if ((helplong[0] == KEYH) || (helplong[0] == KEYh)) 
  574.                             {
  575.                                 *inchar = incharmax + 1;
  576.                                 answerhelp = bsTrue;
  577.                                 answerok = bsTrue;          
  578.                             }
  579.                             else if ((helplong[0] == KEYX) || (helplong[0] == KEYx)) 
  580.                                 {
  581.                                     *inchar = incharmax + 2;
  582.                                     answerok = bsTrue;          
  583.                                 }
  584.                                 else if ((helplong[0] == KEYQ) || (helplong[0] == KEYq)) 
  585.                                     {
  586.                                         answerquit = bsTrue;
  587.                                         answerok = bsTrue;          
  588.                                     }
  589.                                     else 
  590.                                     {
  591.                                         for (i=0;i<inlen;i++)
  592.                                             if (!isdigit(helplong[i]))
  593.                                                 error = 1;
  594.                                         if (!error)
  595.                                         {
  596.                                             sscanf(helplong,"%i",&helpint);
  597.                                             helpchar = (char) helpint;
  598.                                             if ((helpchar >= 1) && (helpchar <= incharmax))
  599.                                             {
  600.                                                 *inchar = helpchar;
  601.                                                 answerok = bsTrue;
  602.                                             }
  603.                                         }
  604.                                         else
  605.                                         {
  606.                                             printf("%s ",inerrstring);
  607.                                             GenOutAcknowledge(ModusNoRet);
  608.                                             
  609.                                         }   
  610.                                     }
  611.                             }
  612.                             helplong[0] = ' ';
  613.                         GenOutClrScr(MaxLineS,helplong);
  614.                         if  (EOF == printf("%s",helplong))
  615.                             GenExit(100);                 
  616.                         break;
  617.             case IReq:  fgets(helplong,(inlen + 1),stdin);
  618.                         if (helplong[0] == NEWLINE)   
  619.                         {
  620.                             answerok = bsTrue;          // DEFAULT!!!
  621.                             answervoid = bsTrue;
  622.                         }
  623.                         else if ((char *)NULL != (occur = strpbrk((const char *)helplong,(const char *)"\n\0")))
  624.                             *occur = '\0';                      
  625.                         if (!answerok)
  626.                         {
  627.                             if ((helplong[0] == KEYH) || (helplong[0] == KEYh)) 
  628.                             {
  629.                                 printf("%s ",inhelpstr);
  630.                                 GenOutAcknowledge(ModusNoRet);
  631.                                 answerhelp = bsTrue;
  632.                                 answerok = bsTrue;          
  633.                             }
  634.                             else if ((helplong[0] == KEYQ) || (helplong[0] == KEYq)) 
  635.                                 {
  636.                                     answerquit = bsTrue;
  637.                                     answerok = bsTrue;          
  638.                                 }
  639.                                 else 
  640.                                 {
  641.                                     for (i=0;i<inlen;i++)
  642.                                         if (!isdigit(helplong[i]))
  643.                                             error = 1;
  644.                                     if (!error)
  645.                                     {
  646.                                         sscanf(helplong,"%i",&helpint);
  647.                                         if ((helpint >= inintmin) && (helpint <= inintmax))
  648.                     {
  649.                                             helpchar = (char)helpint;
  650.                                             *inchar = helpchar;
  651.                                             answerok = bsTrue;
  652.                                         }
  653.                                     }
  654.                                     else
  655.                                     {
  656.                                         printf("%s ",inerrstring);
  657.                                         GenOutAcknowledge(ModusNoRet);  
  658.                                     }
  659.                                 }
  660.                         }                   
  661.                         break;
  662.             case RReq:  printf("NOT IMPLEMENTED, Program exiting...");
  663.                         error = GenOutAcknowledge(ModusNoRet);
  664.                         exit(0);
  665.                         break;
  666.             case SReq:  fgets(helplong,(inlen + 1),stdin);
  667.                         if (helplong[0] == NEWLINE)   
  668.                         {
  669.                             answerok = bsTrue;          // DEFAULT!!!
  670.                             answervoid = bsTrue;
  671.                         }
  672.                         else if ((char *)NULL != (occur = strpbrk((const char *)helplong,(const char *)"\n\0")))
  673.                             *occur = '\0';                      
  674.                         if (!answerok)
  675.                         {
  676.                             if (((helplong[0] == KEYH) || (helplong[0] == KEYh)) && (1 == (int) strlen(helplong)))
  677.                             {
  678.                                 printf("%s ",inhelpstr);
  679.                                 GenOutAcknowledge(ModusNoRet);
  680.                                 answerhelp = bsTrue;
  681.                                 answerok = bsTrue;          
  682.                             }
  683.                             else if ((helplong[0] == KEYQ) || (helplong[0] == KEYq)) 
  684.                                 {
  685.                                     answerquit = bsTrue;
  686.                                     answerok = bsTrue;          
  687.                                 }
  688.                                 else 
  689.                                 {
  690.                                     for (i=0;i<(int)strlen(helplong);i++)
  691.                                         if ((!isgraph(helplong[i]) && (!isspace(helplong[i]))))
  692.                                             error = 1;
  693.                                     if (!error)
  694.                                     {
  695.                                         helplong[inlen] = '\0';
  696.                                         // sscanf(helplong,"%s",helpstring);
  697.                                         // Dann können keine Blanks verwendet werden!!!
  698.                                         for (helpint = 0; *(helplong+helpint) !=0; helpint++)
  699.                                             *(helpstring+helpint) = *(helplong + helpint);
  700.                                         *(helpstring+helpint) = 0;
  701.                                         if (inlen >= (int) strlen(helpstring))  
  702.                                         {
  703.                                             for(i=0;(*(helpstring+i-1) != '\0');i++)
  704.                                                 *(instring+i) = *(helpstring+i);
  705.                                             answerok = bsTrue;
  706.                                         }
  707.                                     }
  708.                                     else
  709.                                     {
  710.                                         printf("%s ",inerrstring);
  711.                                         GenOutAcknowledge(ModusNoRet);
  712.                                         
  713.                                     }   
  714.                                 }
  715.                         }                   
  716.                         break;
  717.             default:    error=1;
  718.         
  719.         }   
  720.     }
  721.     free (helpstring);
  722.     if (error)
  723.         return INPUTER;
  724.     if (!answerok)
  725.         return INPUTIR;
  726.     if (answerquit)
  727.         return INPUTQI;
  728.     if (answervoid)
  729.         return INPUTVO;
  730.     if (answerhelp)
  731.         return INPUTHE;
  732.     else 
  733.         return INPUTOK;
  734.     
  735. }
  736. #endif // modus_inter
  737.  
  738. int GenCorStr(int type,char *str)
  739. {
  740.     int error = 0;
  741.     
  742.     error = ((char *)NULL == str);
  743.     if (!error)
  744.     {
  745.         switch (type)
  746.         {
  747.             case 100:   
  748.                         strncpy(str,BReqStr,((size_t) MaxErrMessLen));
  749.                         break;
  750.             case 101:   strncpy(str,MReqStr,((size_t) MaxErrMessLen));
  751.                         break;
  752.             case 102:   strncpy(str,IReqStr,((size_t) MaxErrMessLen));
  753.                         break;
  754.             case 103:   strncpy(str,RReqStr,((size_t) MaxErrMessLen));
  755.                         break;
  756.             case 104:   strncpy(str,SReqStr,((size_t) MaxErrMessLen));
  757.                         break;
  758.             
  759.             case 200:   strncpy(str,IInfStr,((size_t) MaxErrMessLen));
  760.                         break;
  761.             case 201:   strncpy(str,AInfStr,((size_t) MaxErrMessLen));
  762.                         break;
  763.             case 202:   strncpy(str,EInfStr,((size_t) MaxErrMessLen));
  764.                         break;
  765.             
  766.             case 300:   strncpy(str,CSnfStr,((size_t) MaxErrMessLen));
  767.                         break;
  768.             case 301:   strncpy(str,WSnfStr,((size_t) MaxErrMessLen));
  769.                         break;
  770.             case 302:   strncpy(str,ASnfStr,((size_t) MaxErrMessLen));
  771.                         break;
  772.             case 303:   strncpy(str,ESnfStr,((size_t) MaxErrMessLen));
  773.                         break;
  774.             case 304:   strncpy(str,SSnfStr,((size_t) MaxErrMessLen));
  775.                         break;
  776.             case 305:   strncpy(str,PSnfStr,((size_t) MaxErrMessLen));
  777.                         break;
  778.     
  779.             case 400:   strncpy(str,IWrnStr,((size_t) MaxErrMessLen));
  780.                         break;
  781.             case 401:   strncpy(str,DWrnStr,((size_t) MaxErrMessLen));
  782.                         break;
  783.             case 402:   strncpy(str,SWrnStr,((size_t) MaxErrMessLen));
  784.                         break;
  785.             case 403:   strncpy(str,AWrnStr,((size_t) MaxErrMessLen));
  786.                         break;
  787.             case 404:   strncpy(str,JWrnStr,((size_t) MaxErrMessLen));
  788.                         break;
  789.             case 405:   strncpy(str,BWrnStr,((size_t) MaxErrMessLen));
  790.                         break;
  791.             case 406:   strncpy(str,KWrnStr,((size_t) MaxErrMessLen));
  792.                         break;
  793.             
  794.             case 500:   strncpy(str,IErrStr,((size_t) MaxErrMessLen));
  795.                         break;
  796.             case 501:   strncpy(str,DErrStr,((size_t) MaxErrMessLen));
  797.                         break;
  798.             case 502:   strncpy(str,SErrStr,((size_t) MaxErrMessLen));
  799.                         break;
  800.             case 503:   strncpy(str,AErrStr,((size_t) MaxErrMessLen));
  801.                         break;
  802.             case 504:   strncpy(str,JErrStr,((size_t) MaxErrMessLen));
  803.                         break;
  804.             case 505:   strncpy(str,BErrStr,((size_t) MaxErrMessLen));
  805.                         break;
  806.             case 506:   strncpy(str,KErrStr,((size_t) MaxErrMessLen));
  807.                         break;
  808.             case 507:   strncpy(str,WErrStr,((size_t) MaxErrMessLen));
  809.                         break;
  810.             case 508:   strncpy(str,RErrStr,((size_t) MaxErrMessLen));
  811.                         break;
  812.             case 509:   strncpy(str,UErrStr,((size_t) MaxErrMessLen));
  813.                         break;
  814.             case 510:   strncpy(str,EErrStr,((size_t) MaxErrMessLen));
  815.                         break;
  816.             
  817.             case 600:   strncpy(str,ASrrStr,((size_t) MaxErrMessLen));
  818.                         break;
  819.             case 601:   strncpy(str,FSrrStr,((size_t) MaxErrMessLen));
  820.                         break;
  821.             case 602:   strncpy(str,NSrrStr,((size_t) MaxErrMessLen));
  822.                         break;
  823.             case 603:   strncpy(str,OSrrStr,((size_t) MaxErrMessLen));
  824.                         break;
  825.             case 604:   strncpy(str,QSrrStr,((size_t) MaxErrMessLen));
  826.                         break;
  827.             case 605:   strncpy(str,RSrrStr,((size_t) MaxErrMessLen));
  828.                         break;
  829.             case 606:   strncpy(str,WSrrStr,((size_t) MaxErrMessLen));
  830.                         break;
  831.             case 607:   strncpy(str,CSrrStr,((size_t) MaxErrMessLen));
  832.                         break;
  833.             case 608:   strncpy(str,DSrrStr,((size_t) MaxErrMessLen));
  834.                         break;
  835.             case 609:   strncpy(str,USrrStr,((size_t) MaxErrMessLen));
  836.                         break;
  837.             case 610:   strncpy(str,MSrrStr,((size_t) MaxErrMessLen));
  838.                         break;
  839.     
  840.             default:    error =1;
  841.          }
  842.     }
  843.     return(error);
  844. }
  845.  
  846.  
  847. int GenOutCentered(char *modul)     
  848. {   
  849.     int error = 0, i = 0, space = 0, length = 0;
  850.     char modmax[MaxModulNamLen],title[MaxMenuTitleLen];
  851.     div_t res;
  852.     
  853.     error = ((char *)NULL == modul);
  854.     if ( (long) strlen(modul) >= (long) MaxModulNamLen) error = 1;
  855.     if(!error)
  856.     {   
  857.         strncpy(modmax,modul,MaxModulNamLen);
  858.         length = (int) (long) strlen(modmax);
  859.         length += (int) (long) strlen(HelStr);
  860.         strcpy(title,strcat(modmax, HelStr));
  861.         space = MaxLineS - (int) strlen(title);
  862.         res = div(space,2);
  863.         space = res.quot;
  864.         for (i=1; i<=space; i++)
  865.             if (EOF == printf(" ")) error =1; 
  866.         if (EOF == printf("%s\n", title)) error =1;
  867.         for (i=1; i<=space; i++)
  868.             if (EOF == printf(" ")) error =1; 
  869.         for (i=1; i<=(int)((long) strlen(title)); i++)
  870.             if (EOF == printf("=")) error =1; 
  871.     }               
  872.     return(error);
  873. }
  874.  
  875.  
  876. int GenOutAcknowledge(int modus)
  877. {
  878.     int error =0;
  879.     
  880.     if (modus == ModusReturn)
  881.     {
  882.         if (EOF == printf("\n ----> hit RETURN to continue...\a")) 
  883.             error = 1;
  884.     }
  885.     else if (modus == ModusNoRet)
  886.         {
  887.             if (EOF == printf(" -> RETURN ...\a"))
  888.                  error = 1;
  889.         }
  890.         else error = 1;
  891.     if (!error)
  892.     {
  893.         if (EOF == fflush(stdin)) error = 1;
  894.         if (EOF == getchar()) error = 1;
  895.     }
  896.     return(error ? EOF : 0);
  897. }
  898.  
  899. #ifdef modus_inter
  900. int GenOutClrScr(int count,char *string)
  901. {
  902.     int i=0, j=0, error=0;
  903.     
  904.     j = bsintmin(MaxLineCntS, count);
  905.     if (string == (char *) NULL)
  906.     {
  907. //        if (MaxLineCntS == j)
  908.             if (EOF == printf("\f")) error = 1;
  909. //        else
  910.             for (i=1; i <= j; i++)
  911.                 if (EOF == printf("\n")) error = 1;
  912.         return(error ? EOF : 0);
  913.     }
  914.     else
  915.     {
  916. //        if (MaxLineCntS == j)
  917.             strcat(string,"\f\0");
  918. //        else
  919.             for (i=1; i <= j; i++)
  920.                 strcat(string,"\n\0");
  921.         return(error ? EOF : 0);
  922.     }
  923.  
  924. }
  925. #endif // modus_inter
  926.  
  927. void GenInName(char *str)
  928. {    
  929. #ifdef apple
  930.      int error = 0,len = 0;
  931.     char hlstr[MaxFileName+1];
  932.     
  933.     sprintf(hlstr,"%#s",CurApName);
  934.     strncpy(str,hlstr,MaxFileName);
  935. #endif // ifdef apple
  936. #ifdef ibm
  937.     strncpy(str,argv,MaxFileName);
  938. #endif // ifdef ibm
  939. #ifdef sun
  940.     strncpy(str,argv,MaxFileName);
  941. #endif // ifdef sun
  942. }
  943.  
  944. void GenExit(unsigned errno)
  945. {
  946. #ifdef apple
  947.     DSErrCode = (unsigned long) errno;
  948. #endif // ifdef apple
  949.     exit(errno);
  950. }
  951. #endif // ifndef bsioc