[C/C] Chiamare un programma da codice

[Zero-Giulio]

Ok, il titolo è da culo. Non sapevo cosa scrivere.

Allora, questo è il mio problema:

Ho due programmi (scritti in C), A e B. B va eseguito dentro A. Nel senso che:

1 - eseguo A fino a un certo punto, poi A scrive qualche files e va in pausa;

2 - eseguo B dando in input l'output di A ed eseguondolo fino alla fine. B restituisce una serie di files;

3 - riprendo A da dove lo avevo lasciato, facendogli leggere l'output di B e portandolo fino al suo termine.

Il punto fondamentale di tutto la questione è che i due programmi, A e B, devono rimanere DISTINTI. Non posso, in sostanza, scrivere un programma con dentro entrambi i codici, uno annidato nell'altro.

Forse vi suonerà strano, non so se vi viene in mente il perchè di questo. Non mi va di raccontarlo, e non vorrei entrare nei particolari.

L'unica cosa è che, di fatto, i due programmi devono rimanere distinti, e uno va eseguito quando l'altro è a metà, in pausa.

Attualmente, quello che faccio è rude: praticamente avvio A, poi lo metto in pausa (lui mi chiede inputs che io non gli do, per il momento), eseguo (dall'inizio alla fine) B, continuo con A (rispondendo all'input) fino alla fine.

Vorrei implementare una soluzione più elegante. A livello di codice, magari. E' possibile da codice far eseguire un programma? Preferisco soluzioni universali, ma in assenza di queste vanno bene anche soluzioni ad hoc per il mio SO, che è WinXp.

[agente mm8]

La mia è solo un'idea: potresti creare un file "pause", e verifichi con il programma A se questo file contiene qualche carattere in un ciclo while: se c'è passi avanti.
Con il programma B, dopo aver eseguito tutte le operazioni, scrivi uno 0 (o quello che vuoi) sul file "pause". Il programma A, vedendo che il file "pause" contiene un carattere, continuerà a fare il suo lavoro.
Ripeto, è solo una mia idea, spero possa esserti d'aiuto.

[Zero-Giulio]

Ma il programma B come lo chiamo?

Una volta che A entra in pausa, quello che vorrei è che il sistema lanciasse in automatico il programma B.

[BrutPitt]

Premetto: non so esattamente le tue esigenze, ma vedi se la finzione spawn, con le sue varianti, possa fare al caso tuo.

spawn esegue un processo (puoi passare parametri, environment: link a documentazione ) ed utilizzando la modalita' P_WAIT, attende la sua terminazione.

Per esempio:

#include <process.h>
#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    //stampa "inizio"
    cout << "inizio" << endl;

    //lancia "notepad.exe" ... e ne attende la chiusura...
    _spawnl( _P_WAIT, "c:/windows/notepad.exe", NULL );

    //stampa fine... dopo la chiusura di notepad
    cout << "fine" << endl;
    return 0;
}

[_Claudio]

A rigore non è possibile ciò che chiedi senza intervenire direttamente all'interno dei due programmi.
Si potrebbe agire sul contesto in cui operano (es. sviscerando i messaggi del sistema) ma è molto molto difficile, faresti prima a riscrivere tutto da zero.

[Zero-Giulio]

Proverò con la spawnl.

Se non funziona, beh... Lascio così com'è...

Alla fine il programma non devo mandarlo in giro. Serve solo a me. E io posso benissimo fare tutto a mano, tanto sono solo un apio di click.

Certo però che se la spawnl funziona come spero, potrebbe andare benone.

Unica cosa... Io programma in C. Lo so che nel titolo del topic stà [C\C++], ma in effetti nel mio programma c'è solo il C (e vorrei rimanesse solo lui).

La spawnl funziona lo stesso?

Per dire, posso evitare di scrivere cose come

using mainspace std

oppure sono indispensabili?

[_Claudio]

Originariamente inviato da Zero-Giulio

Proverò con la spawnl.

Se non funziona, beh... Lascio così com'è...

Alla fine il programma non devo mandarlo in giro. Serve solo a me. E io posso benissimo fare tutto a mano, tanto sono solo un apio di click.

Certo però che se la spawnl funziona come spero, potrebbe andare benone.

Unica cosa... Io programma in C. Lo so che nel titolo del topic stà [C\C++], ma in effetti nel mio programma c'è solo il C (e vorrei rimanesse solo lui).

La spawnl funziona lo stesso?

Per dire, posso evitare di scrivere cose come

using mainspace std

oppure sono indispensabili?

spawnl è una funzione di libreria, quindi puoi chiamarla tranquillamente sia con C che con C++...
http://msdn.microsoft.com/en-us/libr...sc(VS.80).aspx

In caso usi codice gestito (.net) allora
http://msdn.microsoft.com/en-us/libr...ss(VS.80).aspx

