sempre da Ubuntu Forum Italia

in questa thread

http://forum.ubuntu-it.org/viewtopic.php?f=33&t=540147

una domanda pertinente, ma le risposte latitano, come volevasi dimostrare...
dove sono i veri programmer? ah già ma esistono su quel forum? Penso di si, almeno vi erano, poi tra Ban e sospensioni e troll e spam, sono rimasti i Troll, Spammer e vari ma chi sa? NO

ma per fortuna in Italia vi sono Forum che sanno, hanno purtroppo poco seguito....

si si non conta il fatto che di avere tanti utenti, solo perchè hanno una comunità, in questo caso Ubuntu molto numerosa, ma il basso non ha mai fine....

(facile parlare, io come adesso non posso seguire i miei forum preferiti, ma non perchè sono  pigra, o non mi interesso più i computer o l'informatica, anzi... ma devo mettere su casa e famiglia, quindi per ora mi dedico a questo)

ma appena possibile mi dedicherò come prima, mii come prima? meglio penso!

Erika

colore caratteri, colore sfondo

dopo varie ricerche e prove ho finalmente capito come avere nel terminale caratteri rossi e sfondo giallo da una mia applicazione. ecco due esempi, uno in c e uno in script sh fond_color.c

/* * ---------------------------------------------------------------------- * by Erika * begin : september 02 2011 * Last change: september 03 2011 * * compilare with: * gcc -g -Wall fond_color.c -o fond_color * per avviarlo ./fond_color *----------------------------------------------------------------------- */ #include int main() { int attributo = 0, fore_ground = 0, back_ground = 0; for (attributo = 0; attributo <= 7; ++attributo) { printf ("--------------------------------------------------------\n"); printf ("ESC[%d;Foreground;Background -\n", attributo); for (fore_ground = 30; fore_ground <= 37; ++fore_ground) { for (back_ground = 40; back_ground <= 47; ++back_ground) { printf ("\e[%d;%d;%dm %d;%d \e[00m", attributo, fore_ground, back_ground, fore_ground, back_ground); } printf ("\n"); } } return (0); }

colori_bash.sh

#!/bin/sh #----------------------------------------------------------------------- # by Erika # begin : september 01 2011 # Last change: september 03 2011 # # per renderlo eseguibile # chmod +x colori_bash.sh # per avviarlo ./colori_bash.sh #----------------------------------------------------------------------- for attr in 0 1 4 5 7 ; do echo "--------------------------------------------------------" printf "ESC[%s;Foreground;Background - \n" $attr for fore in 30 31 32 33 34 35 36 37; do for back in 40 41 42 43 44 45 46 47; do printf '\033[%s;%s;%sm %02s;%02s \033[0m' $attr $fore $back $fore $back done printf '\n' done done

file del compito

/* Esercizio 16, creare applicativo in terminale
* scrivere le seguenti funzioni:
* da una stringa, passare la stringa alla rovescio, usare malloc e free
* scrivere una stringa da terminale e dare numero caratteri
* togliere il carattere \n dalla stringa
* leggere il path corrente
* leggere i file della directory corrente, non in ordine
* avere come minimo due file *.h e relativi *.c, avere un file main.c, avere un makefile
* dal makefile avere la possibilità di generare un file *.tar.gz e cancellare i file *.o e l'eseguibile
*/

Main1.c

/* programma test reverse string */
/* non funziona con la localizzasione Italiana, è viene scritto con ??,
* la soluzione la so, ma i soliti sapientoni dei forum\blog di programmazione,
* fanno solo polemiche, nhe'
*
*/
/* Esercizio 16, creare applicativo in terminale
* scrivere le seguenti funzioni:
* da una stringa, passare la stringa alla rovescio, usare malloc e free
* scrivere una stringa da terminale e dare numero caratteri
* togliere il carattere \n dalla stringa
* leggere il path corrente
* leggere i file della directory corrente, non in ordine
* avere come minimo due file *.h e relativi *.c, avere un file main.c, avere un makefile
* dal makefile avere la possibilità di generare un file *.tar.gz e cancellare i file *.o e l'eseguibile
*/

#include
#include
#include
#include
#include
#include
#include
#include
#include "scrivoleggo.h"
#include "reverse.h"

/* int main (int, char **); */

int main (int argc, char **argv)
{
int x = 0;
char a_uno[] = "int main (int argc, char **argv)";

char line[MAX_LINEA];
char miapath[PATH_MAX + 1];

printf ("%s\n", a_uno);
rovescio (a_uno, strlen (a_uno));
printf ("%s\n", a_uno);

strcpy (miapath, leggopath ());
printf ("il mio path %s\n", miapath);
rovescio (miapath, strlen (miapath));
printf ("in reverse: %s\n\n", miapath);

/* per fermare l'immissione dare ctrl C o ctrl D in Linux\freeBSD */
while (getlinea (line, sizeof line) > 1)
{
discardnewline (line);
rovescio (line, strlen (line));
printf("%s\n", line);
}

printf ("\n");
x = leggodirectori ((leggopath ()), 0);

return (0);
}

reverse.h

/* reverse. prova string, header */

#ifndef REVERSE_H
#define REVERSE_H

#define MAX_LINEA 1024

/*
* rovescio, per invertire una stringa o frase
*
* input: stringa da invertire, lunghezza stringa da invertire
* output: stringa invertita
*
*/
char *rovescio (char *, const int );

/*
* cancello il punto a capo (newline '\n')
*
* input: stringa controllo
* output: stringa senza newline
*
*/
void discardnewline (char *);

#endif

reverse.c

/* prova reverse string, funzioni varie */

#include
#include
#include
#include
#include "reverse.h"

char *rovescio (char *s, const int lung)
{
int l = lung,
x = 0;
char *p_dummy; /* puntatore a caratteri per rovesciare la stringa */

/* verifico se vi è abbastanza memoria da allocare */
if(!(p_dummy = malloc (l * sizeof (*p_dummy))))
{
fprintf (stderr,"memoria non allocata"); /* stampo un mess. in stderr su video */
exit (EXIT_FAILURE); /* Esco se ho memoria insufficiente. */
}

--l; /* diminuisco il valore per l'indice, in C partono da zero */
for (x = 0; x < lung; x++) { p_dummy[l] = s[x]; --l; } p_dummy[lung] = '\0'; /* aggiungo la fine stringa */ strcpy (s, p_dummy); /* copio la stringa invertita */ free (p_dummy); /* libero memoria allocata */ return (s); } void discardnewline (char *s) { int i; for(i = 0; s[i] != '\0'; i++) { if(s[i] == '\n') s[i] = '\0'; } }

scrivoleggo.h

/* input wrote read prova string, header */

#ifndef SCRIVOLEGGO_H
#define SCRIVOLEGGO_H

/*
* scrivo la linea con tastiera
*
* input: stringa da scrivere, massima lunghezza linea
* output: numeri caratteri scritti (da K&C book "language C", the bible for me)
*
*/
int getlinea (char *, const int );

/*
* scansiono directory
*
* input: stringa precorso directory da scansionare, valore numero file
* output: numero file scansionati
*
*/
int leggodirectori (char *, int );

char *leggopath (void);

#endif

scrivoleggo.c

/* prova wrote read string, funzioni varie */

#include
#include
#include
#include
#include
#include
#include
#include
#include "scrivoleggo.h"

int getlinea (char *s, const int lim)
{
int c, i;

for(i = 0; i < lim - 1 && (c = getchar()) != EOF && c != '\n'; ++i) { s[i] = c; } if(c == '\n') { s[i++] = c; } s[i] = '\0'; return i; } int leggodirectori (char *s, int a) { int x = a; DIR *dir; struct dirent *drent; if((dir = opendir(s)) == NULL) { fprintf(stderr, "Errore opendir()\n"); return EXIT_FAILURE; } while((drent = readdir(dir)) != NULL) { fprintf(stdout, "--> %s\n", drent->d_name);
++x;
}

if(closedir(dir) < 0) { fprintf(stderr, "Errore closedir()\n"); return EXIT_FAILURE; } return (x); } char *leggopath (void) { char *miopath; char miobuff[PATH_MAX + 1]; miopath = getcwd( miobuff, PATH_MAX + 1 ); if( miopath != NULL ) { printf( "My working directory is --<%s>-- done\n", miopath );
}

return (miopath);
}

makefile

# -
# makefile by Erika
# se si ha bisogno della libreria matematica con math.h
# togliere il # davanti a -lm nella linea CFLAGS.
# ricordarsi di cambiare i nomi *.h e *.o, se no contattarmi per avere
# un applicazione(GPL) che leggendo una directory, mette i nomi *.h e *.c
# ricava i nomi *.o dai file *.c (*.cpp) e chiede il compilatore (gcc g++ o altro)
# chiede il nome eseguibile e altro ...
# -
# non la metto tale applicazione(GPL) perchè funziona solo in Linux\freeBSD,
# e dopo tante polemiche con i sapientoni dei vari forum/blog di programmazione
# che si ARRANGINO "loro" i sotutto, nhe', a scuola i proff. hanno detto che va bene ...
# -

CC=gcc
CFLAGS=-Wall -g -pedantic #-lm
STDE=-D_GNU_SOURCE
DEPS = reverse.h scrivoleggo.h
SOURCES := main1.c reverse.c scrivoleggo.c
OBJ = main1.o reverse.o scrivoleggo.o
RM= rm -f
ARCHIVIO := tar -cf
COMPRESSO := gzip
PROGRAMMA := Rovescio

.c.o:
$(CC) -c $(CFLAGS) $(STDE) $(SOURCES) $(DEPS)

all: rovescio

rovescio: $(OBJ)
$(CC) $(OBJ) -o rovescio

.PHONY: clean cleanall tarzippare
clean:
$(RM) -f $(OBJ)

cleanall: clean
$(RM) -f rovescio *.h.gch
# per i file *.h.gch ho dato da terminale: ulimit -c unlimited per il core o gdb core

# creo un file .gz, con i sorgenti
tarzippare: clean cleanall
$(RM) $(PROGRAMMA).tar.gz
$(ARCHIVIO) $(PROGRAMMA).tar $(SOURCES) $(DEPS) makefile
$(COMPRESSO) $(PROGRAMMA).tar

aggiornato il compito

modificato il compito, fatto un nuovo makefile e aggiunto da terminale
[b]ulimit -c unlimited[/b]
per avere il file core o i file *.h.gch per il gdb debug

# -
# makefile by Erika
# se si ha bisogno della libreria matematica con math.h
# togliere il # davanti a -lm nella linea CFLAGS.
# ricordarsi di cambiare i nomi *.h e *.o, se no contattarmi per avere
# un applicazione(GPL) che leggendo una directory, mette i nomi *.h e *.c
# ricava i nomi *.o dai file *.c (*.cpp) e chiede il compilatore (gcc g++ o altro)
# chiede il nome eseguibile e altro ...
# -
# non la metto tale applicazione(GPL) perchè funziona solo in Linux\freeBSD,
# e dopo tante polemiche con i sapientoni dei vari forum/blog di programmazione
# che si ARRANGINO "loro" i sotutto, nhe', a scuola i proff. hanno detto che va bene ...
# -

CC=gcc
CFLAGS=-Wall -g -pedantic #-lm
STDE=-D_GNU_SOURCE
DEPS = reverse.h scrivoleggo.h
SOURCES := main1.c reverse.c scrivoleggo.c
OBJ = main1.o reverse.o scrivoleggo.o
RM= rm -f
ARCHIVIO := tar -cf
COMPRESSO := gzip
PROGRAMMA := Rovescio

.c.o:
$(CC) -c $(CFLAGS) $(STDE) $(SOURCES) $(DEPS)

all: rovescio

rovescio: $(OBJ)
$(CC) $(OBJ) -o rovescio

.PHONY: clean cleanall tarzippare
clean:
$(RM) -f $(OBJ)

cleanall: clean
$(RM) -f rovescio *.h.gch
# per i file *.h.gch ho dato da terminale: ulimit -c unlimited per il core o gdb core

# creo un file .gz, con i sorgenti
tarzippare: clean cleanall
$(RM) $(PROGRAMMA).tar.gz
$(ARCHIVIO) $(PROGRAMMA).tar $(SOURCES) $(DEPS) makefile
$(COMPRESSO) $(PROGRAMMA).tar