Wenn das so einfach ist, dann mach ma..Nicht böse sein. Wir könnten ja ein kleines Spielchen un den Client einbauen ;D
Ich bin raus..
/* füllt eine liste mit den informationen die auf der Partition C: gefunden werden: */
lese_autostart_programme()
/* bennent datei um und updatet die liste */
deaktiviere_autostart_programm( programmname )
/* wartet auf tastendruck und fuert je nach taste ein anderes unterprogramm aus, bzw. beendet den bootmanager */
behandle_benutzereingabe( maximale_wartezeit )
/* listet die programmliste auf dem bildschirm auf */
programmliste_ausgeben( filter );
/* sorgt dafür das nur ein bestimmter typ von autostart programm auf dem bildschirm ausgegeben wird, z.b. .acc, .cpx oder .prg*/
filter_setzen( typ )
/* markiert ein programm innerhalb der liste */
cursor_setzen( y_posiiton )
SIMPLE BOOT MANAGER
[Filter: PRG]
-----------------
fastmous.prg
> mint.prx
nvdi.prg
---------
F1 = prg (default), F2 = acc, F3 = cpx, Enter = eintrag de/aktivieren, F10 = booten
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
string lese_autostart_programme($autodir)
{
DIR *dp;
struct dirent *ep;
dp = opendir ($autodir);
if (dp != NULL)
{
$i=0;
while (ep = readdir (dp))
$autofiles[$i] = ep->d_name;
(void) closedir (dp);
}
else
perror ("Couldn't open the directory");
return $autofiles;
}
Der Rückgabewert müßte ja rein theoretisch ein array sein, weiß nur nicht 100pro ob das so funktionieren würde, ist eine ganze weile her wo ich das letzte mal C Programmiert habe so 3 Jahre.
;************************************************************
;
; PureC Project File for SIMPLEBOOT
;
;************************************************************
SBOOT.PRG ;ausgabe programm name
; compiler setup:
; allow nested comments
; char is unsigned,
; no string mergin
; use absolute calls
.C [-C -K -M -P]
; Stackgroesse 4096
.L [-S=4096]
=
PCVSTART.O ; PureC startup code einbinden
MAIN.C ; Hauptmodul
;**********************************
;* LIBS
;**********************************
PCTOSLIB.LIB
PCGEMLIB.LIB
PCSTDLIB.LIB
PCEXTLIB.LIB
/* Standard TOS funktionen bekannt machen: */
#include <tos.h>
#include <vdi.h>
/* funktionen wie memcpy, strcpy... bekannt machen: */
#include <string.h>
/* auch die standard funktionen bekannt machen: */
#include <stdlib.h>
/* Erweiterte pureC Funktionen bekannt machen: */
#include <ext.h>
/* Textbildschirm Funktionen bekannt machen */
#include <screen.h>
/* ------------------ */
/* Globale Variablen: */
/* ------------------ */
/* Variable fuer VDI handle */
/* Wenn VDI funktionen aufgerufen werden, */
/* dann bezieht sich das auf ein Geraet, */
/* mit diesem handle teilen wir mit das wir */
/* auf den bildschirm ausgeben wollen... */
short vdih;
/* Array zum uebergeben von Parametern */
/* and VDI funktionen: */
short workin[16];
/* Array zum auslesen von VDI */
/* Rueckgabewerten */
short workout[58];
/* intialisiert variablen / umgebung des programms */
void init( void )
{
/* VDI Bildschirm-handle(1) oeffnen: */
memset( &workin, 0, 16*sizeof(short) );
/* VDI soll den Bildschirm nutzen: */
workin[0] = 1;
v_opnvwk( &workin, &vdih, &workout );
}
/* Funktion zur ausgabe von text an bestimmter position */
/* und ausgabefarbe (inv) */
void textxy(short x, short y, short inv, char * str)
{
if( inv ) {
Rev_on();
}
Goto_pos( x, y );
Cconws( str );
if( inv ) {
Rev_off();
}
}
/* Hauptprogramm, wird aufgerufen nach start des Programms: */
int main(void)
{ init();
textxy( 0, 0, 1, "SIMPLEBOOT" );
return( 0 );
}
(uebrigens auch bei purec sollte man pcstart.o anstatt pcvstart.o verwenden ..., war ein fehler )
/* funktionen wie memcpy, strcpy... bekannt machen: */
#include <string.h>
/* auch die standard funktionen bekannt machen: */
#include <stdlib.h>
#include <stdio.h>
/* Standard TOS funktionen bekannt machen: */
#include <tos.h>
#include <vdi.h>
/* Ein string konstante definieren: */
/* __DATE__ ist standard und wird vom */
/* Compiler auf das aktuelle Datum gesetzt */
#define VERSION "0.1 - (" __DATE__ ")"
/* Hauptprogramm, wird aufgerufen nach start des Programms: */
int main(void)
{
/* Aufrufen der OS Routine Cconws */
/* Diese ist in tos.h deklariert */
/* und enthalten in PCTOSLIB.LIB */
/* bzw. AHCCGEM.LIB */
/* und gibt einen Text auf der */
/* Konsole bzw. auf dem Bildschirm */
/* aus. */
Cconws( "SimpleBoot Version " VERSION "\r\n" );
return( 0 );
}
void file_list( char * path)
{
/* variable vom typ int anlegen: */
int err;
/* variable vom typ ffblk anlegen: */
struct ffblk blk;
/* erstes element auslesen: */
err = findfirst( path, &blk, 0xff);
while( err == 0 ){
/* datei name ausgeben: */
Cconws( blk.ff_name );
/* evt. weitere elemente auslesen ... : */
err = findnext( &blk );
}
}
TOS calls sind deutlich vorzuziehen, denn diese Pure C Calls rufen nichts anderes auf, und dazu noch mit einem unnötigen Overhead (mehr Datenstrukturen, mehr Unteraufrufe, mehr Sprünge -> langsamer als nötig)
Ausserdem sind die TOS Aufrufe auf jeden anderen Atari Compiler portierbar, z.B. auch den gcc.
Nach Abschluß der Funktion steht der Verzeichniseintrag unter der Diskettenübertragungsadresse DTA, die mit Fgetdta und Fsetdta ermittelt bzw. festgelegt werden kann. Die Informationen können dann der Struktur DTA entnommen werden.
zudem sollte doch lieber basic gewählt werden
mögliche erweiterbarkeit?
void main(int, char**);
void recursive_function(int, int);
void recursive_function(int amount, int max_depth) {
int count = amount + 1;
if (count > max_depth) {
return;
}
printf("%i ", count);
recursive_function(count, max_depth);
}
void main(int argc, char** argv) {
recursive_function(0, 10);
return 0;
}
printf("%i ", count);
recursive_function(count, max_depth);
/* funktionen wie memcpy, strcpy... bekannt machen: */
#include <string.h>
/* auch die standard funktionen bekannt machen: */
#include <stdlib.h>
#include <stdio.h>
/* Standard TOS funktionen bekannt machen: */
#include <tos.h>
#include <vdi.h>
/* Textbildschirm Funktionen bekannt machen */
/* Diese Datei enthaelt makros (d.h. nichts anderes */
/* als Aliase fuer bestimmte kommandos, wer */
/* interesse hat, was ich meine, schut einmal kurz */
/* die Datei hinein */
#include <screen.h>
/* Ein string konstante definieren: */
/* __DATE__ ist standard und wird vom */
/* Compiler auf das aktuelle Datum gesetzt */
#define VERSION "0.1 - (" __DATE__ ")"
/* Neue (eigene) funktion textxy, */
/* ------------------------------------------------ */
/* Diese Funktion ist im gegensatz zu main() nicht */
/* Pflicht. Es ist eine völlig eigens definierte */
/* Funktion die machen kann was sie will, bzw. was */
/* wir wollen. */
/* man koennte sich auch anders benennen oder andere*/
/* dinge tun lassen.... */
/* ------------------------------------------------ */
/* mit dieser Funktion kann man einen text an einer */
/* bestimmten stelle am Bildschirm ausgeben. */
/* Die ersten beiden Parameter bestimmen die */
/* Postion, sie sind vom typ short - das heisste */
/* bei purec: 16 bit maximalwert. */
/* der parameter inv bestimmt ob schwarz auf weiss */
/* oder weiss auf schwarz ausgegeben werden soll */
/* der letzte parameter beinhaltet eine */
/* Speicheradresse an die auszugebenden buchstaben */
/* stehen, das ende der buchstaben wird durch ein */
/* null byte markiert. (Uebernimmt der compiler */
/* fuer gewoehnlich */
/* Wichtig ist, das diese Funktion ueber main() */
/* ausprogrammiert wird, bzw. vor jeder anderen */
/* funktion in der diese funktin genutzt werden soll*/
/* der compiler kann nur aufrufen was er kennt.... */
/* es gibt auch die moeglichkeit funkt. aufzurufen */
/* die nach dem aufruf ausprogrammiert sind. */
/* aber das benoetigt eine vorherige "deklaration" */
/* - darauf verzichten wir in diesem projekt */
void textxy(short x, short y, short inv, char * str)
{
/* wenn parameter inv (invertiert) ungleich 0 */
/* ist-dann wird der reverse mode eingeschaltet */
/* d.h. weiss auf schwarze ausgabe */
if( inv != 0 ) {
/* Makro das in screen.h definiert wurde: */
Rev_on();
}
/* Jetzt wird der cursor an die gewuenschte */
/* Stelle gesetzt, diese anweisung ist ebenfalls*/
/* in screen.h definiert */
Goto_pos( y, x );
/* Diese funktion kennen wir schon: */
/* wir merken: Cconws gibt immer an der moment. */
/* cursor-position den text aus. */
Cconws( str );
/* wenn inv ungleich 0 ist, dann wird der */
/* modus wieder auf normal gesetzt. */
if( inv != 0 ) {
Rev_off();
}
}
/* Hauptprogramm, wird aufgerufen nach start des Programms: */
int main(void)
{
/* Anstatt Cconws rufen wir jetzt */
/* unsere eigene Textausgabe routine*/
/* auf! */
/* Spalte 2, Zeile 1, Invers, Text */
textxy( 3, 1, 1,"SimpleBoot Version " VERSION );
/* am ende wird nochmal ein Ruecklauf / */
/* Zeilenumbruch ausgegeben, damit die Konsole */
/* auf der wir ausgeben "sauber" ist. */
/* (testet einfach mal was passiert wenn man es */
/* weglaesst. */
Cconws("\r\n");
/* da die funktion main() den rueckgabetyp "int"*/
/* (je nach compiler einstellung 16 oder */
/* 32 bit zahl) hat, muss ein entsprechender */
/* wert zurueckgegeben werden - 0 bedeutet: kein*/
/* fehler. */
return( 0 );
}
textxy( 3, 1, 1,"SimpleBoot Version " VERSION );
getchar();
Ich bin mir sicher das der geneigte Leser noch nicht alles verstanden hat - z.b. diese Deklaration:
void textxy(short x, short y, short inv, char * str);
Ist denn str ein reservierter Begriff oder kann das ein belibieger Name sein?
char ist eine Anzahl von Zeichen und der * besagt das str ein Zeiger auf char ist?
In welcher Bildschirmauflösung soll das Programm eigentlich später laufen...oder in welcher besser nicht? Macht es Sinn für textxy die Auflösung vorher abzufragen?
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <tos.h>
#include <vdi.h>
#include <screen.h>
#define VERSION "0.1 - (" __DATE__ ")"
/* Diese Variable vom typ short (16 Bit bei PureC) */
/* ist neu im Programm! */
/* ------------------------------------------------ */
/* Da sie ausserhalb von einer Funktion deklariert */
/* wird - ist sie berall in dieser Datei erreichbar*/
/* also in jeder Funktion. Variablen die innerhalb */
/* einer funktion deklariert werden, sind nur so */
/* lange "am leben" wie die funktion l„uft..., */
/* solche Variablen nennt man dann "Lokale" Variabl.*/
/* Aber dies hier ist eine "Globale" Variable */
/* Alle globalen Variablen werden mit 0 */
/* initialisiert - zumindest bei C */
/* Das heisst "short quit;" ist gleichbedeutend mit */
/* "short quit = 0;" */
/* Das gillt aber nur fr Globale Variablen!!! */
/* Lokale Variablen enthalten Speicher Schrott -bis */
/* ihnen das erste mal ein Wert zugewiesen wird. */
/* D.h. - Lokale Variable immer anfangs mit einem */
/* Startwert versehen! */
/* Wir benutzen diese Variable um das Programm */
/* von verschiedenen Stellen aus beenden zu koennen */
/* aber seht selbst... */
short quit;
/* ------------------------------------------------ */
/* mit dieser Funktion kann man einen text an einer */
/* bestimmten stelle am Bildschirm ausgeben. */
/* Die ersten beiden Parameter bestimmen die */
/* Postion (X = Spalte, Y=Zeile) */
/* der parameter inv bestimmt ob schwarz auf weiss */
/* oder weiss auf schwarz ausgegeben werden soll */
/* der letzte parameter beinhaltet eine */
/* Speicheradresse an der die auszugebenden */
/* buchstaben stehen */
void textxy(short x, short y, short inv, char * str)
{
/* wenn parameter inv (invertiert) ungleich 0 */
/* ist-dann wird der reverse mode eingeschaltet */
/* d.h. weiss auf schwarze ausgabe */
if( inv != 0 ) {
/* Makro das in screen.h definiert wurde: */
Rev_on();
}
/* Jetzt wird der cursor an die gewuenschte */
/* Stelle gesetzt, diese anweisung ist ebenfalls*/
/* in screen.h definiert */
Goto_pos( y, x );
/* Diese funktion kennen wir schon: */
/* wir merken: Cconws gibt immer an der moment. */
/* cursor-position den text aus. */
Cconws( str );
/* wenn inv ungleich 0 ist, dann wird der */
/* modus wieder auf normal gesetzt. */
if( inv != 0 ) {
Rev_off();
}
}
/* Neue Funktion "input()" */
/* ------------------------------------------------ */
/* Diese Funktion liest ein Zeichen und reagiert */
/* darauf... */
void input( void )
{
/* Zeichen in eine 32 Bit Variable einlesen: */
/* hierbei ist wichtig: */
/* sobald GEM geladen wurde, hat diese Funktion */
/* ein bisschen andere Rueckgabewerte */
/* fuer einige Tasten - z.B. Funktionstasten */
/* unter GEM bekommen wir immer einen ASCII */
/* Wert ... */
/* Will man also die Funktionstasten abfragen */
/* im autostart - dann muss das anders erfolgen */
/* als unter GEM... aber dazu mehr in den */
/* naechsten folgen. Jetzt wird erstmal nur ein */
/* Buchstabe eingelesen! */
long key = Cnecin();
/* momentan interessiert uns nur der Ascii wert */
/* der Taste.... */
/* Es gibt auch Tasten bei denen der ASCII Wert */
/* 0 ist.... da interessiert uns dann ein */
/* anderer Bereich der Zahl.... */
/* Hier wird jetzt das Ascii Byte des Tasten */
/* codes durch eine Bin„re Und verknpfung */
/* extrahiert... bzw. alles andere ausgeblendet */
/* Der Ascii wert befined sich am ersten byte */
/* der 4 byte variable ( 4 byte = 32 bit): */
char ascii = (key & 0xFF);
/* Darauf achten das die Buchstaben - anders */
/* als Zeichenketten - in einzelne anfhrungs- */
/* gesetzt sind!!! */
/* der buchstabe wird daraufhin vom compiler */
/* in den "(Atari)-Ascii" Wert gewandelt. */
/* anstatt 'Q' koennte man auch die Zahl */
/* 81 nehmen - der Ascii wert fuer Q. Aber so */
/* ist es besser zu lesen! */
/* Hier wird jetzt abgefragt ob der Buchstabe */
/* das Kommando zum beenden enthaelt... */
if( ascii == 'Q' || ascii == 'q' ){
quit = 1;
} else {
/* hier wird der wert der variablen ausgegeben */
/* nur fuer informationszwecke */
/* ich gehe nicht naeher darauf ein */
/* es ist nur fuer info zwecke gedacht */
/* wer mehr wissen will schaut in andere */
/* dokumente.... */
printf("ascii: %d - keycode: %lu\n", ascii, key );
}
}
/* Hauptprogramm, wird aufgerufen nach start des Programms: */
int main(void)
{
/* Anstatt Cconws rufen wir */
/* unsere eigene Textausgabe routine*/
/* auf! */
/* Spalte 2, Zeile 10, Invers, Text */
textxy( 3, 1, 1,"SimpleBoot Version " VERSION );
/* Hier haben wir ein neues Programm-konstrukt */
/* eine schleife! Diese wird solange wiederholt */
/* bis die bedingung innerhalb der klammern */
/* nicht mehr zutrifft */
/* konkret wird hier immer wieder ein Buchstabe */
/* eingelesen - es sei denn die Variable quit */
/* enthaelt den Wert 1 - dann wird nicht weiter */
/* gemacht... */
while( quit != 1 ) {
input();
}
/* da die funktion main() den rueckgabetyp "int"*/
/* (je nach compiler einstellung 16 oder */
/* 32 bit zahl) hat, muss ein entsprechender */
/* wert zurueckgegeben werden - 0 bedeutet: kein*/
/* fehler. */
return( 0 );
}
[code]
[/code]
if( key == 'Q' ){
// beenden
}
else if( key == 'A' ) {
// ausgabe machen
}
else {
// nix...
}
#include <stdio.h>
int main(void)
{
char key;
printf("druecke Taste \"A\", \"a\" oder \"q\" um das Programm zu beenden\n");
while((key = getchar()) !='q') {
if (key == 'A')
{
printf("A gedrueckt\n");
}
else if(key == 'a')
{
printf("a gedrueckt\n");
}
}
}switch(var)
{
case 'a':
/* tu was */
break;
case 'b':
/* tu was anderes */
break;
default:
/* wenn nix zutrifft tu das hier */
break;
}switch((uint16_t)my32bit)