Anche se non vi è alcun riferimento circa la possibilità di controllare l'evoluzione del processo lanciato a meno di accedere al codice del processo.

[BrutPitt]

Originariamente inviato da Zero-Giulio

Proverò con la spawnl.

Se non funziona, beh... Lascio così com'è...

...

Unica cosa... Io programma in C. Lo so che nel titolo del topic stà [C\C++], ma in effetti nel mio programma c'è solo il C (e vorrei rimanesse solo lui).

La spawnl funziona lo stesso?

Come t'ha gia' scritto _Claudio, certamente ...

Stesso esempio ri-scritto strettamente in C

#include <process.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
    //stampa "inizio"
    printf("inizio\n");

    //lancia "notepad.exe" ... e ne attende la chiusura...
    _spawnl( _P_WAIT, "c:/windows/notepad.exe", NULL );

    //stampa fine... dopo la chiusura di notepad
    printf("fine\n");
    return 0;
}

Come vedi la chiamata a spawn e' rimasta invariata.

Unica cosa... il controllo dei processi e' legato al sistema operativo, per cui la spawn non la troverai nei sistemi unix-like (Linux, FreeBSD, MacOSX, etc...).
In tal caso dovrai gestire la cosa attraverso fork(), execv(...) e waitpid(...).

[Zero-Giulio]

Ho finalmente inserito la _spawnl nel mio codice, facendo girare il tutto. Che dire... Sembra andare bene.

Fa quello che volevo facesse: mette in pausa il programma "padre", chiama il programma "figlio", lo porta a termine, e infine riprende il padre da dove l'aveva lasciato.

Qualche domanda...

1 - con la _spawnl, così come l'ho scritta io, tutto viene fatto girare su una stessa finestra di comando. Poichè io vorrei arrivare ad annidazioni anche molto profonde, ciascuna con molte righe di output che mando su schermo, mi piacerebbe che ogni volta che la _spawnl chiama un nuovo processo, questo venisse aperto su una shella diversa. Si può fare a costo zero? Non è un'esigenza fondamentale, potrei sempre ridirigere l'output su un file, anzicche sullo schermo. Ma se fosse possibile aprire processi su finestre separate mi piacerebbe. Naturalmente a costo zero, o quasi, nel senso che se si, si può fare, ma è macchinoso, lascio perdere e ci rinuncio.

2 - cosa posso controllare per essere sicuro che tutto vada bene? Chessò, è possibile che magari il sistema faccia confusione e vada amischiare le variabili relative ai due processi. Considerate che con la _spawnl io chiamo lo stesso programma. In sostanza ho un eseguibile, pippo.exe, che copio n volte (p1.exe, p2.exe, ..., pn.exe), e poi da dentro p(i-1).exe chiamo pi.exe ciclicamente, fino a i=n. Ci sono rischi? C'è qualche controllo che posso fare?

[BrutPitt]

Cio' che mi viene in mente e' usare il comando "START" per aprire un programma in un'altra finestra.

E devi anche usare l'opzione /WAIT affinche' la finestra non venga aperta in modo asincorono.

Oltretutto essendo "START" un comando di cmd.exe, e non un programma, per poterlo utilizzare devi quindi chiamare cmd.exe a sua volta con l'opzione /c

Insomma la spawn verrebbe:

_spawnl( _P_WAIT, "c:/windows/system32/cmd.exe", "/c", "start", "/wait", "c:/windows/system32/ping.exe", "192.168.0.1", NULL );

In questo esempio apro il comando "ping 192.168.0.1" in un'altra finestra.

[Zero-Giulio]

Ho scoperto, con mia somma gioia, che il super computer dell'ateneo dove dovrei far girare il programma ha la Mandriva, non Windows.

In pratica devo compilare il codice sotto lunix.

Essendo scritto quasi interamente in Ansi C, immagino non avrò problemi, eccetto per la riga di codice di questo thread (da cui il "quasi interamente").

In sostanza, per il debug a casa ho windows e posso continuare a usare il vecchio codice (con la _spawnl), mentre per le run vere all'ateneo dovrei sostituire quella riga con fork ()-wait () ecc...

Volevo chiedervi, approfittando delle vostra competenza e disponibilità, se potevate farmi un esempio del tutto analogo in linux.

Per intenderci, io nel codice di adesso ho

#include <process.h>

_spawnl (_P_WAIT, progr_name, input_file_name, NULL);

dove progr_name e input_file_name sono due stringhe.

Cosa scrivere in linux?

Mi piacerebbe avere un esempio. So che esistono le documentazioni, ma "imparare" qualcosa direttamente su di loro lo trovo difficile. Sarà che non sono un programmatore.

Preferirei avere un esempio, così per chiarire il funzionamento, e poi eventualmente approfondire sulla documentazione una volta chiarite le idee.

Grazie :-)