Speichererweiterung über Netzwerk

Hallo Freunde,

bevor ich schlafen gehe noch eine Idee:
Einen Treiber schreiben für Contiki, der aus einer Internettfestplatte eine Speichererweiterung macht, wie wäre das?

Also ein Treiber für die 1764 würd ich für sinnvoller erachten.

den treiber für die reu gibts ja schon in den cc65 libs... nur ist sowas halt bei contiki auch garnicht vorgesehen

Ja, ich bin es nochmal.

Also in C++ habe ich schon Klassen durch überlagerung des <<-Operators weggespeichert und auch gezogen >>.

Das Prinzip möchte ich erhalten, soweit es mein Programm betrifft, obwohl ich es in C umformen muss. :rotwerd:

Das geht durch eine laufende Numerierung. So wird eine Klasse (oder was nach meiner Art der Konvertierung davon übrig bleibt) in eine Datei T333909.tmp oder so - so die Idee- geschrieben werden und bei Bedarf in den rausgeholt werden mit der Nummer 333909.

Das sprengt die Möglichkeiten des Diskettenlaufwerks. Ich weiß, immer wenn ich davon anfange, wird es still. Aber einen TFTP zu FTP-Server fand ich beim Suchen eines TFTP-Servers. Ich bräuchte also nur ein TFTP-Client,

weil ich als Elektrotechnikstudent keine Ahnung von Netzwerken habe und das einfach nicht programmieren kann.

Helft ihr mir, indem ihr mir helft an den TFTP-Client zu kommen?

Ich schreibe hier ein bißchen Code rein, der zeigen soll, wie, den muß ich erst noch machen, laßt mir etwas Zeit...

Internetspeicher hinterher löschen:
uip_send("kill T<z a h l>.tmp"kill T*.tmp,sowieso);

TAB *dfo=new TAB ("Zeitung.tab")
umwandeln in
dfo=globalneu;
globalneu++;
platz_machen();
TAB ("Zeitung.tab");

this-Zeiger = die aktuelle TAB-Nummer der TAB im Speicher

TAB ("Zeitung.tab");
Bearbeitet wird die neue Tab im Speicher

:: werden vor der c-compelierung noch in __ gewandelt, der this zeiger steht fest

x-->f
wird vorher noch gewandelt in
mache_auf (x); (this-zeiger ändert sich nicht, obwohl objekt nicht im Speicher drinnen)
speicherobjekt.f
mache_zu (); (this-zeiger objekt wird wieder eingelesen)

this-zeiger-objekt
struct TAB
{ ...
}
TAB this->zeiger objekt

delete (TAB-zahl)
uip_send("kill T<z a h l>.tmp",sowieso);

~TAB()
delete (TAB-zahl)

mache_auf(x)
this-zeiger stapeln
T<x> in speicher

mache_zu (x)
this-zeiger irgendwo restapeln
t(stapel) in speicher zurück

a->Funktion
mache_auf (a);
stapel alten this zeiger
nehme a als neuen
Funktion ()
zurückstapelt
alter zeiger

Also eine C++-Klassenkonvertierung für meine bescheidenen Ansprüche gleich so, daß alles ausgelagert wird. Mit viel Mühe habe ich mein ganzes Programm (siehe Programmpakete) so ausgerichtet, daß das geht.

Erklärt wird das in meiner Antwort davor.

/*umlauteende*/

#include <stdlib.h>
#include <conio.h> //ehemals Hallo-World.
#include <dbg.h>

#include <stdio.h>
#include <string.h> //ehemals gunzip65
#include <zlib.h>

//#include <alloc.h>

int Blockanzahl=0; //Zwei statische.
void TABs__anzahl ()
{
// printf ("\"%d\"",Blockanzahl);
}

