Return to natfeats.c CVS log

Up to [HATARI the Atari ST Emulator] / hatari / tests / natfeats

Annotation of hatari/tests/natfeats/natfeats.c, revision 1.1.1.2

1.1       root        1: /*
                      2:  * natfeat.c - NatFeats API examples
                      3:  *
                      4:  * Copyright (c) 2014 by Eero Tamminen
                      5:  * 
                      6:  * NF initialization & calling is based on EmuTOS code,
                      7:  * Copyright (c) 2001-2003 The EmuTOS development team
                      8:  * 
                      9:  * This file is distributed under the GPL, version 2 or at your
                     10:  * option any later version.  See doc/license.txt for details.
                     11:  */
                     12: 
                     13: #if __GNUC__
                     14: # include <mint/osbind.h>
                     15: #else  /* VBCC/AHCC/Pure-C */
                     16: # include <tos.h>
                     17: #endif
                     18: #include "natfeats.h"
                     19: 
                     20: 
                     21: /* NatFeats available & initialized */
                     22: static int nf_ok;
                     23: 
                     24: /* handles for NF features that may be used more frequently */
                     25: static long nfid_print, nfid_debugger, nfid_fastforward;
                     26: 
                     27: 
                     28: /* API documentation is in natfeats.h header */
                     29: 
                     30: int nf_init(void)
                     31: {
                     32:        void *sup = (void*)Super(0);
                     33:        nf_ok = detect_nf();
                     34:        Super(sup);
                     35: 
                     36:        if (nf_ok) {
                     37:                /* initialize commonly used handles */
                     38:                nfid_print = nf_id("NF_STDERR");
                     39:                nfid_debugger = nf_id("NF_DEBUGGER");
                     40:                nfid_fastforward = nf_id("NF_FASTFORWARD");
                     41:        } else {
                     42:                Cconws("Native Features initialization failed!\r\n");
                     43:        }
                     44:        return nf_ok;
                     45: }
                     46: 
                     47: long nf_print(const char *text)
                     48: {
                     49:        if (nfid_print) {
                     50:                return nf_call(nfid_print, text);
                     51:        } else {
                     52:                Cconws("NF_STDERR unavailable!\r\n");
                     53:                return 0;
                     54:        }
                     55: }
                     56: 
                     57: long nf_debugger(void)
                     58: {
                     59:        if (nfid_debugger) {
                     60:                return nf_call(nfid_debugger);
                     61:        } else {
                     62:                Cconws("NF_DEBUGGER unavailable!\r\n");
                     63:                return 0;
                     64:        }
                     65: }
                     66: 
                     67: long nf_fastforward(long enabled)
                     68: {
                     69:        if (nfid_fastforward) {
                     70:                return nf_call(nfid_fastforward, enabled);
                     71:        } else {
                     72:                Cconws("NF_FASTFORWARD unavailable!\r\n");
                     73:                return 0;
                     74:        }
                     75: }
                     76: 
                     77: void nf_shutdown(void)
                     78: {
                     79:        long id;
                     80:        if(nf_ok && (id = nf_id("NF_SHUTDOWN"))) {
                     81:                void *sup = (void*)Super(0);
                     82:                /* needs to be called in supervisor mode */
                     83:                nf_call(id);
                     84:                Super(sup);
                     85:        } else {
                     86:                Cconws("NF_SHUTDOWN unavailable!\r\n");
                     87:        }
                     88: }
                     89: 
                     90: void nf_exit(long exitval)
                     91: {
                     92:        long id;
                     93:        if(nf_ok && (id = nf_id("NF_EXIT"))) {
                     94:                nf_call(id, exitval);
                     95:        } else {
                     96:                /* NF_EXIT is Hatari specific, NF_SHUTDOWN isn't */
                     97:                Cconws("NF_EXIT unavailable, trying NF_SHUTDOWN...\r\n");
                     98:                nf_shutdown();
                     99:        }
                    100: }
                    101: 
                    102: #ifdef TEST
                    103: 
                    104: /* show emulator name */
                    105: static void nf_showname(void)
                    106: {
                    107:        long id;
                    108:        if (nf_ok && (id = nf_id("NF_NAME"))) {
                    109:                long chars;
                    110:                char buffer[64];
                    111:                id |= 0x0001;  /* name + version */
1.1.1.2 ! root      112:                chars = nf_call(id, buffer, (long)sizeof(buffer)-2);
1.1       root      113:                buffer[chars++] = '\n';
                    114:                buffer[chars++] = '\0';
                    115:                nf_print(buffer);
                    116:        } else {
                    117:                Cconws("NF_NAME unavailable!\r\n");
                    118:        }
                    119: }
                    120: 
                    121: static int wait_key(void)
                    122: {
                    123:        while (Cconis()) {
                    124:                Cconin();
                    125:        }
                    126:        Cconws("\r\n<press key>\r\n");
                    127:        return Cconin();
                    128: }
                    129: 
                    130: int main()
                    131: {
                    132:        long old_ff;
                    133:        if (!nf_init()) {
                    134:                wait_key();
                    135:                return 1;
                    136:        }
                    137:        old_ff = nf_fastforward(1);
                    138:        nf_print("Emulator name:\n");
                    139:        nf_showname();
                    140:        nf_print("Shutting down...\n");
                    141:        nf_fastforward(old_ff);
                    142:        nf_exit(0);
                    143:        wait_key();
                    144:        return 0;
                    145: }
                    146: 
                    147: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.