home *** CD-ROM | disk | FTP | other *** search
/ ST-Computer Leser 1998 October / STC_CD_10_1998.iso / BASE / PD_PATCH / PD_LIB.C < prev    next >
Encoding:
C/C++ Source or Header  |  1998-09-26  |  15.9 KB  |  563 lines
  1. /*             V 1.02
  2.         (c) 1997 by Dimitri Junker
  3.             Adenauerallee 30
  4.             52066 Aachen    */
  5. /* Dies sind die C-Funktionen, die in PD eingefügt werden können*/
  6. /* Zum Sprachgebrauch: Bei der 2 Monitorlösung unterscheide ich zwischen:
  7. AES-Monitor: der über den das AES ausgibt, also der an der Grafikkarte
  8. Bitmap-Monitor: der, der per Offscreen-Bitmap beschrieben wird
  9.     und am Original-Videoshifter hängt    */
  10.     
  11. /* -------------------------------------------------------------------- */
  12. /*        Includes                                                        */
  13. /* -------------------------------------------------------------------- */
  14.  
  15. #include "patch.h"
  16.  
  17. /* -------------------------------------------------------------------- */
  18. /*       Makros. & Konstanten                                           */
  19. /* -------------------------------------------------------------------- */
  20.  
  21. #define min(a, b)             ((a) < (b) ? (a) : (b))
  22. #define _sysbase    (0x4f2l)
  23.  
  24. /* -------------------------------------------------------------------- */
  25. /*        typedefs                                                        */
  26. /* -------------------------------------------------------------------- */
  27.  
  28. typedef char BOOLEAN;
  29.  
  30. /* -------------------------------------------------------------------- */
  31. /*         lokale Funktionsprototypen                                        */
  32. /* -------------------------------------------------------------------- */
  33.  
  34. void prg_reset_a(void);
  35. void Set_Gd_trm(void);
  36. long get_act_pd(void);
  37. long init_sup(void);
  38. long set_mon(void);
  39. long  get_cookie_jar();
  40. BOOLEAN get_cookie(long cookie_name, LONG *cookie_value);
  41. void draw_menu(void);
  42. long framelength(void);
  43. void v_clsvwk1(int handle);
  44.  
  45. /* -------------------------------------------------------------------- */
  46. /*        Globale Variablen                                                */
  47. /* -------------------------------------------------------------------- */
  48. extern MFDB M_pd;
  49. extern PDX X_pd;
  50. extern int b_23E58;
  51. /* -------------------------------------------------------------------- */
  52. /*        Funktionen                                                        */
  53. /* -------------------------------------------------------------------- */
  54.  
  55.  
  56. /* Im 2 Monitorbetrieb müssen PD teilweise andere Phys- bzw Logbase
  57. Adressen gemeldet werden, als dies die Betriebssystemroutinen
  58. machen würden.    */
  59. void *Physbase2(void)
  60. {    return(X_pd.p_baddr[X_pd.p_phys]);
  61. }
  62.  
  63. void *Logbase2(void)
  64. {    return(X_pd.p_baddr[X_pd.p_log]);
  65. }
  66. /* Diese Routine wird einmal statt der normalen v_opnvwk ausgeführt,
  67.     sie öfnet keine virtuelle WS, sondern eine Offscreenbitmap
  68.     an der Stelle, an der sich der Bildschirmspeicher befindet.
  69.     Au₧erdem wird sie noch einmal von Mxalloc2 aufgerufen, um noch
  70.     eine 2. Bitmap zu öffnen
  71.     Beim 1. Aufruf wird auch noch einiges initialisiert, daher der Name    */
  72. void v_opn_init2( int *work_in_alt, int *handle,int *work_out )
  73. {    VDIPB vdipb;
  74.     int contrl[15], work_in[20],i,bm;
  75.     long farben,c_val;
  76.     if(X_pd.p_baddr[0])    /* Aufruf von Mxalloc für Bitmap[1]    */
  77.     {    bm=1;
  78.         contrl[6]=work_in[0] =X_pd.p_bhdl[2];
  79.     }
  80.     else                    /* Aufruf von PD für Bitmap[0]        */
  81.     {    bm=0;
  82.         if(get_cookie('_VDO', &c_val))
  83.             X_pd.p_masch=(int)(c_val>>16);
  84.         else 
  85.             X_pd.p_masch=ST_MOD;
  86.         X_pd.p_pdhdl=handle;        /* hier speichert PD sein Handel    */
  87.         X_pd.p_baddr[0]=(void *)Supexec(init_sup);
  88.         X_pd.p_baddr[2]=Physbase();
  89.         X_pd.p_phys=X_pd.p_log=2;            /* Aktuell AES-Monitor*/
  90.         X_pd.p_bhdl[2]=contrl[6]=work_in[0] = graf_handle(&i, &i, &i, &i);
  91.     }
  92.     M_pd.fd_addr=X_pd.p_baddr[bm];
  93.     contrl[0]=100;
  94.     contrl[1]=0;
  95.     contrl[4]=0;
  96.     contrl[5]=1;
  97.     for(i=1;i<11;i++)
  98.         work_in[i]=work_in_alt[i];
  99.     work_in[11] = M_pd.fd_w-1;
  100.     work_in[12] = M_pd.fd_h-1;
  101.  
  102.     vdipb.contrl=contrl;
  103.     vdipb.intin =work_in;
  104.     vdipb.intout=work_out;
  105.     vdipb.ptsout=work_out + 45;
  106.     if(X_pd.p_vopn==NOVA)
  107.     {    work_in[13]=M_pd.fd_nplanes;
  108.         work_in[14]=1;
  109.         contrl[2]=6;
  110.         contrl[3]=15;
  111.         *((void **)(&contrl[7])) =M_pd.fd_addr;
  112.  
  113.     }
  114.     else    /* EdDi 1.1    */
  115.     {    work_in[13]=278;        /*  Breite eines Pixels in Mikrometern    */
  116.         work_in[14]=278;        /*  Höhe eines Pixels in Mikrometern    */
  117.         farben=1<<M_pd.fd_nplanes;
  118.         *(long *)&work_in[15]=farben;
  119.         work_in[17]=M_pd.fd_nplanes;
  120.         work_in[18]=0;
  121.         work_in[19]=1;
  122.         contrl[2]=0;
  123.         contrl[3]=20;
  124.         *((MFDB **)(&contrl[7])) =&M_pd;
  125.     }
  126.     vdi( &vdipb );            /* v_opnbm oder v_opnvwk2    */
  127.     
  128.     X_pd.p_bhdl[bm]=*handle = contrl[6];
  129.  
  130. /* Bei meinen ersten Versuchen erschien die Schrift Wei₧ auf Wei₧,
  131.     deshalb sicherheitshalber auf Schwarz setzen    */
  132.     contrl[0]=22;
  133.     contrl[1]=0;
  134.     contrl[2]=0;
  135.     contrl[3]=1;
  136.     contrl[4]=1;
  137.     contrl[5]=0;
  138.     contrl[6]=*handle;
  139.     work_in[0]=1;
  140.     vdipb.intout=work_in+3;
  141.     vdipb.ptsout=work_in+12;
  142.     vdi( &vdipb );            /* vst_color    */
  143.     M_pd.fd_addr=X_pd.p_baddr[0];
  144. }
  145. /* ist eigentlich Teil von v_opn_init2, mu₧ aber im Supervisormode
  146.     ausgeführt werden hier wird die Basepage ermittelt, die Bildschirm-
  147.     Adresse (Bitmap-Monitor) bestimmt und die Auflösung gesetzt*/
  148. long init_sup(void)
  149. {    long addr;
  150.     X_pd.p_bp=(BASPAG *)get_act_pd(); /* Die eigene BASEPAGE merken    */
  151.     addr=(long)(*(unsigned char *)0xffff8201l);
  152.     addr=addr<<8;
  153.     addr|=(long)(*(unsigned char *)0xffff8203l);
  154.     addr=addr<<8;
  155.     if(X_pd.p_masch!=ST_MOD)
  156.         addr|=(long)(*(unsigned char *)0xffff820dl);
  157.     *( char *)0xffff8260l=X_pd.p_res;
  158.     if(X_pd.p_masch==TT_MOD)
  159.     {    *( char *)0xffff8262l&=0xF8;
  160.         *( char *)0xffff8262l|=X_pd.p_res;
  161.     }
  162.     X_pd.p_frame=(int)framelength();
  163.     return(addr);
  164. }
  165. /* ist eigentlich Teil von v_opn_init1 und 2, mu₧ aber im Supervisormode
  166.     ausgeführt werden hier wird ermittelt, ob TRAP 6 oder 8 Byte auf den SSP
  167.     legt. Sie ist long, damit sie mit Supexec verwendet werden kann*/
  168. long framelength(void)
  169. {    return((*(int *)0x59EL) ? 8 : 6 );
  170. }    
  171. /* Im Einmonitorbetrieb ist zwar keine Alternative zu v_opnvwk
  172.     nötig, aber da die Stelle gut für Initialisierung ist...
  173.     Hier wird die Basepage ermittelt, Falls eine NOVA-Karte aktiv ist,
  174.     wird der Mxalloc Modus auf 3 gesetzt, für andere Karten einfach testen*/
  175. void v_opn_init1( int *work_in, int *handle,int *work_out )
  176. {    ICB *icb;
  177.     X_pd.p_bp=(BASPAG *)Supexec(get_act_pd); /* Die eigene BASEPAGE merken    */
  178.     v_opnvwk(work_in,handle,work_out );
  179.     if (get_cookie('IMNE',(long *)&icb))
  180.         X_pd.p_bs_m=3;
  181.     X_pd.p_ms=-1;
  182.     X_pd.p_frame=(int)Supexec(framelength);
  183.     X_pd.p_baddr[2]=Physbase();
  184. }
  185.  
  186. /* Die 2 Bitmap-WS abmelden und Bildschirm löschen, ist besser für
  187. den Monitor    */
  188. #pragma warn -par
  189. void v_clsbm( int handle )
  190. {    VDIPB vdipb;
  191.     int contrl[15],dummy[20],pxy[8];
  192.  
  193. /* Bildschirm löschen    */
  194.     pxy[0]=pxy[1]=pxy[4]=pxy[5]=0;
  195.     pxy[2]=pxy[6]=M_pd.fd_w-1;
  196.     pxy[3]=pxy[7]=M_pd.fd_h-1;
  197.     M_pd.fd_addr=X_pd.p_baddr[0];
  198.     vro_cpyfm(X_pd.p_bhdl[0],ALL_BLACK,pxy,&M_pd,&M_pd);
  199.  
  200. /*    Beide Workstations schlie₧en    */
  201.     if(X_pd.p_vopn==NOVA)
  202.     {    v_clsvwk(X_pd.p_bhdl[0]);
  203.         v_clsvwk(X_pd.p_bhdl[1]);
  204.     }
  205.     else
  206.     {    contrl[0]=101;
  207.         contrl[1]=contrl[2]=contrl[3]=contrl[4]=0;
  208.         contrl[5]=1;
  209.         vdipb.contrl=contrl;
  210.         vdipb.intin =dummy;
  211.         vdipb.intout=dummy;
  212.         vdipb.ptsout=dummy;
  213.         contrl[6] = X_pd.p_bhdl[0];
  214.         vdi( &vdipb );
  215.         contrl[6] = X_pd.p_bhdl[1];
  216.         vdi( &vdipb );
  217.     }
  218.         
  219. }
  220. #pragma warn +par
  221. /* NOVA-VDI <2.63 gibt bei vq_extnd eine falsche Anzahl Planes zurück*/
  222. void vq_extnd_nova( int handle, int owflag, int *work_out )
  223. {    vq_extnd(handle,owflag,work_out );
  224.     if(owflag)
  225.         work_out[4]=M_pd.fd_nplanes;
  226. }
  227. /* Mauszeiger auf 2. Bildschirm zeichnen...
  228. es wird davon ausgegangen, da₧ die Auflösung des AES-Monitors grö₧er
  229. oder gleich der des kleinen ist.*/
  230. void vq_mouse2( int handle, int *pstatus, int *x,int *y )
  231. {    int pxy[8],w,h,xv,yv;
  232.     MFDB m_s;
  233.     m_s=*&M_pd;
  234.     m_s.fd_w=m_s.fd_h=16;
  235.     m_s.fd_wdwidth=1;
  236.     /* Die Mausposition und Status erfragen    */
  237.     vq_mouse(handle,pstatus,x,y);
  238.     
  239.     /* Falls au₧erhalb des kleinen Bildschirms Offset verändern*/
  240.     xv=*x-X_pd.p_x_offs;
  241.     if(xv<0)
  242.     {    X_pd.p_x_offs=*x;
  243.         *x=0;
  244.     }
  245.     else
  246.     {    if(xv>=M_pd.fd_w)
  247.         {    X_pd.p_x_offs=*x+1-M_pd.fd_w;
  248.             *x=M_pd.fd_w-1;
  249.         }
  250.         else
  251.             *x=xv;
  252.     }
  253.     yv=*y-X_pd.p_y_offs;
  254.     if(yv<0)
  255.     {    X_pd.p_y_offs=*y;
  256.         *y=0;
  257.     }
  258.     else
  259.     {    if(yv>=M_pd.fd_h)
  260.         {    X_pd.p_y_offs=*y+1-M_pd.fd_h;
  261.             *y=M_pd.fd_h-1;
  262.         }
  263.         else
  264.             *y=yv;
  265.     }
  266.     /* Falls die Maus sich bewegt hat mu₧ der Zeiger neu gezeichnet werden    
  267.     natürlich nur wenn nicht der AES-Monitor aktiv ist*/
  268.     if((*x!=X_pd.p_x || *y!=X_pd.p_y)&& X_pd.p_phys!=2)
  269.     {    m_s.fd_addr=X_pd.p_msave;
  270.         /* Falls Mauszeiger an war Hintergrund restaurieren    */
  271.         if(X_pd.p_x!=-1)
  272.         {    w=min(16,M_pd.fd_w-X_pd.p_x)-1;
  273.             h=min(16,M_pd.fd_h-X_pd.p_y)-1;
  274.             pxy[0]=pxy[1]=0;
  275.             pxy[2]=w;
  276.             pxy[3]=h;
  277.             pxy[6]=w+(pxy[4]=X_pd.p_x);
  278.             pxy[7]=h+(pxy[5]=X_pd.p_y);
  279.             vro_cpyfm(handle,S_ONLY,pxy,&m_s,&M_pd);
  280.         }
  281.         /* Falls jetzt an: Mauszeiger zeichnen    */
  282.         if(!X_pd.p_ms)
  283.         {    w=min(16,M_pd.fd_w-*x)-1;
  284.             h=min(16,M_pd.fd_h-*y)-1;
  285.             pxy[2]=w+(pxy[0]=*x);
  286.             pxy[3]=h+(pxy[1]=*y);
  287.             pxy[4]=pxy[5]=0;
  288.             pxy[6]=w;
  289.             pxy[7]=h;
  290.             vro_cpyfm(handle,S_ONLY,pxy,&M_pd,&m_s);
  291.             m_s.fd_addr=X_pd.p_mmaske;
  292.             pxy[0]=pxy[1]=0;
  293.             pxy[2]=w;
  294.             pxy[3]=h;
  295.             pxy[6]=w+(pxy[4]=*x);
  296.             pxy[7]=h+(pxy[5]=*y);
  297.             vro_cpyfm(handle,NOTS_AND_D,pxy,&m_s,&M_pd);
  298.             m_s.fd_addr=X_pd.p_mzeiger;
  299.             vro_cpyfm(handle,S_OR_D,pxy,&m_s,&M_pd);
  300.             X_pd.p_x=*x;
  301.             X_pd.p_y=*y;
  302.         }
  303.         else
  304.             X_pd.p_x=-1;    /* beim nächsten mal nicht restaurieren    */
  305.     }
  306. }
  307. /* Falls im 1-Monitorbetrieb in die Menüzeile geklickt wird, diese restaurieren
  308.     falls die rechte Maustaste gedrückt wird Mauszeiger aktivieren*/
  309. void vq_mouse1( int handle, int *pstatus, int *x,int *y )
  310. {    vq_mouse(handle,pstatus,x,y );
  311.     if((*y<18 && *pstatus && !X_pd.p_ms)||X_pd.p_ms<0)
  312.         draw_menu();
  313.     if(*pstatus>1)    /*Eine andere Maustaste als die linke gedrückt*/
  314.     {    v_show_c(handle,0);
  315.         *pstatus&=1;    /*Vor PD verbergen    */
  316.     }
  317.     X_pd.p_ms=*pstatus;
  318. }
  319. /* Ein- und ausschalten des Mauscursors mu₧ auf die 2 Monitore verteilt
  320.     werden.    */
  321. void hide_curs2( void )
  322. {    int pxy[8],w,h;
  323.     MFDB m_s;
  324.     m_s=*&M_pd;
  325.     X_pd.p_ms++;
  326.     if(X_pd.p_phys==2)        /* AES-Monitor    */
  327.         v_hide_c(X_pd.p_bhdl[2]);
  328.     else                    /* Bitmap-Monitor    */
  329.     {    if(X_pd.p_x>-1)    /* Wenn er sichtbar war löschen */
  330.         {    m_s.fd_w=m_s.fd_h=16;
  331.             m_s.fd_wdwidth=1;
  332.             m_s.fd_addr=X_pd.p_msave;
  333.             w=min(16,M_pd.fd_w-X_pd.p_x)-1;
  334.             h=min(16,M_pd.fd_h-X_pd.p_y)-1;
  335.             pxy[0]=pxy[1]=0;
  336.             pxy[2]=w;
  337.             pxy[3]=h;
  338.             pxy[6]=w+(pxy[4]=X_pd.p_x);
  339.             pxy[7]=h+(pxy[5]=X_pd.p_y);
  340.             X_pd.p_x=-1;
  341.             vro_cpyfm(X_pd.p_bhdl[X_pd.p_phys],S_ONLY,pxy,&m_s,&M_pd);
  342.         }
  343.     }
  344. }
  345. void show_curs2( void )
  346. {    int x,y,ps,reset=1;
  347.     if(reset)
  348.     {    if(X_pd.p_ms)
  349.             X_pd.p_ms--;
  350.     }
  351.     else
  352.         X_pd.p_ms=0;
  353.     
  354.     if(X_pd.p_phys==2)
  355.     {    if(!X_pd.p_ms)
  356.             reset=0;
  357.         v_show_c(X_pd.p_bhdl[2],reset);
  358.     }
  359.     else
  360.         vq_mouse2(X_pd.p_bhdl[X_pd.p_phys],&ps,&x,&y);
  361. }
  362. #pragma warn -par
  363.  
  364. /* auch das Setscreen mu₧ auf die 2 Monitore verteilt werden    */
  365. void  Setscreen2( void *laddr, void *paddr, int rez )
  366. {    int bm;
  367.     if((long)laddr!=-1l)    /* Logbase ändern?    */
  368.     {    if(X_pd.p_baddr[0]==laddr)
  369.             bm=0;
  370.         else
  371.         {    if(X_pd.p_baddr[2]==laddr)
  372.                 bm=2;
  373.             else
  374.                 bm=1;
  375.         }
  376.         *X_pd.p_pdhdl=X_pd.p_bhdl[bm];    /* dadurch simulierenm, da₧ PD ein anderes Handle untergejubelt wird    */
  377.         X_pd.p_log=bm;        /* und merken    */
  378.     }
  379.     if((long)paddr!=-1l)    /* Physbase ändern    */
  380.     {    if(X_pd.p_baddr[0]==paddr)
  381.             bm=0;
  382.         else
  383.         {    if(X_pd.p_baddr[2]==paddr)
  384.                 bm=2;
  385.             else
  386.                 bm=1;
  387.         }
  388.         hide_curs2();
  389.         if(bm<2)                /* Bitmap-Monitor    */
  390.         {    M_pd.fd_addr=paddr; /* Adresse für Videoshifter umsetzen    */
  391.             Supexec(set_mon);
  392.         }        /* AES-Monitor ist ja immer sichtbar    */
  393.         X_pd.p_phys=bm;
  394.         show_curs2();
  395.     }
  396. }
  397. /* Bildschirmadresse für Videoshifter setzen, also eine Art Setscreen */
  398. long set_mon(void)
  399. {
  400.     *(unsigned char *)0xffff8201l=(unsigned char)((long)M_pd.fd_addr>>16);
  401.     *(unsigned char *)0xffff8203l=(unsigned char)((long)M_pd.fd_addr>>8);
  402.     if(X_pd.p_masch!=ST_MOD)
  403.         *(unsigned char *)0xffff820dl=(unsigned char)M_pd.fd_addr;
  404.     return(0l);
  405. }
  406.  
  407.      
  408. /* Mxalloc wird nur benutzt, um Speicher für den 2. und 3. Bildschirm zu
  409. reservieren, da PD davon ausgeht, da₧ sie ST-RAM benötigen. Da der
  410. Speicher für den 2. Bildschirm bereits vom AES reserviert ist, kann
  411. beim 1. Aufruf von Mxalloc der Speicher zurückgegeben werden, auf den
  412. die VideoBase Register zeigen. Da PD sicherheitshalber immer auf die
  413. nächste durch 256 teilbare Adresse aufrundet, und zwar so, da₧ wenn die 
  414. von Mxalloc zurückgegebene Adresse bereits durch 256 teilbar ist, er
  415. 256 hinzuaddiert:
  416. addr+=256;
  417. addr&=0xffffff00;
  418.  
  419. mu₧ diese Routine eine Adresse kleiner als Videobase zurückgeben.
  420.  PD ruft zuerst Mxalloc auf, wenn dieses einen Wert <=0 
  421. ( Assembler: ble ) zurückgibt wird nochmal mit Malloc probiert.
  422.  Es reicht also Mxalloc zu ersetzen, auch auf TOS Versionen ohne Mxalloc.
  423.  
  424.  Problem:
  425.  Falls Videobase nicht durch 256 teilbar ist, wird es Probleme geben.
  426.  Dies ist bei mir nie der Fall gewesen, das AES reserviert wohl aus
  427.  kompatibilitätsgründen immer Speicher an einer Seitengrenze. Falls aber
  428.  irgendwann andere Programme den 2. Bildschirm nutzen, und evtl.
  429.  Feinscrolling machen ist dies nicht mehr gesichert. Dann mü₧te z.B.
  430.  das Aufrunden weggepatcht werden:
  431.              add.l        #$100,D0
  432.             and.l        #-$100,D0
  433.  dies kommt 2* vor
  434.  Oder in v_opnbm neuer Speicher reserviert werden.*/
  435.  
  436. void  *Mxalloc2( long amount, int mode )
  437. {    int work_in[11],work_out[65],i;
  438.     void *ret;
  439.     switch((int)X_pd.p_mxa)
  440.     {    case 0:
  441.             X_pd.p_mxa++;
  442.             *X_pd.p_pdhdl=X_pd.p_bhdl[X_pd.p_log];
  443.             ret=(void*)((long)X_pd.p_baddr[0]-2l);
  444.             break;
  445.         case 1:
  446.             X_pd.p_mxa++;
  447.             ret=Mxalloc(amount,mode );
  448.             
  449.             for(i=0;i<10;i++)
  450.                 work_in[i]=1;
  451.             work_in[10]=2;
  452.             X_pd.p_baddr[1]=(void *)(((long)ret+256l)&0xffffff00l);
  453.             v_opn_init2(work_in,&X_pd.p_bhdl[1],work_out);
  454.             break;
  455.         default:            /* sollte zwar nicht vorkommen, aber...*/
  456.             ret=Mxalloc(amount,mode );
  457.     }
  458.     return(ret);
  459. }
  460. /*    falls in v_opn_init X_pd.p_bs_m umgesetzt wurde wird nicht mehr
  461. ST-RAM für den 2. Bildschirm verwendet    */
  462.  
  463. #pragma warn -par
  464. void  *Mxalloc1( long amount, int mode )
  465. {    return(Mxalloc(amount,X_pd.p_bs_m ));
  466. }
  467. #pragma warn +par
  468. /* fügt beim Programm-Reset auch noch ein Fclose aller offenen Dateien durch*/
  469.  
  470. void reset(void )
  471. {    int i;
  472.     long tst=64l;
  473.     for(i=6;i<32;i++) 
  474.     {    if((X_pd.p_flags[1]&tst)!=0l)
  475.             Fclose(i);
  476.         tst*=2l;
  477.     }
  478.     tst=1l;
  479.     for(i=32;i<64;i++) 
  480.     {    if((X_pd.p_flags[0]&tst)!=0l)
  481.             Fclose(i);
  482.         tst*=2l;
  483.     }
  484.     if(b_23E58!=-1)
  485.         prg_reset_a();
  486.     
  487. }
  488.  
  489. /*------------------------------------------------------------------*/
  490. /*    long get_act_pd()                                                */
  491. /*                                                                    */
  492. /*    Gibt die Basepage des aktuellen Proz. zurück                    */
  493. /*                                                                    */
  494. /*    Parameter:    keiner                                                */
  495. /*    Rückgabe :Die Funktion liefert als Ergebnis den Pointer,         */
  496. /*        allerdings als long, wegen Supexec                             */
  497. /*    (c) by Dimitri Junker 1996                                        */
  498. /*    nach Profibuch S.185                                            */
  499. /*    Besonderheit: mu₧ per Supexec aufgerufen werden                    */
  500. /*------------------------------------------------------------------*/
  501. long get_act_pd(void)
  502. {    BASPAG *bp;
  503.     SYSHDR *os;
  504.     
  505.     os=*(SYSHDR **)_sysbase;
  506.     os=os->os_base;
  507.     bp=*os->_run;
  508.     return((long)bp);
  509. }
  510.  
  511. BOOLEAN get_cookie(long cookie_name, LONG *cookie_value)
  512. {
  513.     LONG *cookie;
  514.     int ret;
  515.     
  516.     /* Zuerst einen Zeiger auf den Cookie holen */
  517.  
  518.     if((cookie = (long *)Supexec(get_cookie_jar))==NULL)
  519.         ret=0;
  520.     else
  521.     {
  522.         do
  523.         {
  524.             /* Ist es unser Cookie ? */
  525.             if(*cookie== cookie_name)
  526.                 break;
  527.             else
  528.             {
  529.                 /* nächster Cookie aus Jar */
  530.                 cookie = &(cookie[2]);
  531.             }
  532.         } 
  533.         while(cookie[0]);  /* solange nicht NULL-Cookie */
  534.     
  535.         if(!cookie[0])
  536.             ret=0;
  537.         else
  538.         {    *cookie_value=cookie[1];
  539.             ret=1;
  540.         }
  541.     }
  542.     return(ret);
  543. }
  544. /*------------------------------------------------------------------*/
  545. /*    long get_cookie_jar()                                            */
  546. /*                                                                    */
  547. /*    Ermittelt die Adresse des Cookie Jar.                            */
  548. /*                                                                    */
  549. /*    Parameter:keine                                                     */
  550. /*    Rückgabe :Adresse, falls der Cookie Jar gefunden wurde,            */
  551. /*              NULL falls kein Cookie-Jar                            */
  552. /*  Besonderheit: mu₧ per Supexec aufgerufen werden                    */
  553. /*    (c) by Dimitri Junker 1996                                        */
  554. /*------------------------------------------------------------------*/
  555.  
  556. long  get_cookie_jar()
  557. {
  558.     LONG *cookiejar;
  559.  
  560.     cookiejar = *((LONG **) 0x5a0L);
  561.     return((long)cookiejar);
  562. }
  563.