home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1991 / 04 / txl / 1_preis / kubasic.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-02  |  57.9 KB  |  2,552 lines
  1. /************************************************************************
  2. *                .......................................                *
  3. *                .                                     .                *
  4. *                .       TOOLBOX - INTERPRETER         .                *
  5. *                . TESTPROGRAMM FÜR WINDOWS-FUNKTIONEN .                *
  6. *                .             KUBASIC.C               .                *
  7. *                .    M.Beising & K.Bauer & TOOLBOX    .                *
  8. *                .......................................                *
  9. *************************************************************************/
  10.  
  11. #include <windows.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include <ctype.h>
  16. #include <math.h>
  17. #include "kubasic.h"
  18.  
  19.  
  20. extern PTNODE CreateTree(char Fktzeile[],int *ErrorPos,int *ErrorNr);
  21. extern void DelTree(PTNODE *ptnode);
  22. extern double Calc(PTNODE *ptnode);
  23. extern float random();
  24. extern void LiesDaten(void);
  25. extern void SaveDaten(void);
  26.  
  27. extern BOOL FAR PASCAL TypeHelp(HWND, unsigned, WORD, LONG);
  28. extern BOOL FAR PASCAL SetTextBox(HWND, unsigned, WORD, LONG);
  29. extern BOOL FAR PASCAL HelpBox(HWND, unsigned, WORD, LONG);
  30. extern BOOL FAR PASCAL Input(HWND, unsigned, WORD, LONG);
  31. extern BOOL FAR PASCAL About(HWND, unsigned, WORD, LONG);
  32. extern HANDLE FAR PASCAL OpenDlg(HWND, unsigned, WORD, LONG);
  33. extern void menuecommand(HWND hWnd,WORD wParam);
  34. extern void writeclipbrd(HWND hWnd,char *writestr);
  35.  
  36. PRGZEILE *FirstLine,*ActLine,NewLine,*LastLine,*WaitLine=NULL;
  37. DWORD  dwTextlen,TOSCROLL;
  38. OFSTRUCT fileInfo;
  39. TEXTMETRIC tm;
  40. FORARRAY forcalc[FORWHILETIEFE];
  41.  
  42. unsigned char Leerstring[81]= ">                                                                               ";
  43. unsigned char Textstr[ZEILENLAENGE]= "?";
  44. unsigned char Questr[ZEILENLAENGE];
  45. unsigned char PrintBuf[ZEILENLAENGE];
  46. LPSTR Ersetzstr=NULL;
  47.  
  48.  
  49. char FileName[FNAMLEN];
  50. char ReadBuffer[ZEILENLAENGE];
  51. char Charakter,*LinePos;
  52. char IntegerZahl[25];
  53. char szAppName[10];
  54. char szAbout[10];
  55. char szMessage[30];
  56. char *LinePos,ScanBuffer[ZEILENLAENGE];
  57. VAR  *FirstVar = NULL;
  58. VAR  Variable;
  59. RECT rect;
  60. HFONT oldFont,newFont;
  61. HPEN hOldPen,hWeissPen,hBlackPen,hBlauPen,hGruenPen,hTurkisPen;
  62. HPEN FARBPEN,hRedPen,hGrauPen,hViolettPen,hGelbPen;
  63. HBITMAP hBitmap,hOldBitmap;
  64. HANDLE hInst,hEditText;
  65. FARPROC lpProcTextBox,lpprocAbout,lpProcTemp,lpOpenDlg;
  66. HWND hWndglob,hWndEdit;
  67. HDC hPrnDC;
  68. LOGFONT mF;
  69.  
  70. HBRUSH hOldBrush,hBlackBrush,hBlauBrush,hGruenBrush,hTurkisBrush,hRedBrush;
  71. HBRUSH FARBBRUSH,hGrauBrush,hWeissBrush,hViolettBrush,hGelbBrush;
  72. POINT pt;
  73.  
  74. BOOL RUNBREAK=FALSE,LoadFile=FALSE,bText=FALSE,PrMsgBox=FALSE,Mono = FALSE;
  75. BOOL locate=FALSE,Edit=FALSE,TreeError=FALSE,IntError=TRUE,NeedNext;
  76. BOOL bCaret=FALSE,Anfang=TRUE,FontChange=FALSE,Drucker=FALSE,Mehr=FALSE;
  77.  
  78. int Brush=0,MessageLength,Steuer,Zeile=0,GetNextLine;
  79. int Backgrd=15,AktPos,ErrTyp,ErrPos,ErrNr,XW1,XW2,XW3,XW4,YW1,YW2,YW3,YW4;
  80. int charcnt=0,TXW1=0,TYW1=8,TXW2=8,TYW2=500,TXW3=0,TXW4=0,TYW3=0;
  81. int TORIENT=0,TESCP=0,TOutP=0,TCliP=0,TQual=0,TFam=10,oem=255,Pen=0;
  82. int icnt,ini,ForCnt=0,TextCol=-1,wX=10,wY=10,wW=620,wH=250,x=0,fio,Readcnt=0;
  83. unsigned int slen;
  84. WORD  what;
  85. DWORD FLOODFARBE,GRAU,GELB,TURKIS,ROT,GRUEN,VIOLETT,BLACK,WEISS,BLAU;
  86.  
  87.  
  88. char *MFONT[]= { "System","Terminal",
  89.          "Helvetica","Courier",
  90.          "Tms Rmn","Roman",
  91.          "Script","Modern" };
  92.  
  93. TOKBEF  TokBefDesc[] = {
  94.     { cinput,       "input"     ,       1,           1},
  95.     { cwtitle,      "titlewindow",      1,           1},
  96.     { crectangle,   "rectangle" ,       1,           1},
  97.     { clineto,      "line"      ,       1,           1},
  98.     { cellipse,     "ellipse"   ,       1,           1},
  99.     { croundrect,   "roundrect" ,       1,           1},
  100.     { carc,         "arc"       ,       1,           1},
  101.     { csetpxl,      "setpixel"  ,       1,           1},
  102.     { cmove,        "movewindow",       1,           1},
  103.     { cpie,         "pie"       ,       1,           1},
  104.     { csetprint,    "setprinter",       0,           0},
  105.     { cneu,         "neu"       ,       0,           0},
  106.     { ccls,         "cls"       ,       0,           0},
  107.     { crun,         "run"       ,       0,           0},
  108.     { cdruck,       "print"     ,       0,           1},
  109.     { cneu,         "new"       ,       0,           0},
  110.     { cif,          "if"        ,       2,           1},
  111.     { cload,        "load"      ,       1,           1},
  112.     { csave,        "save"      ,       1,           1},
  113.     { cgoto,        "goto"      ,       1,           0},
  114.     { cende,        "end"       ,       0,           0},
  115.     { cexit,        "system"    ,       0,           0},
  116.     { cmerke,       "rem"       ,       0,           1},
  117.     { clist,        "list"      ,       0,           1},
  118.     { cset,         "let"       ,       3,           1},
  119.     { cscreen,      "setscreen" ,       0,           0},
  120.     { ctexttype,    "typeset"   ,       1,           1},
  121.     { cllist,       "llist"     ,       1,           1},
  122.     { clocate,      "locate"    ,       1,           1},
  123.     { cpolyline,    "polyline"  ,       1,           1},
  124.     { cflodfil,     "floodfill"  ,      1,           1},
  125.     { ctextcol,     "settextcolor",     1,           1},
  126.     { cbackgrd,     "setbkcolor",       1,           1},
  127.     { ccolor,       "setcolor"  ,       1,           1},
  128.     { cpencolor,    "setpencolor",      1,           1},
  129.     { messagebox,   "msgbox"    ,       1,           1},
  130.     { cviereck,     "viereck"   ,       1,           1},
  131.     { crectline,    "rectline"  ,       1,           1},
  132.     { cinline,      "inline"    ,       1,           1},
  133.     { cfor,         "for"       ,       1,           1},
  134.     { cnext,        "next"      ,       1,           1},
  135.     { cwhile,       "while"     ,       1,           1},
  136.     { cwend,        "wend"      ,       1,           1},
  137.     { ccursor,      "cursor"    ,       1,           1},
  138.     { crunb,        "runb"      ,       0,           0},
  139.     { NULL,         NULL        ,       0,           0}
  140.  
  141. };
  142.  
  143. BOOL kubasicInit( hInstance )
  144. HANDLE hInstance;
  145. {
  146.     PWNDCLASS   pkubasicClass;
  147.     LoadString( hInstance, IDSNAME, (LPSTR)szAppName, 10 );
  148.     LoadString( hInstance, IDSABOUT, (LPSTR)szAbout, 10 );
  149.     MessageLength = LoadString( hInstance, IDSTITLE, (LPSTR)szMessage,20 );
  150.  
  151.     pkubasicClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );
  152.     pkubasicClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
  153.     pkubasicClass->hIcon          = LoadIcon( hInstance, MAKEINTRESOURCE(KUBASICON) );
  154.     pkubasicClass->lpszMenuName   = (LPSTR)NULL;
  155.     pkubasicClass->lpszClassName  = (LPSTR)szAppName;
  156.     pkubasicClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
  157.     pkubasicClass->hInstance      = hInstance;
  158.     pkubasicClass->style          = CS_HREDRAW | CS_VREDRAW;
  159.     pkubasicClass->lpfnWndProc    = kubasicWndProc;
  160.  
  161.     pkubasicClass->cbClsExtra      = 0;
  162.     pkubasicClass->cbWndExtra      = 0;
  163.  
  164.     if (!RegisterClass( (LPWNDCLASS)pkubasicClass ) )
  165.      return FALSE;
  166.     LocalFree( (HANDLE)pkubasicClass );
  167.     return TRUE;
  168. }
  169.  
  170.  
  171. int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
  172. HANDLE hInstance, hPrevInstance;
  173. LPSTR lpszCmdLine;
  174. int cmdShow;
  175. {
  176.     MSG   msg;
  177.     HWND  hWnd;
  178.     HMENU hMenu;
  179.     HANDLE hAccelTable;
  180.  
  181.    if (!hPrevInstance) {
  182.     if (!kubasicInit( hInstance ))
  183.             return FALSE;
  184.         }
  185.     else {
  186.         GetInstanceData( hPrevInstance, (PSTR)szAppName, 10 );
  187.         GetInstanceData( hPrevInstance, (PSTR)szAbout, 10 );
  188.     GetInstanceData( hPrevInstance, (PSTR)szMessage, 20 );
  189.         GetInstanceData( hPrevInstance, (PSTR)&MessageLength, sizeof(int) );
  190.     }
  191.     hInst = hInstance;
  192.     hWnd = CreateWindow((LPSTR)szAppName,
  193.                         (LPSTR)szMessage,
  194.             WS_OVERLAPPEDWINDOW |WS_CLIPCHILDREN,
  195.             wX,
  196.             wY,
  197.             wW,
  198.             wH,
  199.             (HWND)NULL,
  200.             (HMENU) LoadMenu(hInstance,(PSTR)"theMenu"),
  201.             (HANDLE)hInstance,
  202.             (LPSTR)NULL
  203.                         );
  204.     hWndglob=hWnd;
  205.     ShowWindow( hWnd, cmdShow );
  206.     GetClientRect(hWnd,(LPRECT)&rect);
  207.     hWndEdit = CreateWindow((LPSTR)"Edit",
  208.             (LPSTR)NULL,
  209.             WS_CHILD | ES_MULTILINE | ES_AUTOVSCROLL |
  210.             ES_AUTOHSCROLL | WS_VSCROLL | WS_HSCROLL,
  211.             0,
  212.             0,
  213.             rect.right,
  214.             rect.bottom,
  215.             (HWND)hWnd,
  216.             (HMENU)NULL,
  217.             (HANDLE)hInstance,
  218.             (LPSTR)NULL
  219.             );
  220.     lpprocAbout = MakeProcInstance( (FARPROC)About, hInstance );
  221.     hMenu = GetSystemMenu(hWnd, FALSE);
  222.     ChangeMenu(hMenu, 0, NULL, 999, MF_APPEND | MF_SEPARATOR);
  223.     ChangeMenu(hMenu, 0, (LPSTR)szAbout, IDSABOUT, MF_APPEND | MF_STRING);
  224.     UpdateWindow( hWnd );
  225.     SetFocus(hWnd);
  226.  
  227.     hAccelTable = LoadAccelerators( hInst, (LPSTR)"theAcc");
  228.     /* while (GetMessage(&msg,NULL,NULL,NULL)) */
  229.  
  230.     while (TRUE)
  231.      {
  232.       if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
  233.       {
  234.        if(msg.message==WM_QUIT)
  235.      break;
  236.        if (TranslateAccelerator(hWnd, hAccelTable, (LPMSG) &msg) ==0 )
  237.     {
  238.      TranslateMessage(&msg);
  239.      DispatchMessage(&msg);
  240.     }
  241.       } else
  242.           if(RUNBREAK)
  243.          {
  244.            if(WaitLine==NULL)
  245.          {
  246.           ActLine = FirstLine;
  247.           HideCaret(hWndglob);
  248.           ForCnt=0;
  249.          }
  250.          else
  251.            ActLine = WaitLine;
  252.              DoProgram ();
  253.          }
  254.      }
  255.        return msg.wParam;
  256. }
  257.  
  258.  
  259. long FAR PASCAL kubasicWndProc( hWnd, message, wParam, lParam )
  260. HWND hWnd;
  261. unsigned message;
  262. WORD wParam;
  263. LONG lParam;
  264. {
  265.     HDC hDC;
  266.     PAINTSTRUCT ps;
  267.     HANDLE hmenu;
  268.     WORD wFormat;
  269.     hmenu = GetMenu(hWnd);
  270.     switch (message)
  271.     {
  272.  
  273.     case WM_KEYDOWN:
  274.            if(Anfang)
  275.               {
  276.              ccls();
  277.              PRINTF(">");
  278.              x=tm.tmMaxCharWidth+6;
  279.              Zeile=0;
  280.              Anfang=FALSE;
  281.               }
  282.             break;
  283.  
  284.     case WM_CHAR:
  285.          if(Edit) break;
  286.  
  287.          if(RUNBREAK && wParam==0x1b)
  288.         {
  289.          RUNBREAK=FALSE;
  290.          WaitLine=NULL;
  291.          break;
  292.         } else if(RUNBREAK) break;
  293.  
  294.        switch(wParam)
  295.           {
  296.           case '\r':  if(!Readcnt) break;
  297.                ResetError();
  298.                ForCnt=0;
  299.                *NewLine.Zeile='\0';
  300.                InterAct ();
  301.                memset(ReadBuffer,'\0',255);
  302.                PRINTF(">");
  303.                x=tm.tmMaxCharWidth+6;
  304.                Readcnt=0;
  305.              break;
  306.           case '\b':
  307.              if(!Readcnt)
  308.             {
  309.               Readcnt=0;
  310.               ReadBuffer[0]='>';
  311.               MessageBeep(0xf000);
  312.             }
  313.              else
  314.                 ReadBuffer[--Readcnt]='\0';
  315.  
  316.           default: if(wParam >= ' ' && Readcnt<255)
  317.              ReadBuffer[Readcnt++] = wParam;
  318.              x=(ReadBuffer[0]!= '>' ? (tm.tmMaxCharWidth+6):0);
  319.              Zeile-=(tm.tmHeight+2);
  320.              if(Zeile<0)Zeile=0;
  321.              PRINTF(ReadBuffer);
  322.                break;
  323.           }
  324.           break;
  325.     case WM_CREATE :
  326.      BLACK=RGB(0,0,0);
  327.      BLAU=RGB(0,0,255);
  328.      GRUEN=RGB(0,255,0);
  329.      TURKIS=RGB(0,255,255);
  330.      ROT=RGB(255,0,0);
  331.      VIOLETT=RGB(255,0,255);
  332.      GELB=RGB(255,255,0);
  333.      WEISS=RGB(255,255,255);
  334.      GRAU=RGB(128,128,128);
  335.      hGrauBrush=CreateSolidBrush(GRAU);
  336.      hWeissBrush=CreateSolidBrush(WEISS);
  337.      hBlackBrush=CreateSolidBrush(BLACK);
  338.      hBlauBrush=CreateSolidBrush(BLAU);
  339.      hGruenBrush=CreateSolidBrush(GRUEN);
  340.      hTurkisBrush=CreateSolidBrush(TURKIS);
  341.      hRedBrush=CreateSolidBrush(ROT);
  342.      hViolettBrush=CreateSolidBrush(VIOLETT);
  343.      hGelbBrush=CreateSolidBrush(GELB);
  344.      hGrauPen=CreatePen(0,1,GRAU);
  345.      hWeissPen=CreatePen(0,1,WEISS);
  346.      hBlackPen=CreatePen(0,1,BLACK);
  347.      hBlauPen=CreatePen(0,1,BLAU);
  348.      hGruenPen=CreatePen(0,1,GRUEN);
  349.      hTurkisPen=CreatePen(0,1,TURKIS);
  350.      hRedPen=CreatePen(0,1,ROT);
  351.      hViolettPen=CreatePen(0,1,VIOLETT);
  352.      hGelbPen=CreatePen(0,1,GELB);
  353.      FirstLine=NULL;
  354.      ActLine=NULL;
  355.      FirstVar=NULL;
  356.      SetFileName ("work.txl");
  357.      break;
  358.     case WM_SIZE :
  359.       GetClientRect(hWnd,(LPRECT)&rect);
  360.       MoveWindow(hWndEdit,0,0,LOWORD(lParam),HIWORD(lParam),TRUE);
  361.       Zeile = 0;
  362.       return DefWindowProc( hWnd, message, wParam, lParam );
  363.      break;
  364.     case WM_INITMENU:
  365. if (wParam == hmenu)
  366.  {
  367.  
  368.        (Mono) ? CheckMenuItem(hmenu,MN_MONO,MF_CHECKED) :
  369.         CheckMenuItem(hmenu,MN_MONO,MF_UNCHECKED);
  370.        (TXW4) ? CheckMenuItem(hmenu,MN_KURSIV,MF_CHECKED) :
  371.         CheckMenuItem(hmenu,MN_KURSIV,MF_UNCHECKED);
  372.        (TXW3) ? CheckMenuItem(hmenu,MN_UNTERS,MF_CHECKED) :
  373.         CheckMenuItem(hmenu,MN_UNTERS,MF_UNCHECKED);
  374.        (TYW3) ? CheckMenuItem(hmenu,MN_DURCHG,MF_CHECKED) :
  375.         CheckMenuItem(hmenu,MN_DURCHG,MF_UNCHECKED);
  376.    for (ini = 0;ini<8;ini++)
  377.       (TXW1==ini) ? CheckMenuItem(hmenu,(ini+126),MF_CHECKED) :
  378.             CheckMenuItem(hmenu,(ini+126),MF_UNCHECKED);
  379.       CheckMenuItem(hmenu,MW_NORMAL,MF_UNCHECKED);
  380.       CheckMenuItem(hmenu,MW_HEAVY,MF_UNCHECKED);
  381.      if(TYW2==500)
  382.       CheckMenuItem(hmenu,MW_NORMAL,MF_CHECKED);
  383.      if(TYW2==600)
  384.       CheckMenuItem(hmenu,MW_HEAVY,MF_CHECKED);
  385.    for (ini = 8;ini<55;ini++)
  386.       switch(ini)
  387.         {
  388.          case 9:
  389.          case 11:
  390.          case 17:
  391.          case 23:
  392.          case 25:
  393.          case 31:
  394.          case 33:
  395.          case 34:
  396.          case 41:
  397.          case 43:
  398.          case 46:
  399.          case 47:
  400.          case 49:
  401.          case 51:
  402.          case 53:
  403.          case 55:
  404.               break;
  405.         default:
  406.       (TXW2==ini) ? CheckMenuItem(hmenu,(ini),MF_CHECKED) :
  407.             CheckMenuItem(hmenu,(ini),MF_UNCHECKED);
  408.               break;
  409.         }
  410.  
  411.     OpenClipboard(hWnd);
  412.     wFormat = 0;
  413.     while ((wFormat = EnumClipboardFormats(wFormat)) != 0 && wFormat != CF_TEXT);
  414.     (wFormat == CF_TEXT ? (EnableMenuItem(hmenu,MN_PASTE,MF_ENABLED)):
  415.               (EnableMenuItem(hmenu,MN_PASTE,MF_GRAYED)));
  416.      CloseClipboard();
  417.  
  418. if(Edit)
  419.   {
  420.      for(icnt=MN_UNDO;icnt<=MN_WERSETZE;icnt++)
  421.      EnableMenuItem(hmenu,(WORD)icnt,MF_ENABLED);
  422.      for(icnt=MN_EDITOR;icnt<=MN_RUN;icnt++)
  423.      EnableMenuItem(hmenu,(WORD)icnt,MF_GRAYED);
  424.   }
  425.   else
  426.    {
  427.      for(icnt=MN_UNDO;icnt<=MN_WERSETZE;icnt++)
  428.      EnableMenuItem(hmenu,(WORD)icnt,MF_GRAYED);
  429.      for(icnt=MN_EDITOR;icnt<=MN_RUN;icnt++)
  430.      EnableMenuItem(hmenu,(WORD)icnt,MF_ENABLED);
  431.    }
  432.  
  433.     (Drucker ? (EnableMenuItem(hmenu,MN_SCREEN,MF_ENABLED)):
  434.            (EnableMenuItem(hmenu,MN_SCREEN,MF_GRAYED)));
  435. }
  436.         break;
  437.  
  438.     case WM_COMMAND:
  439.      menuecommand(hWnd,wParam);
  440.         break;
  441.     case WM_SYSCOMMAND:
  442.         switch (wParam)
  443.         {
  444.         case IDSABOUT:
  445.             DialogBox( hInst, MAKEINTRESOURCE(ABOUTBOX), hWnd, lpprocAbout );
  446.             break;
  447.         default:
  448.             return DefWindowProc( hWnd, message, wParam, lParam );
  449.         }
  450.         break;
  451.     case WM_DESTROY:
  452.      cscreen();
  453.      cneu();
  454.      DeleteObject(hBlackBrush);
  455.      DeleteObject(hBlauBrush);
  456.      DeleteObject(hGruenBrush);
  457.      DeleteObject(hTurkisBrush);
  458.      DeleteObject(hRedBrush);
  459.      DeleteObject(hViolettBrush);
  460.      DeleteObject(hGelbBrush);
  461.      DeleteObject(hWeissBrush);
  462.      DeleteObject(hGrauBrush);
  463.  
  464.      DeleteObject(hBlackPen);
  465.      DeleteObject(hBlauPen);
  466.      DeleteObject(hGruenPen);
  467.      DeleteObject(hTurkisPen);
  468.      DeleteObject(hRedPen);
  469.      DeleteObject(hViolettPen);
  470.      DeleteObject(hGelbPen);
  471.      DeleteObject(hWeissPen);
  472.      DeleteObject(hGrauPen);
  473.      if(bCaret)
  474.        DestroyCaret();
  475.      PostQuitMessage( 0 );
  476.         break;
  477.  
  478.   case WM_PAINT: if(Drucker) break;
  479.  
  480.     BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
  481.       Zeile=0;
  482.     if(Anfang)
  483.           {
  484.         KuBaBitmap(hWnd,ps.hdc);
  485.         GetTextMetrics(ps.hdc,(LPTEXTMETRIC)&tm);
  486.         CreateCaret(hWnd,1,tm.tmAveCharWidth,tm.tmHeight);
  487.         bCaret=TRUE;
  488.         ShowCaret(hWnd);
  489.           }
  490.     EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
  491.        if(!Edit) {
  492.                x=0;
  493.                Zeile=0;
  494.                PRINTF(">");
  495.                Zeile-=(tm.tmHeight+2);
  496.               }
  497.     break;
  498.     case WM_SETFOCUS:
  499.     if(!Edit)
  500.       ErzeugeCursor(hWnd);
  501.        else SetFocus(hWndEdit);
  502.     break;
  503.     case WM_KILLFOCUS:
  504.      if(bCaret)
  505.          {
  506.           DestroyCaret();
  507.           bCaret=FALSE;
  508.          }
  509.     default:
  510.     return DefWindowProc( hWnd, message, wParam, lParam );
  511.         break;
  512.     }
  513.     return(0L);
  514. }
  515.  
  516. void KuBaBitmap(HWND hWnd,HDC hDC)
  517. {
  518.   HDC hcDC;
  519.       hBitmap = LoadBitmap(hInst,(LPSTR)"toolbox");
  520.       hcDC    = CreateCompatibleDC(hDC);
  521.  
  522.       hOldBitmap = SelectObject(hcDC,hBitmap);
  523.       SetStretchBltMode(hDC,WHITEONBLACK);
  524.       SetTextColor(hDC,GELB);
  525.       SetBkColor(hDC,ROT);
  526.       StretchBlt(hDC,100,10,72,72,hcDC,0,0,72,72,SRCCOPY);
  527.       SetTextColor(hDC,GRUEN);
  528.       SetBkColor(hDC,BLAU);
  529.       StretchBlt(hDC,200,55,72,72,hcDC,0,0,72,72,SRCCOPY);
  530.       SetTextColor(hDC,VIOLETT);
  531.       SetBkColor(hDC,GELB);
  532.       StretchBlt(hDC,300,100,72,72,hcDC,0,0,72,72,SRCCOPY);
  533.  
  534.       DeleteObject(SelectObject(hcDC,hOldBitmap));
  535.       DeleteDC(hcDC);
  536. }
  537.  
  538. void InterAct ()
  539. {
  540.     char Ausgabe[30];
  541.     LinePos = ReadBuffer;
  542.     SkipChar ();
  543.     Scan ();
  544.  
  545.     if (Steuer == ZIFFER) {
  546.       NewLine.LineNumber = atoi (ScanBuffer);
  547.       ActLine = 
  548.       if (MakeToken () == OK)
  549.       InsIntLine ();
  550.       else {
  551.         sprintf (Ausgabe,"%s %03d %s ","# Zeile",
  552.                NewLine.LineNumber,"ist gel÷scht! #");
  553.  
  554.            PRINTF (Ausgabe);
  555.         DelLine (NewLine.LineNumber);
  556.       }
  557.     }
  558.     else {
  559.       ActLine = 
  560.       SkipChar ();
  561.       LinePos = ReadBuffer;
  562.       if (MakeToken () == OK) {
  563.     LinePos = ActLine->Zeile;
  564.     InterpLine ();
  565.       }
  566.       else {
  567.     sprintf (ReadBuffer,"# Befehl <%s> unbekannt #",ScanBuffer);
  568.     serror (ReadBuffer);
  569.       }
  570.     }
  571. }
  572.  
  573. int InterpLine ()
  574. {
  575. int i,error;
  576.  i = 0xff & *LinePos;
  577.   if ((i >= TOKMIN) && (i <= TOKMAX)) {
  578.     LinePos++;
  579.     SkipChar ();
  580.     error = TokBefDesc[i-TOKMIN].function ();
  581.   }
  582.   else {
  583.     serror ("# Unbekannter Befehl! #");
  584.     error = FALSE;
  585.   }
  586. return (error);
  587. }
  588.  
  589. int DoProgram ()
  590. {
  591. int error = TRUE;
  592.  if(!RUNBREAK)
  593.   {
  594.    SetCursor(LoadCursor(NULL,IDC_WAIT));
  595.    SetCursorPos(100,30);
  596.    ForCnt=0;
  597.   }
  598.   while (ActLine && error && !TreeError)
  599.    {
  600.     LinePos = ActLine->Zeile;
  601.     GetNextLine = TRUE;
  602.     error = InterpLine ();
  603.     if (GetNextLine)
  604.       ActLine = ActLine->NextZeile;
  605.        WaitLine = ActLine;
  606.       if (IntError || RUNBREAK)
  607.      break;
  608.     }
  609.     if(!RUNBREAK)
  610.       SetCursor(LoadCursor(NULL,IDC_ARROW));
  611.      if(!ActLine) RUNBREAK=FALSE;
  612. return (error);
  613. }
  614.  
  615. int MakeToken ()
  616. {
  617. int     i,j;
  618. int     LineSym;
  619. char    *TokLine;
  620.   TokLine = ActLine->Zeile;
  621.   if (Scan () == UNEOL)
  622.      return (ERROR_1);
  623.   if (TestBefehl(&i) == 0) {
  624.     *TokLine++ = i + TOKMIN;
  625.     *TokLine = '\0';
  626.     if (TokBefDesc[i].CopyRest) {
  627.       strcat (TokLine,LinePos);
  628.       return (OK);
  629.     }
  630.     else
  631.       for (LineSym = TokBefDesc[i].ParaCount;
  632.        LineSym ; LineSym--) {
  633.       if (Scan () == SCANOK)
  634.     if (TestBefehl(&i) == 0) {
  635.       *TokLine++ = i + TOKMIN;
  636.       *TokLine = '\0';
  637.     }
  638.     else {
  639.       strcat (TokLine,ScanBuffer);
  640.       TokLine = strchr (TokLine,'\0');
  641.     }
  642.       else
  643.     return (ERROR_1);
  644.     }
  645.   }
  646.   else
  647.     return (ERROR_1);
  648. return (OK);
  649. }
  650.  
  651. int TestBefehl (int *Befehl)
  652. {
  653. int i,j;
  654.  
  655.   for (i = 0;
  656.        (TokBefDesc[i].function != NULL) &&
  657.        ((j = strcmp(TokBefDesc[i].Befehl,ScanBuffer)) != 0)
  658.        ; i++) {
  659.     }
  660.   *Befehl = i;
  661. return (j);
  662. }
  663.  
  664. void InsIntLine ()
  665. {
  666. PRGZEILE        *NewLine;
  667. PRGZEILE        *InsZeile;
  668.  
  669.       NewLine = (PRGZEILE NEAR *)LocalAlloc (LPTR,sizeof(PRGZEILE));
  670.     if (NewLine == NULL) {
  671.         PRINTF ("#### Kein Speicherplatz mehr vorhanden! ####");
  672.       return;
  673.     }
  674.  
  675.     if (!FirstLine) {
  676.       FirstLine = NewLine;
  677.       NewLine->LineNumber = ActLine->LineNumber;
  678.       strcpy (NewLine->Zeile,ActLine->Zeile);
  679.       NewLine->NextZeile = NULL;
  680.       NewLine->PrevZeile = NULL;
  681.       return;
  682.     }
  683.  
  684.     if (FindInsPos(ActLine->LineNumber,&InsZeile)) {
  685.         strcpy (InsZeile->Zeile,ActLine->Zeile);
  686.         LocalFree ((LOCALHANDLE)NewLine);
  687.     }
  688.     else {
  689.         NewLine->LineNumber = ActLine->LineNumber;
  690.         strcpy (NewLine->Zeile,ActLine->Zeile);
  691.         if ((InsZeile == FirstLine) &&
  692.             (InsZeile->LineNumber < NewLine->LineNumber)) {
  693.           NewLine->NextZeile = NULL;
  694.           NewLine->PrevZeile = InsZeile;
  695.           InsZeile->NextZeile = NewLine;
  696.           return;
  697.         }
  698.  
  699.         if (InsZeile->NextZeile) {
  700.           NewLine->NextZeile  = InsZeile;
  701.           NewLine->PrevZeile  = InsZeile->PrevZeile;
  702.  
  703.           if (InsZeile->PrevZeile)
  704.             InsZeile->PrevZeile->NextZeile = NewLine;
  705.           else
  706.             FirstLine = NewLine;
  707.           InsZeile->PrevZeile = NewLine;
  708.         }
  709.         else {
  710.           NewLine->NextZeile = NULL;
  711.           NewLine->PrevZeile = InsZeile;
  712.           InsZeile->NextZeile = NewLine;
  713.         }
  714.     }
  715. }
  716.  
  717. int FindInsPos (LineNumber,InsPos)
  718. int             LineNumber;
  719. PRGZEILE        **InsPos;
  720. {
  721. PRGZEILE        *FindZeile,*LastLine;
  722.  
  723.     FindZeile = FirstLine;
  724.  
  725.     while ((FindZeile != NULL) &&
  726.            (FindZeile->LineNumber < LineNumber)) {
  727.       LastLine = FindZeile;
  728.       FindZeile = FindZeile->NextZeile;
  729.     }
  730.     if (!FindZeile)
  731.       FindZeile = LastLine;
  732.  
  733.     if (FindZeile->LineNumber == LineNumber) {
  734.       *InsPos = FindZeile;
  735.       return (TRUE);
  736.     }
  737.     else {
  738.       *InsPos =  FindZeile;
  739.       return (FALSE);
  740.     }
  741. }
  742.  
  743. int
  744. DelLine (int LineNumber)
  745. {
  746. PRGZEILE        *InsPos;
  747.     if (FindInsPos (LineNumber,&InsPos)) {
  748.       if ((InsPos->NextZeile == NULL) &&
  749.           (InsPos->PrevZeile == NULL))
  750.         FirstLine = NULL;
  751.       else
  752.         if (InsPos == FirstLine) {
  753.             FirstLine = InsPos->NextZeile;
  754.             InsPos->NextZeile->PrevZeile = NULL;
  755.         }
  756.         else {
  757.           if (InsPos->NextZeile == NULL)
  758.             InsPos->PrevZeile->NextZeile = NULL;
  759.           else {
  760.               InsPos->PrevZeile->NextZeile = InsPos->NextZeile;
  761.               InsPos->NextZeile->PrevZeile = InsPos->PrevZeile;
  762.           }
  763.         }
  764.       LocalFree ((LOCALHANDLE)InsPos);
  765.       return (TRUE);
  766.     }
  767.     else
  768.       return (FALSE);
  769. }
  770.  
  771. /* SCANNER */
  772.  
  773. int Scan ()
  774. {
  775. int test;
  776. char    *buffer;
  777.  
  778.   GetChar ();
  779.   SkipSpace ();
  780.  
  781.   if ((test = isalpha(Charakter)) != FALSE)
  782.     test = ALPHA;
  783.   else
  784.     if ((test = isdigit (Charakter)) != FALSE)
  785.       test = ZIFFER;
  786.        else
  787.      test = Charakter;
  788.  
  789.   switch (test) {
  790.     case ALPHA :
  791.       Steuer = ALPHA;
  792.       GetBezeichner (ScanBuffer);
  793.       NoSkipChar ();
  794.       break;
  795.     case ZIFFER :
  796.       GetZahl (ScanBuffer);
  797.       NoSkipChar ();
  798.       break;
  799.     case '"'        :
  800.       Steuer = STRING;
  801.       GetString (ScanBuffer);
  802.       break;
  803.     case '?'        :
  804.     case '('        :
  805.     case ')'        :
  806.     case '='        :
  807.     case '<'        :
  808.     case '>'        :
  809.     case '/'        :
  810.     case '*'        :
  811.     case '+'        :
  812.     case '-'        :
  813.       ScanBuffer[0] = Charakter;
  814.       ScanBuffer[1] = '\0';
  815.       Steuer = SONDER;
  816.       break;
  817.     case ',':
  818.        Steuer = TRENNER;
  819.       break;
  820.     case ';':
  821.       ScanBuffer[0] = Charakter;
  822.       ScanBuffer[1] = '\0';
  823.       Steuer = EOLCHAR;
  824.       break;
  825.     case EOLFEHLER:
  826.       return (UNEOL);
  827.     default :
  828.       Steuer = UNKNOWN;
  829.       fatal_error ("#  Ungⁿltiges Zeichen gefunden! #");
  830.       return (INVCHAR);
  831.   }
  832.  
  833. return (SCANOK);
  834. }
  835.  
  836. void SkipSpace ()
  837. {
  838.     while (Charakter == SPACE)
  839.       GetChar ();            /* Leerzeichen ueberlesen */
  840. }
  841.  
  842. void GetChar ()
  843. {
  844.   if (NeedNext == TRUE)
  845.     GetNextChar ();
  846.   else
  847.     NeedNext = TRUE;
  848. }
  849.  
  850. void GetNextChar ()
  851.  
  852. {
  853.  if (*LinePos != '\0') {
  854.    Charakter = *LinePos++;
  855.  }
  856.  else
  857.    Charakter = EOLFEHLER;
  858. }
  859.  
  860. void GetBezeichner (char *buffer)
  861. {
  862. int count = 0;
  863.  
  864.  while ((Charakter ==  '$') || (isalpha (Charakter) || isdigit (Charakter)) &&
  865.        (Charakter != ';') && (count++ < NAMLEN))
  866.  {
  867.    *buffer++ = Charakter;
  868.    GetChar ();
  869.  }
  870.  *buffer = '\0';
  871. }
  872.  
  873. void GetZahl (char *buffer)
  874. {
  875. int count = 0;
  876.    Steuer=ZIFFER;
  877.   while (((Charakter == '.') || isdigit (Charakter)) &&
  878.      (count++ < NAMLEN))
  879.   {
  880.     if (Charakter == '.') Steuer = FLONUM;
  881.     *buffer++ = Charakter;
  882.      GetChar ();
  883.   }
  884.      *buffer = '\0';
  885. }
  886.  
  887. void GetString (char *buffer)
  888. {
  889. int count = 0;
  890.  
  891.   GetChar ();
  892.  
  893.   while ( (Charakter != '"') &&
  894.       (count++ < ZEILENLAENGE))
  895.   {
  896.     *buffer++ = Charakter;
  897.     GetChar ();
  898.     *buffer = '\0';
  899.     if (Charakter == EOLFEHLER) {
  900.       fatal_error ("Stringende lΣ▀t sich nicht finden!");
  901.       break;
  902.     }
  903.   }
  904.   GetChar ();
  905. }
  906.  
  907. void GetGeklammert (char *buffer)
  908. {
  909. int count = 0;
  910. int nextkl;
  911.     nextkl=1;
  912. while ((nextkl) && (count++ < 200))
  913.   {
  914.     *buffer++ = Charakter;
  915.     GetChar ();
  916.     if(Charakter == '(') nextkl++;
  917.      if(Charakter == ')') nextkl--;
  918.       if (Charakter == EOLFEHLER)
  919.        fatal_error ("Rechte Klammer nicht gefunden! ");
  920.   }
  921.   *buffer++ = Charakter;
  922.   *buffer = '\0';
  923.   GetChar ();
  924. }
  925.  
  926. void
  927. NoSkipChar ()
  928. {
  929.   NeedNext = FALSE;
  930. }
  931.  
  932. void
  933. SkipChar ()
  934. {
  935.   NeedNext = TRUE;
  936. }
  937.  
  938. int cset(void)
  939. {
  940. VAR             Variable;
  941.  
  942.     Scan ();
  943.     if (Steuer == ALPHA) {
  944.       strcpy (Variable.VarName,ScanBuffer);
  945.       Scan ();
  946.       if ((Steuer == SONDER) && (*ScanBuffer == '=')) {
  947.         SetVar (&Variable,VARIABLE);
  948.       }
  949.       else
  950.         serror ("# Zuweisung erwartet! #");
  951.     }
  952.     else
  953.       serror ("# Variablenname erwartet! #");
  954.  
  955. return (OK);
  956. }
  957.  
  958. int cwtitle()
  959. {
  960.      Scan();
  961.     if (Steuer == STRING)
  962.            SetWindowText(hWndglob,ScanBuffer);
  963.            else
  964.         SetWindowText(hWndglob,szMessage);
  965.        return (OK);
  966. }
  967.  
  968. int KlammerTok()
  969. {
  970. int Error,cnt,vcnt;
  971.        cnt=vcnt=0;
  972.        Error = Scan();
  973.  
  974.        if((Steuer == SONDER) && (*ScanBuffer == '?'))
  975.        return (63);
  976.        if((Steuer == SONDER) && (*ScanBuffer == '('))
  977.     {
  978.      do
  979.      {
  980.        memset(PrintBuf,'\0',ZEILENLAENGE-1);
  981.        SkipChar();
  982.        Error = Scan();
  983.  
  984.         if((Steuer == SONDER) && (*ScanBuffer == ')')) break;
  985.  
  986.        switch(Steuer)
  987.         {
  988.          case ALPHA:
  989.            break;
  990.          case TRENNER:
  991.            break;
  992.          case ZIFFER:
  993.            break;
  994.          case EOLCHAR:
  995.          default:
  996.            Error = UNEOL;
  997.            break;
  998.         }
  999.        if(Steuer==ZIFFER || Steuer==ALPHA)
  1000.      {
  1001.         vcnt++;
  1002.        switch(vcnt)
  1003.        {
  1004.         case 1: if(Steuer ==  ALPHA) XW1 = ReadInt(ScanBuffer);
  1005.                else
  1006.              XW1 = atoi(ScanBuffer);
  1007.             /* Hier könnte ^ jeweils auch LinePos=ScanBuffer an
  1008.                CalcExpression() und somit Formeln als Parameter
  1009.                übergeben werden.
  1010.                z.B. bei ellipse (x*pi+4,etc......);
  1011.             */
  1012.             break;
  1013.         case 2: if(Steuer ==  ALPHA) YW1 = ReadInt(ScanBuffer);
  1014.                else
  1015.              YW1 = atoi(ScanBuffer);
  1016.             break;
  1017.         case 3: if(Steuer ==  ALPHA) XW2 = ReadInt(ScanBuffer);
  1018.                else
  1019.              XW2 = atoi(ScanBuffer);
  1020.             break;
  1021.         case 4: if(Steuer ==  ALPHA) YW2 = ReadInt(ScanBuffer);
  1022.                else
  1023.              YW2 = atoi(ScanBuffer);
  1024.             break;
  1025.         case 5: if(Steuer ==  ALPHA) XW3 = ReadInt(ScanBuffer);
  1026.                else
  1027.              XW3 = atoi(ScanBuffer);
  1028.             break;
  1029.         case 6: if(Steuer ==  ALPHA) YW3 = ReadInt(ScanBuffer);
  1030.                else
  1031.              YW3 = atoi(ScanBuffer);
  1032.             break;
  1033.         case 7: if(Steuer ==  ALPHA) XW4 = ReadInt(ScanBuffer);
  1034.                else
  1035.              XW4 = atoi(ScanBuffer);
  1036.             break;
  1037.         case 8: if(Steuer ==  ALPHA) YW4 = ReadInt(ScanBuffer);
  1038.                else
  1039.              YW4 = atoi(ScanBuffer);
  1040.             break;
  1041.         case 9: if(Steuer ==  ALPHA) TOutP = ReadInt(ScanBuffer);
  1042.                else
  1043.              TOutP = atoi(ScanBuffer);
  1044.             break;
  1045.         case 10: if(Steuer ==  ALPHA) TCliP = ReadInt(ScanBuffer);
  1046.                else
  1047.              TCliP = atoi(ScanBuffer);
  1048.             break;
  1049.         case 11: if(Steuer ==  ALPHA) TQual = ReadInt(ScanBuffer);
  1050.                else
  1051.              TQual = atoi(ScanBuffer);
  1052.             break;
  1053.         case 12: if(Steuer ==  ALPHA) oem  = ReadInt(ScanBuffer);
  1054.                else
  1055.              oem  = atoi(ScanBuffer);
  1056.              (oem != 0 ? 255 : 0);
  1057.             break;
  1058.         case 13: if(Steuer ==  ALPHA) TESCP = ReadInt(ScanBuffer);
  1059.                else
  1060.              TESCP = atoi(ScanBuffer);
  1061.             break;
  1062.         case 14: if(Steuer ==  ALPHA) TORIENT  = ReadInt(ScanBuffer);
  1063.                else
  1064.              TORIENT  = atoi(ScanBuffer);
  1065.             break;
  1066.        }
  1067.      }
  1068.      } while(Error != UNEOL);
  1069.  
  1070.     }
  1071.  
  1072.      return (IntError ? FALSE : vcnt);
  1073. }
  1074.  
  1075. void Paramtozeichne(int was,int hole)
  1076. {
  1077.         if(KlammerTok()==hole)
  1078.               Zeichne(was); else
  1079.                fatal_error ("# PARAMETER-ERROR #");
  1080. }
  1081.  
  1082.  
  1083. HDC GetPrinterDC()
  1084. {
  1085. char szPrinter[64];
  1086. char *szDevice,*szDriver,*szOutput;
  1087.      GetProfileString("windows","device","",szPrinter,64);
  1088.    if((szDevice = strtok(szPrinter,",")) &&
  1089.       (szDriver = strtok(NULL,     ", ")) &&
  1090.       (szOutput = strtok(NULL,     ", ")))
  1091.    return CreateDC(szDriver,szDevice,szOutput,NULL);
  1092.  return 0;
  1093. }
  1094.  
  1095. int csetprint()
  1096. {
  1097.  if((hPrnDC=GetPrinterDC())==NULL)
  1098.      {
  1099.        serror("# DRUCKER-INIT-ERROR #");
  1100.        return(ERROR);
  1101.      }
  1102.  
  1103.   if(Escape(hPrnDC,STARTDOC,sizeof szMessage - 1,szMessage,NULL) > 0)
  1104.        Drucker=TRUE;
  1105.      else
  1106.      {
  1107.        serror("# DRUCKER-OUTPUT-ERROR #");
  1108.        return(ERROR);
  1109.      }
  1110.  return(OK);
  1111. }
  1112.  
  1113. int cscreen()
  1114. {
  1115.  if(Drucker)
  1116.     {
  1117.     if(Escape(hPrnDC,NEWFRAME,0,NULL,NULL) > 0)
  1118.        Escape(hPrnDC,ENDDOC,0,NULL,NULL);
  1119.       DeleteDC(hPrnDC);
  1120.       Drucker=FALSE;
  1121.     }
  1122. }
  1123.  
  1124. void makefont()
  1125. {
  1126. int Art,TFamily;
  1127.      Art = (TXW1 >= 0 && TXW1 < 8) ? TXW1 : 0;
  1128.      mF.lfHeight = TXW2;
  1129.      mF.lfWidth  = TYW1;
  1130.      mF.lfEscapement = TESCP;
  1131.      mF.lfOrientation = TORIENT;
  1132.      mF.lfWeight = TYW2;
  1133.      mF.lfItalic = TXW4;
  1134.      mF.lfUnderline = TXW3;
  1135.      mF.lfStrikeOut = TYW3;
  1136.      mF.lfCharSet = oem;
  1137.      switch(TQual)
  1138.       {
  1139.       default:
  1140.        case 0:  mF.lfQuality = DEFAULT_QUALITY; break;
  1141.        case 1:  mF.lfQuality = DRAFT_QUALITY;   break;
  1142.        case 2:  mF.lfQuality = PROOF_QUALITY;   break;
  1143.       }
  1144.      switch(TOutP)
  1145.       {
  1146.       default:
  1147.        case 0: mF.lfOutPrecision = OUT_DEFAULT_PRECIS;   break;
  1148.        case 1: mF.lfOutPrecision = OUT_CHARACTER_PRECIS; break;
  1149.        case 2: mF.lfOutPrecision = OUT_STRING_PRECIS;    break;
  1150.        case 3: mF.lfOutPrecision = OUT_STROKE_PRECIS;    break;
  1151.       }
  1152.      switch(TCliP)
  1153.       {
  1154.       default:
  1155.        case 0: mF.lfClipPrecision = CLIP_DEFAULT_PRECIS;   break;
  1156.        case 1: mF.lfClipPrecision = CLIP_CHARACTER_PRECIS; break;
  1157.        case 2: mF.lfClipPrecision = CLIP_STROKE_PRECIS;    break;
  1158.       }
  1159.  
  1160.      TFamily=TFam / 10;
  1161.  
  1162.      switch(TFamily)
  1163.       {
  1164.       default:
  1165.        case 1: mF.lfPitchAndFamily = DEFAULT_PITCH;  break;
  1166.        case 2: mF.lfPitchAndFamily = FIXED_PITCH;     break;
  1167.        case 3: mF.lfPitchAndFamily = VARIABLE_PITCH;  break;
  1168.       }
  1169.  
  1170.      TFamily=TFam % 10;
  1171.  
  1172.      switch(TFamily)
  1173.       {
  1174.       default:
  1175.        case 0: mF.lfPitchAndFamily |= FF_DONTCARE;   break;
  1176.        case 1: mF.lfPitchAndFamily |= FF_DECORATIVE; break;
  1177.        case 2: mF.lfPitchAndFamily |= FF_MODERN;     break;
  1178.        case 3: mF.lfPitchAndFamily |= FF_ROMAN;      break;
  1179.        case 4: mF.lfPitchAndFamily |= FF_SCRIPT;     break;
  1180.        case 5: mF.lfPitchAndFamily |= FF_SWISS;      break;
  1181.       }
  1182.       strcpy(mF.lfFaceName,MFONT[Art]);
  1183.      FontChange=TRUE;
  1184. }
  1185.  
  1186. int ctexttype()
  1187. {
  1188. int Menge;
  1189.     Menge=KlammerTok();
  1190.     if (Menge==63)
  1191.       {
  1192.        lpProcTemp = MakeProcInstance(TypeHelp,hInst);
  1193.        DialogBox(hInst,"TYPEHELP",hWndglob,lpProcTemp);
  1194.        FreeProcInstance(lpProcTemp);
  1195.   PRINTF("Anzahl der Parameter 1 - 14  m÷glich <!!Vorsicht!!> bei P. 13-14");
  1196.   PRINTF("(Art,Hch,Br,Fat,U.st,D.gst,Kurs,Fam,OutP,Clip,Qual,OEM,ESC,ORIENT)");
  1197.        return(OK);
  1198.       } else
  1199.  
  1200.     if(Menge > 0 && Menge < 15)
  1201.     {
  1202.      switch(Menge)
  1203.      {
  1204.         case 14:
  1205.         case 13:
  1206.         case 12: TFam=YW4;
  1207.         case 11:
  1208.         case 10:
  1209.         case 9 :
  1210.         case 8 :
  1211.         case 7 : TXW4=XW4;
  1212.         case 6 : TYW3=YW3;
  1213.         case 5 : TXW3=XW3;
  1214.         case 4 : TYW2=YW2;
  1215.         case 3 : TXW2=XW2;
  1216.         case 2 : TYW1=YW1;
  1217.         case 1 : TXW1=XW1;
  1218.         default:
  1219.              break;
  1220.      }
  1221.       makefont();
  1222.     }
  1223.     else
  1224.        {
  1225.         FontChange=FALSE;
  1226.         if(bCaret)
  1227.            {
  1228.          DestroyCaret();
  1229.          bCaret = FALSE;
  1230.            }
  1231.        }
  1232.     return(OK);
  1233. }
  1234. int clocate()
  1235. {
  1236.      if(KlammerTok()== 2)
  1237.       {
  1238.     x=XW1;
  1239.     Zeile=YW1;
  1240.     locate=TRUE;
  1241.       }
  1242.      return(OK);
  1243. }
  1244.  
  1245. int cllist()
  1246. {
  1247.   /* Programm darf nicht länger sein als Druckerseite
  1248.      Ergänzung in Funktion TEXTZEILE(...)  if(Drucker && Zeile >= YPage)
  1249.      dann neue Seite.....            YPage=GetDeviceCaps(hPrnDC,VERTRES)
  1250.   */
  1251.   csetprint();
  1252.   clist();
  1253.   cscreen();
  1254. }
  1255. int ctextcol()
  1256. {
  1257.   TextCol= (KlammerTok()==1) ? XW1 : -1;
  1258.   return (OK);
  1259. }
  1260. int cpencolor()
  1261. {
  1262.   Pen = (KlammerTok()==1) ? XW1 : 0;
  1263.   return (OK);
  1264. }
  1265.  
  1266. int ccolor()
  1267. {
  1268.   Brush= (KlammerTok()==1) ? XW1 : 0;
  1269.   return (OK);
  1270. }
  1271.  
  1272. int cbackgrd()
  1273. {
  1274.   Backgrd= (KlammerTok()==1) ? XW1 : 15;
  1275.   return (OK);
  1276. }
  1277.  
  1278. int cviereck()
  1279. {
  1280.      Paramtozeichne(9,8);
  1281.      return(OK);
  1282. }
  1283.  
  1284. int crectline()
  1285. {
  1286.      Paramtozeichne(10,4);
  1287.      return(OK);
  1288. }
  1289.  
  1290.  
  1291.  
  1292. int crectangle()
  1293. {
  1294.      Paramtozeichne(1,4);
  1295.      return(OK);
  1296. }
  1297.  
  1298. int croundrect()
  1299. {
  1300.      Paramtozeichne(3,6);
  1301.      return(OK);
  1302. }
  1303.  
  1304. int cellipse()
  1305. {
  1306.      Paramtozeichne(2,4);
  1307.      return(OK);
  1308. }
  1309.  
  1310. int cpie()
  1311. {
  1312.      Paramtozeichne(6,8);
  1313.      return(OK);
  1314. }
  1315.  
  1316. int carc()
  1317. {
  1318.      Paramtozeichne(4,8);
  1319.      return(OK);
  1320. }
  1321.  
  1322. int cpolyline()
  1323. {
  1324.      Paramtozeichne(7,8);
  1325.      return(OK);
  1326. }
  1327.  
  1328. int clineto()
  1329. {
  1330.      Paramtozeichne(0,4);
  1331.      return(OK);
  1332. }
  1333. int cflodfil()
  1334. {
  1335.      Paramtozeichne(8,3);
  1336.      return(OK);
  1337. }
  1338. int csetpxl()
  1339. {
  1340.      Paramtozeichne(5,3);
  1341.      return(OK);
  1342. }
  1343.  
  1344.  
  1345. int cmove()
  1346. {
  1347.      if(KlammerTok()== 4)
  1348.          MoveWindow(hWndglob,XW1,YW1,XW2,YW2,TRUE);
  1349.          else
  1350.     MoveWindow(hWndglob,wX,wY,wW,wH,TRUE);
  1351.      return(OK);
  1352. }
  1353.  
  1354. int cinput()
  1355. {
  1356. VAR             Variable;
  1357.  
  1358.     Scan();
  1359.     if (Steuer == STRING)
  1360.        {
  1361.          sprintf (Questr,"%s",ScanBuffer);
  1362.          Scan();
  1363.        } else strcpy(Questr," Zahl eingeben :");
  1364.  
  1365.        if (Steuer == ALPHA)
  1366.            {
  1367.           strcpy (Variable.VarName,ScanBuffer);
  1368.           lpProcTextBox = MakeProcInstance(Input, hInst);
  1369.           DialogBox(hInst,"TextBox",hWndglob,lpProcTextBox);
  1370.           FreeProcInstance(lpProcTextBox);
  1371.           Variable.VarType = FLONUM;
  1372.           SetVar(&Variable,INPUT);
  1373.           SetCursor(LoadCursor(NULL,IDC_WAIT));
  1374.           return (OK);
  1375.            } else
  1376.            {
  1377.  
  1378.         PRINTF ("# Variablen-Name ? #");
  1379.         return (FALSE);
  1380.            }
  1381. }
  1382.  
  1383. int cinline()
  1384. {
  1385. VAR             Variable;
  1386.  
  1387.     Scan();
  1388.     if (Steuer == STRING)
  1389.        {
  1390.          sprintf (Questr,"%s",ScanBuffer);
  1391.          Scan();
  1392.        }  else strcpy(Questr," Text eingeben :");
  1393.  
  1394.        if (Steuer == ALPHA)
  1395.            {
  1396.           strcpy (Variable.VarName,ScanBuffer);
  1397.           lpProcTextBox = MakeProcInstance(Input, hInst);
  1398.           DialogBox(hInst,"TextBox",hWndglob,lpProcTextBox);
  1399.           FreeProcInstance(lpProcTextBox);
  1400.           Variable.VarType = STRING;
  1401.           SetVar(&Variable,INLINE);
  1402.           SetCursor(LoadCursor(NULL,IDC_WAIT));
  1403.           return (OK);
  1404.            } else
  1405.            {
  1406.  
  1407.         PRINTF ("# Variablen-Name ? #");
  1408.         return (FALSE);
  1409.            }
  1410. }
  1411. int ccursor(void)
  1412. {
  1413.      Scan();
  1414.         if(strcmp(ScanBuffer,"off") == 0)
  1415.         HideCaret(hWndglob);
  1416.          else
  1417.           if(strcmp(ScanBuffer,"on") == 0)
  1418.              ShowCaret(hWndglob);
  1419. }
  1420. int cdruck(void)
  1421. {
  1422. char *such;
  1423. int Error;
  1424.      memset(PrintBuf,'\0',ZEILENLAENGE-1);
  1425.      Mehr=(strchr(LinePos,',')) ? TRUE : FALSE;
  1426.      Scan();
  1427.  
  1428.      if(Steuer != EOLCHAR)
  1429.       {
  1430.      do {
  1431.       switch (Steuer) {
  1432.         case        EOLCHAR:
  1433.           Mehr=FALSE;
  1434.            break;
  1435.         case        STRING:
  1436.           if(!Mehr || !PrintBuf[0])
  1437.             sprintf (PrintBuf,"%s",ScanBuffer);
  1438.          else strcat(PrintBuf,ScanBuffer);
  1439.            break;
  1440.         case        ZIFFER:
  1441.           if(!Mehr || !PrintBuf[0])
  1442.             sprintf (PrintBuf,"%s",ScanBuffer);
  1443.          else strcat(PrintBuf,ScanBuffer);
  1444.            break;
  1445.         case        ALPHA:
  1446.           PrintVar (ScanBuffer);
  1447.            break;
  1448.         case        TRENNER:
  1449.          Mehr= TRUE;
  1450.         break;
  1451.         case        SONDER:
  1452.          if(*ScanBuffer == '(')
  1453.           {
  1454.          GetGeklammert (Questr);
  1455.          such=LinePos;
  1456.          LinePos=Questr;
  1457.         if (CalcExpression (&Variable) == ERROR_1)
  1458.            {
  1459.              serror ("# CalcExpr. Fehler! #");
  1460.              return (OK);
  1461.            }
  1462.         sprintf(IntegerZahl,"%-18.6f",
  1463.               Variable.VarWert.variable.Flotype);
  1464.          Nullenweg();
  1465.         LinePos=such;
  1466.           if(!Mehr || !PrintBuf[0])
  1467.         strcpy (PrintBuf,IntegerZahl);
  1468.          else strcat(PrintBuf,IntegerZahl);
  1469.  
  1470.           }
  1471.         break;
  1472.         default :
  1473.              serror ("# Nicht druckbarer Ausdruck! #");
  1474.            return (OK);
  1475.         break;
  1476.       }
  1477.           Error=Scan();
  1478.  
  1479.         } while (Error != UNEOL && Steuer != EOLCHAR);
  1480.           PRINTF(PrintBuf);
  1481.       }
  1482.            return (OK);
  1483. }
  1484. int messagebox()
  1485. {
  1486.   PrMsgBox=TRUE;
  1487.   return cdruck();
  1488. }
  1489.  
  1490. int cgoto(void)
  1491. {
  1492. int     error,LineNumber;
  1493.  
  1494.     Scan ();
  1495.     if ((Steuer == ZIFFER) && FirstLine)    {
  1496.       LineNumber = atoi (ScanBuffer);
  1497.       if (FindInsPos (LineNumber,&ActLine)) {
  1498.         ActLine = ActLine->PrevZeile;
  1499.         GetNextLine = FALSE;
  1500.         return (OK);
  1501.       }
  1502.       else {
  1503.  
  1504.            PRINTF ("# Sprungziel nicht gefunden! #");
  1505.         return (FALSE);
  1506.       }
  1507.     }
  1508.     else
  1509.       {
  1510.  
  1511.       PRINTF ("# Kein Programm im Speicher! #");
  1512.       }
  1513. return (OK);
  1514. }
  1515.  
  1516. int cwhile()
  1517. {
  1518.  int i;
  1519.    if(ActLine->NextZeile!=NULL)
  1520.        forcalc[ForCnt].Goto = ActLine->NextZeile;
  1521.      else
  1522.      {
  1523.       serror("# WHILE without WEND #");
  1524.       return(ERROR_1);
  1525.      }
  1526.  
  1527.     if((forcalc[ForCnt].whilestr = (char NEAR *)LocalAlloc (LPTR,81*sizeof(char)))==NULL)
  1528.      {
  1529.       serror("# kein Speicher mehr #");
  1530.       return(ERROR_1);
  1531.      } else i=0;
  1532.  
  1533.      while((forcalc[ForCnt].whilestr[i]=LinePos[i]) && i < 81) i++;
  1534.  
  1535.      if (CalcExpression (&Variable) == ERROR_1) return (ERROR_1);
  1536.      else i=1;
  1537.  
  1538.      if (Variable.VarWert.variable.Flotype <= 0.0)
  1539.       do
  1540.          switch(ActLine->NextZeile->Zeile[0])
  1541.           {
  1542.         case (char)TOKWHILE: i++; break;
  1543.         case (char)TOKWEND:  i--; break;
  1544.           }
  1545.       while((ActLine=ActLine->NextZeile)!=NULL && i);
  1546.  
  1547.      if(ForCnt < 11)
  1548.         ForCnt++;
  1549.           else serror ("# too many while while.... #");
  1550.  return (OK);
  1551. }
  1552.  
  1553. int cwend()
  1554. {
  1555. PRGZEILE *NEXT;
  1556.  
  1557. if(ForCnt && forcalc[ForCnt-1].whilestr != NULL)
  1558.    {
  1559.      NEXT= ActLine;
  1560.      GetNextLine = FALSE;
  1561.      LinePos=forcalc[ForCnt-1].whilestr;
  1562.      if (CalcExpression (&Variable) == ERROR_1) return (ERROR_1);
  1563.  
  1564.     if(Variable.VarWert.variable.Flotype > 0.0)
  1565.      ActLine = forcalc[ForCnt-1].Goto;
  1566.     else
  1567.      {
  1568.       if(ForCnt)ForCnt--;
  1569.       LocalFree ((LOCALHANDLE)(forcalc[ForCnt].whilestr));
  1570.       ActLine = NEXT->NextZeile;
  1571.      }
  1572.    } else serror ("# WEND WITHOUT WHILE #");
  1573. return (OK);
  1574. }
  1575.  
  1576. int cfor()
  1577. {
  1578. int error;
  1579. unsigned char *Nuntius;
  1580. BOOL STEP;
  1581.    STEP = FALSE;
  1582.    PrintBuf[0]='\0';
  1583.    if(ActLine->NextZeile!=NULL)
  1584.        forcalc[ForCnt].Goto = ActLine->NextZeile;
  1585.      else
  1586.      {
  1587.       serror("# FOR without NEXT #");
  1588.       return(ERROR_1);
  1589.      }
  1590.    Scan();
  1591.     if(Steuer != ALPHA)
  1592.       {
  1593.        serror ("# for ? #");
  1594.        return(ERROR_1);
  1595.       }
  1596.       strcpy (Variable.VarName,ScanBuffer);
  1597.       Scan();
  1598.     if(Steuer != SONDER && (*ScanBuffer != '='))
  1599.      {
  1600.       serror ("# Zuweisung ? #");
  1601.       return(ERROR_1);
  1602.      }
  1603.       Scan();
  1604.    do
  1605.     {
  1606.       strcat(PrintBuf,ScanBuffer);
  1607.       error = Scan();
  1608.     } while(strcmp(ScanBuffer,"downto") != 0 &&
  1609.         strcmp(ScanBuffer,"to") != 0 && error !=UNEOL);
  1610.  
  1611.    if(strcmp("to",ScanBuffer) != 0)
  1612.        {
  1613.     if( strcmp(ScanBuffer,"downto") != 0)
  1614.       {
  1615.         serror ("# TO expect #");
  1616.         return(ERROR_1);
  1617.       }
  1618.        }
  1619.       if(strcmp(ScanBuffer,"downto") == 0)
  1620.          forcalc[ForCnt].step = -1.0;
  1621.       else
  1622.           forcalc[ForCnt].step = 1.0;
  1623.       Nuntius=LinePos;
  1624.       LinePos = PrintBuf;
  1625.       SetVar (&Variable,FORNEXT);
  1626.       memset(PrintBuf,'\0',ZEILENLAENGE-1);
  1627.       LinePos=Nuntius;
  1628.       Scan();
  1629.       Scan();
  1630.   while(strcmp(ScanBuffer,"step") != 0 && error !=UNEOL)
  1631.    {
  1632.      strcat(PrintBuf,ScanBuffer);
  1633.      error = Scan();
  1634.      if(strcmp("step",ScanBuffer) == 0) STEP =TRUE;
  1635.    }
  1636.       Nuntius=LinePos;
  1637.       LinePos = PrintBuf;
  1638.    if (CalcExpression (&Variable) == ERROR_1) return (ERROR_1);
  1639.        forcalc[ForCnt].toY = Variable.VarWert.variable.Flotype;
  1640.  
  1641.      if(STEP)
  1642.        {
  1643.      LinePos=Nuntius;
  1644.      if (CalcExpression (&Variable) == ERROR_1) return (ERROR_1);
  1645.        forcalc[ForCnt].step = Variable.VarWert.variable.Flotype;
  1646.        }
  1647.  
  1648.      if(ForCnt < 11)
  1649.         ForCnt++;
  1650.           else serror ("# too many FOR FOR.... #");
  1651.  
  1652.  return (OK);
  1653. }
  1654.  
  1655. int cnext()
  1656. {
  1657. VAR *Variable;
  1658. PRGZEILE *NEXT;
  1659.  
  1660.  if(forcalc[ForCnt-1].forX != NULL)
  1661.      {
  1662.      NEXT= ActLine;
  1663.      GetNextLine = FALSE;
  1664.      Variable = forcalc[ForCnt-1].forX;
  1665.  
  1666.  if((forcalc[ForCnt-1].step > 0.0 &&
  1667.       Variable->VarWert.variable.Flotype < forcalc[ForCnt-1].toY) ||
  1668.     (forcalc[ForCnt-1].step < 0.0 &&
  1669.       Variable->VarWert.variable.Flotype > forcalc[ForCnt-1].toY))
  1670.        {
  1671.      Variable->VarWert.variable.Flotype += forcalc[ForCnt-1].step;
  1672.       ActLine = forcalc[ForCnt-1].Goto;
  1673.        } else
  1674.      {
  1675.        if(ForCnt) ForCnt--;
  1676.        ActLine = NEXT->NextZeile;
  1677.      }
  1678.      } else serror ("# NEXT WITHOUT FOR #");
  1679.   return (OK);
  1680. }
  1681.  
  1682. int cif()
  1683. {
  1684. int     result = OK;
  1685.     if (CmpVar ()) {
  1686.       ActLine = ActLine->NextZeile;
  1687.       LinePos = ActLine->Zeile;
  1688.       result = InterpLine ();
  1689.       ActLine = ActLine->NextZeile;
  1690.     }
  1691.     else
  1692.       {
  1693.       if (ActLine->NextZeile)
  1694.         ActLine = ActLine->NextZeile;
  1695.       else
  1696.         serror ("# Kein Else-Zweig vorhanden! #");
  1697.       }
  1698. return (result);
  1699. }
  1700.  
  1701. int ccls()
  1702. {
  1703. HDC hDC;
  1704.    HideCaret(hWndglob);
  1705.    Zeile = 0;
  1706.    hDC = GetDC(hWndglob);
  1707.     Rectangle(hDC,rect.left-1,rect.top-1,rect.right+1,rect.bottom+1);
  1708.    ReleaseDC(hWndglob,hDC);
  1709.    ShowCaret(hWndglob);
  1710. return (OK);
  1711. }
  1712. int crunb()
  1713. {
  1714.     if (FirstLine)
  1715.       RUNBREAK=TRUE;
  1716.      else
  1717.         PRINTF ("# Kein Programm im Speicher! #");
  1718.  
  1719. return (OK);
  1720. }
  1721. int crun()
  1722. {
  1723.     if (FirstLine)
  1724.      {
  1725.       ActLine = FirstLine;
  1726.       HideCaret(hWndglob);
  1727.       DoProgram ();
  1728.      }
  1729.      else
  1730.         PRINTF ("# Kein Programm im Speicher! #");
  1731. return (OK);
  1732. }
  1733.  
  1734. int cende ()
  1735. {
  1736.     PRINTF ("+ Normales Programmende +");
  1737. return (FALSE);
  1738. }
  1739.  
  1740. int  cexit ()
  1741. {
  1742.   if(MessageBox(hWndglob,(LPSTR) "Wollen Sie KuBasiC verlassen ?",
  1743.              (LPSTR)"* ENDE *",
  1744.                 MB_OKCANCEL | MB_ICONEXCLAMATION)==IDOK)
  1745.                   SendMessage(hWndglob,WM_DESTROY,0,0L);
  1746. return (OK);
  1747. }
  1748.  
  1749. int cmerke ()
  1750. {
  1751.  
  1752. return (OK);
  1753. }
  1754.  
  1755. int clist ()
  1756. {
  1757. PRGZEILE        *FindZeile;
  1758. char        *Line;
  1759.     if ((FindZeile = FirstLine) != NULL) {
  1760.  
  1761.         PRINTF ("******* Aktuelles Programm auflisten: ********");
  1762.         PRINTF (FileName);
  1763.         while ( FindZeile) {
  1764.           ShowLine (FindZeile);
  1765.           FindZeile = FindZeile->NextZeile;
  1766.         }
  1767.         PRINTF ("******* Ende des aktuellen Programms! ********");
  1768.     }
  1769.  
  1770. return (TRUE);
  1771. }
  1772.  
  1773. void Waehlbox()
  1774. {
  1775.  lpOpenDlg = MakeProcInstance((FARPROC) OpenDlg, hInst);
  1776.  DialogBox(hInst, "Open", hWndglob, lpOpenDlg);
  1777.  FreeProcInstance(lpOpenDlg);
  1778. }
  1779.  
  1780. int cload ()
  1781. {
  1782.     Scan();
  1783.     if (Steuer == STRING)
  1784.      {
  1785.       SetFileName (ScanBuffer);
  1786.       ReadProg ();
  1787.      }
  1788.     else
  1789.      {
  1790.         Waehlbox();
  1791.       if(LoadFile) ReadProg ();
  1792.      }
  1793. return (OK);
  1794. }
  1795.  
  1796.  
  1797. int csave ()
  1798. {
  1799.  
  1800.     Scan();
  1801.     if (Steuer == STRING) {
  1802.       SetFileName (ScanBuffer);
  1803.       WriteProg ();
  1804.     }
  1805.     else
  1806.       serror ("# Kein Filename angegeben! #");
  1807. return (OK);
  1808. }
  1809.  
  1810.  
  1811. int cneu ()
  1812. {
  1813.     ClearVar();
  1814.     ClearProg ();
  1815. return (OK);
  1816. }
  1817.  
  1818. void fatal_error (char *FehlerMeldung)
  1819. {
  1820.     TextCol = -1;
  1821.     PRINTF (FehlerMeldung);
  1822.     IntError = TRUE;
  1823. }
  1824.  
  1825. void serror(char *FehlerMeldung)
  1826. {
  1827.     TextCol = -1;
  1828.     PRINTF (FehlerMeldung);
  1829.     IntError = TRUE;
  1830. }
  1831.  
  1832. void ResetError ()
  1833. {
  1834.   IntError = FALSE;
  1835. }
  1836.  
  1837. int ReadProg ()
  1838. {
  1839. PRGZEILE        NewLine;
  1840. FILE    *FilePointer;
  1841. char    ReadBuffer[255];
  1842. char    ausgabe[30];
  1843. char    *FName;
  1844.  
  1845.     if ((FName = GetFileName()) != NULL) {
  1846.      fio = OpenFile((LPSTR)FName,(LPOFSTRUCT)&fileInfo,OF_READ);
  1847.  
  1848.       if ((FilePointer = fdopen(fio,"rb")) == NULL) {
  1849.         fatal_error (" Datei konnte nicht ge÷ffnet werden! ");
  1850.         return (ERROR_1);
  1851.       }
  1852.     }
  1853.     else {
  1854.       fatal_error (" Ungⁿltiger Dateiname! ");
  1855.       return (ERROR_1);
  1856.     }
  1857.      cneu ();
  1858.      strcpy(ausgabe,"Lade Datei : ");
  1859.      strcat(ausgabe,FName);
  1860.      PRINTF (ausgabe);
  1861.  
  1862.     while (ReadFileLine (FilePointer,ReadBuffer)) {
  1863.       if (strlen (ReadBuffer) > 3) {
  1864.         LinePos = ReadBuffer;
  1865.         SkipChar ();
  1866.         Scan ();
  1867.         if (Steuer == ZIFFER) {
  1868.           NewLine.LineNumber = atoi (ScanBuffer);
  1869.           ActLine = 
  1870.           if (MakeToken () == OK)
  1871.             InsIntLine ();
  1872.           else {
  1873.  
  1874.             PRINTF ("### Ungⁿltiger Befehl gefunden! ###");
  1875.             return (ERROR_1);
  1876.           }
  1877.         }
  1878.         else {
  1879.           fatal_error ("Fehler beim Einlesen der Datei! ");
  1880.           return (FALSE);
  1881.         }
  1882.       }
  1883.     }
  1884. fclose (FilePointer);
  1885. return (OK);
  1886. }
  1887.  
  1888. int ReadFileLine (FilePointer,BufPointer)
  1889. FILE    *FilePointer;
  1890. char    BufPointer[];
  1891. {
  1892. char    zeichen;
  1893. char    *ReadPointer;
  1894.     ReadPointer = BufPointer;
  1895.  
  1896.     do {
  1897.         zeichen = *ReadPointer++ = fgetc (FilePointer);
  1898.     }       while ((zeichen != LF)&&(zeichen != '\r') && (zeichen != EOF));
  1899.  
  1900.     *(--ReadPointer) = '\0';
  1901.  
  1902.     if ((zeichen == EOF) && (ReadPointer == BufPointer))
  1903.       return (FALSE);
  1904.     else
  1905.       return (TRUE);
  1906. }
  1907.  
  1908. int WriteProg ()
  1909. {
  1910. PRGZEILE        *FindZeile;
  1911. FILE    *FilePointer;
  1912. char    ausgabe[30];
  1913. char    WriteBuffer[255];
  1914. char    *FName;
  1915. char    *Line;
  1916.  
  1917.     if ((FName = GetFileName()) != NULL) {
  1918.      strcpy(ausgabe,"Save Datei : ");
  1919.       strcat(ausgabe,FName);
  1920.        PRINTF (ausgabe);
  1921.      fio = OpenFile((LPSTR)FName,(LPOFSTRUCT)&fileInfo,OF_CREATE | OF_WRITE );
  1922.  
  1923.       if ((FilePointer = fdopen (fio,"w+b")) == NULL) {
  1924.         fatal_error (" Datei konnte nicht ge÷ffnet werden! ");
  1925.         return (ERROR_1);
  1926.       }
  1927.     }
  1928.     else {
  1929.       fatal_error (" Ungⁿltiger Dateiname! ");
  1930.       return (ERROR_1);
  1931.     }
  1932.  
  1933.  
  1934.     if ((FindZeile = FirstLine) != NULL) {
  1935.         while ( FindZeile) {
  1936.             Line = FindZeile->Zeile;
  1937.             if (*Line) {
  1938.               sprintf (WriteBuffer,"%03d %s ",
  1939.                      FindZeile->LineNumber,
  1940.                     TokBefDesc[(*Line-TOKMIN)&0xff].Befehl
  1941.                     );
  1942.                fprintf (FilePointer,"%s",WriteBuffer);
  1943.                 Line++;
  1944.                if (*Line)
  1945.                   {
  1946.                    sprintf (WriteBuffer,"%s\r\n",Line);
  1947.                    fprintf (FilePointer,"%s",WriteBuffer);
  1948.                   } else if(WriteBuffer[0])
  1949.                   {
  1950.                    strcpy(WriteBuffer,"\r\n");
  1951.                    fprintf (FilePointer,"%s",WriteBuffer);
  1952.                   }
  1953.  
  1954.             }
  1955.             FindZeile = FindZeile->NextZeile;
  1956.         }
  1957.     }
  1958. fclose(FilePointer);
  1959. return (OK);
  1960. }
  1961.  
  1962.  
  1963. void SetFileName (char  *FName)
  1964. {
  1965.  strcpy (FileName,FName);
  1966. }
  1967.  
  1968. char    *GetFileName ()
  1969. {
  1970.  return (FileName);
  1971. }
  1972.  
  1973. void ShowLine (PRGZEILE *FindZeile)
  1974. {
  1975. char    *Line;
  1976. char Ausgabe[255];
  1977.  
  1978.     Line = FindZeile->Zeile;
  1979.  if (*Line)
  1980.     {
  1981.        sprintf (Ausgabe,"%03d %s ",
  1982.            FindZeile->LineNumber,
  1983.            TokBefDesc[(*Line-TOKMIN)&0xff].Befehl);
  1984.        if(*Line != ';') Line++;
  1985.        if (*Line) strcat(Ausgabe,Line);
  1986.        PRINTF (Ausgabe);
  1987.     }
  1988. }
  1989.  
  1990. VAR *IsVariable (char    *Name)
  1991. {
  1992. VAR  *i;
  1993.  
  1994.   for (i = FirstVar;
  1995.        i && (strcmp(Name,i->VarName) != 0);
  1996.        i = i->NextVar);
  1997.  
  1998. return (i);
  1999. }
  2000.  
  2001. int SetVar (VAR *Wert,BOOL Input)
  2002. {
  2003. VAR             *Variable;
  2004. VAR             Value;
  2005.  
  2006.       if(Input == INPUT)
  2007.          {
  2008.           strcpy(Value.VarName,Wert->VarName);
  2009.            Value.VarWert.variable.Flotype = atof(Textstr);
  2010.         Value.VarType = FLONUM;
  2011.          } else
  2012.       if(Input == INLINE)
  2013.          {
  2014.           strcpy(Value.VarName,Wert->VarName);
  2015.           strcpy(ScanBuffer,Textstr);
  2016.           Value.VarType = STRING;
  2017.          }
  2018.            else if (CalcExpression (&Value) == ERROR_1) return (ERROR_1);
  2019.  
  2020.     if ((Variable = IsVariable (Wert->VarName)) != NULL)
  2021.        {
  2022.  
  2023.        if (Variable->VarType != Value.VarType)
  2024.          {
  2025.            serror("# falscher Variablentyp #");
  2026.            return (FALSE);
  2027.          }
  2028.  
  2029.        if (Variable->VarType==STRING)
  2030.         LocalFree ((LOCALHANDLE)(Variable->VarWert.variable.text));
  2031.         SetValue (&Variable->VarWert,&Value.VarWert,Value.VarType);
  2032.         if(Input == FORNEXT) forcalc[ForCnt].forX = Variable;
  2033.       return (OK);
  2034.     }
  2035.  
  2036.     if (( Variable =(VAR NEAR *) LocalAlloc(LPTR,sizeof(VAR))) == NULL) {
  2037.       PRINTF ("# Kein Speicherplatz mehr fⁿr die Variable! #");
  2038.       return (FALSE);
  2039.     }
  2040.  
  2041.     strcpy (Variable->VarName,Wert->VarName);
  2042.     Variable->VarType = Value.VarType;
  2043.     SetValue (&Variable->VarWert,&Value.VarWert,Value.VarType);
  2044.     Variable->NextVar = FirstVar;
  2045.     FirstVar = Variable;
  2046.     if(Input == FORNEXT) forcalc[ForCnt].forX = FirstVar;
  2047. return (OK);
  2048. }
  2049.  
  2050. void SetValue (NewVar,Wert,Type)
  2051. VARDEF  *NewVar,*Wert;
  2052. unsigned char   Type;
  2053. {
  2054.  
  2055.     switch (Type) {
  2056.       case  ZIFFER:
  2057.         NewVar->variable.integer = Wert->variable.integer;
  2058.       break;
  2059.       case  FLONUM:
  2060.         NewVar->variable.Flotype = Wert->variable.Flotype;
  2061.       break;
  2062.       case  ALPHA:
  2063.         NewVar->variable.zeichen = Wert->variable.zeichen;
  2064.       break;
  2065.       case  STRING:
  2066.       NewVar->variable.text = (unsigned char NEAR *)LocalAlloc (LPTR,
  2067.                        (strlen(ScanBuffer)+1)*sizeof(char));
  2068.     if (NewVar->variable.text== NULL)
  2069.          serror ("#### Kein Speicherplatz mehr vorhanden! ####");
  2070.        else
  2071.          strcpy(NewVar->variable.text,ScanBuffer);
  2072.       break;
  2073.       default:
  2074.           serror ("# Variablenzuweisung fⁿr diesen Typ nicht implementiert! #");
  2075.       break;
  2076.     }
  2077.  
  2078. }
  2079. int MsgBox(char *Questr)
  2080. {
  2081. WORD Options;
  2082.         Options=0x0000;
  2083.         if(Questr[0] == '*') Options |= MB_ICONASTERISK;
  2084.          else
  2085.         if(Questr[0] == 'H') Options |= MB_ICONHAND;
  2086.          else
  2087.         if(Questr[0] == '?') Options |= MB_ICONQUESTION;
  2088.          else
  2089.         if(Questr[0] == '!') Options |= MB_ICONEXCLAMATION;
  2090.          Questr[0] = ' ';
  2091.         if(Questr[1] == 'Y') Options |= MB_YESNO;
  2092.          else
  2093.         if(Questr[1] == 'C') Options |= MB_OKCANCEL;
  2094.          Questr[1] = ' ';
  2095.  return (MessageBox(hWndglob,(LPSTR) Questr,(LPSTR) "* ACHTUNG *",Options));
  2096. }
  2097.  
  2098. int CmpVar ()
  2099. {
  2100. unsigned char *Nuntius;
  2101.     Nuntius=LinePos;
  2102.     Scan ();
  2103.     if (Steuer == STRING)
  2104.        {
  2105.           what = MsgBox(ScanBuffer);
  2106.         if (what==IDYES || what==IDOK) return TRUE;
  2107.           else return FALSE;
  2108.        }
  2109.     LinePos=Nuntius;
  2110.       if (CalcExpression (&Variable) == ERROR_1) serror ("# if Fehler #");;
  2111.      if (Variable.VarWert.variable.Flotype <= 0.0)
  2112.         return FALSE;
  2113.            else return TRUE;
  2114.  
  2115. }
  2116.  
  2117. void Nullenweg()
  2118. {
  2119. int ncnt;
  2120.  
  2121.         ncnt=19;
  2122.         while(IntegerZahl[ncnt--]!= '.')
  2123.          {
  2124.          if(IntegerZahl[ncnt]> '0') break;
  2125.             if(IntegerZahl[ncnt]=='.')
  2126.              {
  2127.               IntegerZahl[ncnt]=' ';
  2128.               break;
  2129.              }
  2130.             if(IntegerZahl[ncnt]=='0')
  2131.              IntegerZahl[ncnt]=' ';
  2132.          }
  2133.          IntegerZahl[ncnt+1]='\0';
  2134. }
  2135.  
  2136. void PrintVar (char *Name)
  2137. {
  2138. VAR             *Variable;
  2139.     if ((Variable = IsVariable (Name)) != NULL) {
  2140.       switch (Variable->VarType) {
  2141.         case        ZIFFER:
  2142.         sprintf(IntegerZahl,"%-10i",Variable->VarWert.variable.integer);
  2143.           if(!Mehr || !PrintBuf[0]) sprintf (PrintBuf,"%10s",IntegerZahl);
  2144.          else strcat(PrintBuf,IntegerZahl);
  2145.         break;
  2146.  
  2147.         case        FLONUM:
  2148.         sprintf(IntegerZahl,"%-18.6f",
  2149.               Variable->VarWert.variable.Flotype);
  2150.           Nullenweg();
  2151.           if(!Mehr || !PrintBuf[0]) sprintf (PrintBuf,"%s",IntegerZahl);
  2152.          else strcat(PrintBuf,IntegerZahl);
  2153.         break;
  2154.         case        STRING:
  2155.           if(!Mehr || !PrintBuf[0])
  2156.         strcpy (PrintBuf,Variable->VarWert.variable.text);
  2157.          else strcat(PrintBuf,Variable->VarWert.variable.text);
  2158.         break;
  2159.         default:
  2160.  
  2161.           PRINTF ("# Variablen dieses Typs k÷nnen nicht gedruckt werden! #");
  2162.         break;
  2163.       }
  2164.     }
  2165.     else {
  2166.       char buffer[40];
  2167.       sprintf (buffer,"# Variable <%s> unbekannt! #",Name);
  2168.       fatal_error (buffer);
  2169.     }
  2170. }
  2171. int ReadInt (char *Name)
  2172. {
  2173. int wert;
  2174. VAR             *Variable;
  2175.     if ((Variable = IsVariable (Name)) != NULL)
  2176.      {
  2177.       switch (Variable->VarType)
  2178.       {
  2179.         case        ZIFFER:
  2180.         wert=Variable->VarWert.variable.integer;
  2181.         break;
  2182.  
  2183.         case        FLONUM:
  2184.         wert=(int)Variable->VarWert.variable.Flotype;
  2185.         break;
  2186.         case        STRING:
  2187.         break;
  2188.         default:
  2189.  
  2190.           PRINTF ("# Variablen dieses Typs k÷nnen nicht gedruckt werden! #");
  2191.         break;
  2192.       }
  2193.      return wert;
  2194.      }
  2195.     else {
  2196.       char buffer[40];
  2197.       sprintf (buffer,"# Variable <%s> unbekannt! #",Name);
  2198.       fatal_error (buffer);
  2199.       return (FALSE);
  2200.     }
  2201.  
  2202. }
  2203.  
  2204.  
  2205. int CalcExpression (VAR *Result)
  2206. {
  2207. PTNODE FTree;
  2208. unsigned char *Formel;
  2209.  
  2210.    Formel=LinePos;
  2211.    Scan();
  2212.    if(Steuer == EOLCHAR) return (ERROR_1);
  2213.  
  2214.     if(Steuer==STRING)
  2215.       {
  2216.     /* String - Addition/Bearbeitung hier implementieren
  2217.        und in den Scanbuffer schreiben */
  2218.  
  2219.     Result->VarType=STRING;
  2220.     return (OK);
  2221.       }
  2222.  
  2223.      FTree = CreateTree(Formel,&ErrPos,&ErrNr);
  2224.      if(ErrPos != -1)
  2225.     {
  2226.      switch(ErrNr)
  2227.       {
  2228.        case 0:  PRINTF("# Klammer nicht zu #"); break;
  2229.        case 1:  PRINTF("# Klammer nicht auf #"); break;
  2230.        case 2:  PRINTF("# Fehler beim Einlesen #"); break;
  2231.        case 3:  PRINTF("# unerwartetes Ende #"); break;
  2232.        case 4:  PRINTF("# Zeichen falsch #"); break;
  2233.        case 5:  PRINTF("# Variable nicht initialisiert #"); break;
  2234.        case 6:  PRINTF("# Zeichen falsch #"); break;
  2235.        case 7:  PRINTF("# Falscher Variablentyp #"); break;
  2236.        default: PRINTF("# undefinierter Fehler #"); break;
  2237.       }
  2238.      return (ERROR_1);
  2239.     }
  2240.     else
  2241.        {
  2242.          Result->VarWert.variable.Flotype = (double) Calc(&FTree);
  2243.          Result->VarType=FLONUM;
  2244.          DelTree(&FTree);
  2245.        }
  2246.    return (OK);
  2247. }
  2248.  
  2249. void ClearProg ()
  2250. {
  2251. PRGZEILE *Memory;
  2252.  
  2253.     ActLine = FirstLine;
  2254.  
  2255.     while (ActLine) {
  2256.     Memory = ActLine;
  2257.     ActLine = ActLine->NextZeile;
  2258.     LocalFree ((LOCALHANDLE)Memory);
  2259.     }
  2260.  
  2261.     FirstLine = ActLine = NULL;
  2262.  
  2263. }
  2264. void ClearVar()
  2265. {
  2266. VAR  *Memory;
  2267.     while (FirstVar) {
  2268.       Memory = FirstVar;
  2269.       if(Memory->VarType == STRING)
  2270.         LocalFree ((LOCALHANDLE)(Memory->VarWert.variable.text));
  2271.       FirstVar = FirstVar->NextVar;
  2272.       LocalFree ((LOCALHANDLE)Memory);
  2273.     }
  2274.     FirstVar = NULL;
  2275. }
  2276.  
  2277. void Carret(unsigned char *String)
  2278. {
  2279.     Leerstring[0]=(String[0]=='>') ? '>' : ' ';
  2280. }
  2281.  
  2282. void ErzeugeCursor(HWND hWnd)
  2283. {
  2284.  CreateCaret(hWnd,1,tm.tmAveCharWidth,tm.tmHeight);
  2285.  bCaret=TRUE;
  2286.  ShowCaret(hWnd);
  2287. }
  2288.  
  2289. void TEXTZEILE(HDC hDC,unsigned char *String)
  2290. {
  2291.   if(FontChange)
  2292.     {
  2293.      newFont = CreateFontIndirect((LPLOGFONT) &mF);
  2294.      oldFont = SelectObject(hDC,newFont);
  2295.      HideCaret(hWndglob);
  2296.     if(bCaret) DestroyCaret();
  2297.      GetTextMetrics(hDC,(LPTEXTMETRIC)&tm);
  2298.      ErzeugeCursor(hWndglob);
  2299.     }
  2300.     else if(!bCaret)
  2301.       {
  2302.        GetTextMetrics(hDC,(LPTEXTMETRIC)&tm);
  2303.        ErzeugeCursor(hWndglob);
  2304.       }
  2305.  
  2306.   if(!Drucker && !locate)
  2307.     {
  2308.      HideCaret(hWndglob);
  2309.      if(!Mono)
  2310.        SetTextColor(hDC,VIOLETT);
  2311.      Carret(String);
  2312.      TextOut(hDC,(short)0,(short)Zeile,(LPSTR)Leerstring,(short)80);
  2313.     }
  2314.  
  2315.  if(!Mono && !Drucker)
  2316.      switch(String[0])
  2317.       {
  2318.        case '>':
  2319.            SetTextColor(hDC,VIOLETT);
  2320.            break;
  2321.        case '#':
  2322.            SetTextColor(hDC,ROT);
  2323.            break;
  2324.        case '*':
  2325.            SetTextColor(hDC,GRUEN);
  2326.            break;
  2327.        case '+':
  2328.            SetTextColor(hDC,BLACK);
  2329.            break;
  2330.        default:
  2331.          SetTextColor(hDC,BLAU);
  2332.            break;
  2333.       }
  2334.        if(!Mono) {
  2335.                if(TextCol >= 0)
  2336.             SetTextColor(hDC,SetRGBColor(TextCol));
  2337.  
  2338.                if(Backgrd != 15)
  2339.             SetBkColor(hDC,SetRGBColor(Backgrd));
  2340.              }
  2341.       TextOut(hDC,(short)x,(short)Zeile,(LPSTR)String,(short)strlen(String));
  2342.  
  2343.      if(!locate)
  2344.         {
  2345.           dwTextlen=GetTextExtent(hDC,(LPSTR)String,strlen(String));
  2346.           pt=MAKEPOINT(dwTextlen);
  2347.           LPtoDP(hDC,&pt,2);
  2348.           SetCaretPos(x+pt.x,Zeile);
  2349.           ShowCaret(hWndglob);
  2350.         }
  2351.  
  2352.       Zeile+=(tm.tmHeight+2);
  2353.  
  2354.       if(!Drucker && Zeile >= rect.bottom-(tm.tmHeight+2))
  2355.     {
  2356.           Zeile=0;
  2357.           if(!Mono && !Drucker)
  2358.         SetTextColor(hDC,VIOLETT);
  2359.            Carret(String);
  2360.            TextOut(hDC,(short)0,(short)Zeile,(LPSTR)Leerstring,(short)80);
  2361.     }  /* else if(Drucker && Zeile > Blattgroesse...... */
  2362.  
  2363.   if(FontChange)
  2364.     {
  2365.      SelectObject(hDC,oldFont);
  2366.      DeleteObject(newFont);
  2367.     }
  2368.      x=0;
  2369.      locate=FALSE;
  2370. }
  2371.  
  2372. void PRINTF(unsigned char *String)
  2373. {
  2374. HDC hDC;
  2375.    if(Edit) return;
  2376.    if(PrMsgBox)
  2377.       {
  2378.        PrMsgBox=FALSE;
  2379.        what = MsgBox(String);
  2380.        return;
  2381.       }
  2382.  
  2383.    if(!Drucker)
  2384.      hDC = GetDC(hWndglob);
  2385.     else
  2386.      hDC = hPrnDC;
  2387.    TEXTZEILE(hDC,String);
  2388.    if(!Drucker)
  2389.       ReleaseDC(hWndglob,hDC);
  2390. }
  2391. DWORD SetRGBColor(int XW2)
  2392. {
  2393. DWORD FARBE;
  2394.        if(Mono) return (DWORD) 0;
  2395.           else
  2396.          switch(XW2)
  2397.            {
  2398.          case 9:
  2399.          case 1:    FARBE = BLAU;    break;
  2400.          case 10:
  2401.          case 2:    FARBE = GRUEN;   break;
  2402.          case 11:
  2403.          case 3:    FARBE = TURKIS;  break;
  2404.          case 4:
  2405.          case 6:
  2406.          case 12:   FARBE = ROT;     break;
  2407.          case 13:
  2408.          case 5:    FARBE = VIOLETT; break;
  2409.          case 15:
  2410.          case 7:    FARBE = WEISS;   break;
  2411.          case 14:   FARBE = GELB;    break;
  2412.          case 8:
  2413.          default:    FARBE = BLACK;   break;
  2414.            }
  2415.    return FARBE;
  2416. }
  2417. void Zeichne(int was)
  2418. {
  2419. HDC hDC;
  2420.  
  2421.  
  2422.    if(!Drucker)
  2423.     {
  2424.      hDC = GetDC(hWndglob);
  2425.      switch(Brush)
  2426.        {
  2427.        case 1:
  2428.        case 9:  FARBBRUSH=hBlauBrush; break;
  2429.        case 2:
  2430.        case 10: FARBBRUSH=hGruenBrush; break;
  2431.        case 3:
  2432.        case 11: FARBBRUSH=hTurkisBrush; break;
  2433.        case 4 :
  2434.        case 6 :
  2435.        case 12:  FARBBRUSH=hRedBrush; break;
  2436.        case 7 :  FARBBRUSH=hGrauBrush; break;
  2437.        case 5:
  2438.        case 13: FARBBRUSH=hViolettBrush; break;
  2439.        case 14: FARBBRUSH=hGelbBrush; break;
  2440.        case 15: FARBBRUSH=hWeissBrush; break;
  2441.        default:
  2442.        case 0:
  2443.        case 8:  FARBBRUSH=hBlackBrush; break;
  2444.        }
  2445.  
  2446.        hOldBrush=SelectObject(hDC,FARBBRUSH);
  2447.  
  2448.          switch(Pen)
  2449.            {
  2450.            case 1:
  2451.            case 9:  FARBPEN=hBlauPen; break;
  2452.            case 2:
  2453.            case 10: FARBPEN=hGruenPen; break;
  2454.            case 3:
  2455.            case 11: FARBPEN=hTurkisPen; break;
  2456.            case 4 :
  2457.            case 6 :
  2458.            case 12: FARBPEN=hRedPen; break;
  2459.            case 7 : FARBPEN=hGrauPen; break;
  2460.            case 5:
  2461.            case 13: FARBPEN=hViolettPen; break;
  2462.            case 14: FARBPEN=hGelbPen; break;
  2463.            case 15: FARBPEN=hWeissPen; break;
  2464.            default:
  2465.            case 0:
  2466.            case 8:  FARBPEN=hBlackPen; break;
  2467.            }
  2468.          hOldPen=SelectObject(hDC,FARBPEN);
  2469.     }
  2470.        else hDC = hPrnDC;
  2471.  
  2472.     switch(was)
  2473.      {
  2474.       case 0:
  2475.          /* da der DC immer neu erstellt wird müßten für moveto(x,y)
  2476.         Variablen verwaltet werden...........
  2477.          */
  2478.          MoveTo(hDC,XW1,YW1);
  2479.          LineTo(hDC,XW2,YW2);
  2480.          break;
  2481.       case 1:
  2482.          Rectangle(hDC,XW1,YW1,XW2,YW2);
  2483.          break;
  2484.       case 2:
  2485.          Ellipse(hDC,XW1,YW1,XW2,YW2);
  2486.          break;
  2487.       case 3:
  2488.          RoundRect(hDC,XW1,YW1,XW2,YW2,XW3,YW3);
  2489.          break;
  2490.       case 4:
  2491.          Arc(hDC,XW1,YW1,XW2,YW2,XW3,YW3,XW4,YW4);
  2492.          break;
  2493.  
  2494.       case 5: SetPixel(hDC,XW1,YW1,SetRGBColor(XW2));
  2495.           /* Variable = GetPixel in Funktion einbauen */
  2496.          break;
  2497.       case 6:
  2498.          Pie(hDC,XW1,YW1,XW2,YW2,XW3,YW3,XW4,YW4);
  2499.          break;
  2500.       case 7:
  2501.          MoveTo(hDC,XW1,YW1);
  2502.          LineTo(hDC,XW2,YW2);
  2503.          LineTo(hDC,XW3,YW3);
  2504.          LineTo(hDC,XW4,YW4);
  2505.          break;
  2506.       case 8:
  2507.           switch(XW2)
  2508.         {
  2509.            case 1:
  2510.            case 9:  FLOODFARBE=BLAU; break;
  2511.            case 2:
  2512.            case 10: FLOODFARBE=GRUEN; break;
  2513.            case 3:
  2514.            case 11: FLOODFARBE=TURKIS; break;
  2515.            case 4 :
  2516.            case 6 :
  2517.            case 12: FLOODFARBE=ROT; break;
  2518.            case 7 : FLOODFARBE=GRAU; break;
  2519.            case 5:
  2520.            case 13: FLOODFARBE=VIOLETT; break;
  2521.            case 14: FLOODFARBE=GELB; break;
  2522.            case 15: FLOODFARBE=WEISS; break;
  2523.            default:
  2524.            case 0:
  2525.            case 8:  FLOODFARBE=BLACK; break;
  2526.         }
  2527.           FloodFill(hDC,XW1,YW1,FLOODFARBE);
  2528.          break;
  2529.        case 9:
  2530.          MoveTo(hDC,XW1,YW1);
  2531.          LineTo(hDC,XW2,YW2);
  2532.          LineTo(hDC,XW3,YW3);
  2533.          LineTo(hDC,XW4,YW4);
  2534.          LineTo(hDC,XW1,YW1);
  2535.          break;
  2536.        case 10:
  2537.          MoveTo(hDC,XW1,YW1);
  2538.          LineTo(hDC,XW2,YW1);
  2539.          LineTo(hDC,XW2,YW2);
  2540.          LineTo(hDC,XW1,YW2);
  2541.          LineTo(hDC,XW1,YW1);
  2542.          break;
  2543.      }
  2544.  
  2545.    if(!Drucker)
  2546.       {
  2547.        SelectObject(hDC,hOldPen);
  2548.        SelectObject(hDC,hOldBrush);
  2549.        ReleaseDC(hWndglob,hDC);
  2550.       }
  2551. }
  2552.