//Der C64er akzeptiert nur Klassen bei einem Overhead von mehr als dem halben Speicher, also besser nicht, stattdessen Block.
struct TAB {
int tabellendat; //c64 kann nur 8 Bit, eigentlich bool.
int unten; //Da jedes TAB seine eigene Kleine Kennungszahl beim C64 extra gelistet hat.
int rechts; //Da jedes TAB seine eigene Kleine Kennungszahl beim C64 extra gelistet hat.
int links; //Da jedes TAB seine eigene Kleine Kennungszahl beim C64 extra gelistet hat.
int oben; //Da jedes TAB seine eigene Kleine Kennungszahl beim C64 extra gelistet hat.
int neue; //Da jedes TAB seine eigene Kleine Kennungszahl beim C64 extra gelistet hat.
int Inhalt; //Kennungszahl des Inhaltes.
char* Text; // Der C64er akzeptiert nur CHAR*-String aus Speichergründen.
};

struct Blockliste{
struct Blockliste* danach;
struct TAB* richtiger_Zeiger;
int falscher_Zeiger;
};
struct Blockliste* Hauptliste=NULL;
void TABs__anhaengen (struct TAB* neu, int Blockanzahl)
{
struct Blockliste* zaehler=Hauptliste;
if (Hauptliste==NULL)
{
Hauptliste=(struct Blockliste*) malloc (sizeof(struct Blockliste));
(*Hauptliste).danach=NULL;
(*Hauptliste).falscher_Zeiger=Blockanzahl;
(*Hauptliste).richtiger_Zeiger=neu;
}
else
{
while ((*zaehler).danach!=NULL) {zaehler=(*zaehler).danach;};
(*zaehler).danach=(struct Blockliste*) malloc (sizeof(struct Blockliste));
zaehler=(*zaehler).danach;
(*zaehler).danach=NULL;
(*zaehler).falscher_Zeiger=Blockanzahl;
(*zaehler).richtiger_Zeiger=neu;
}
};

struct TAB Kurzzeit; //Eine Kurzzeitgedächtnistabelle gehört einfach dazu.
struct TAB This; //Ein statisches Element für den SWAP

#define FABRIKNEU 0;
#define TABELLENKOPF 1;
#define UEBERSCHRIFT 2;
#define BERICHT 3;
int stadium=0; //für den Konstruktor.

int TAB__konstruktor ()
{
int speicher_da=true; //angenommen genug Speicher für gleich.
int fehler=false;
int *x; //wird auch gleich erst gebraucht.
struct TAB *neu; //wird später gebraucht.
char* temp; //wird später gebraucht.
FILE *fp;


// Konstruktoren ggf. aufholen.
if (stadium==0)
{
Kurzzeit.tabellendat=false;
Kurzzeit.unten=NULL;
Kurzzeit.oben=NULL;
Kurzzeit.rechts=NULL;
Kurzzeit.links=NULL;
Kurzzeit.neue=NULL;
Kurzzeit.Inhalt=FABRIKNEU;
Kurzzeit.Text=NULL;
This.tabellendat=false;
This.unten=NULL;
This.oben=NULL;
This.rechts=NULL;
This.links=NULL;
This.neue=NULL;
This.Inhalt=FABRIKNEU;
This.Text=NULL;
Blockanzahl=2;
stadium++;
}

//Hier stellt sich dann immer die Frage, neu oder Diskette/Internettfestplatte anhand nennenswert weniger Speicher.
x=(int*) malloc (100*sizeof(struct TAB));
if (x==0) speicher_da=false;
if (speicher_da) free (x);

//je nach dem wird verfahren. Programmabbruch, falls Diskette voll.
Blockanzahl++;
if (speicher_da)
{
// printf ("Listenelement: ");
// TABs__anzahl ();
// Alles kleiner eine Sekunde getestet hier oben.
// Aber >10 Sekunden zusammen auch ohne Ausgabe.
// printf (".\n");

neu = (struct TAB*) malloc (sizeof (struct TAB));
TABs__anhaengen (neu, Blockanzahl);
(*neu).tabellendat=false;
(*neu).unten=NULL;
(*neu).oben=NULL;

IQ sollte mein Spitzname sein. Hoffe Dir gefällt, das Du hier nakt siehst.