[C] Compilazione programmi

[lucas87]

Salve mi sono accorto di una cosa...alcuni programmi in C, compilano e vengono eseguiti correttamente totto LINUX con gcc o altro...ma sotto windows con DEV C++ invece da molti errori di compilazione e nn vanno mai.

COme mai????

[variabilepippo]

COme mai????

Forse perché richiedono librerie e caratteristiche presenti solo su Linux... Il porting in ambienti Windows di programmi sviluppati per Linux è facilitato da Cygwin (http://www.cygwin.com/).

[lucas87]

Ciao grazie della risspota...ed esiste un interfaccia che si puo usare sotto windows che ti faccia avere le librerie di linux...quindi che nn ti dii problemi per compilare programmi in C?

[niki89]

ciao non ne sono sicuro ma penso che non si possono mettere librerie di linux sotto windows

[variabilepippo]

Ciao grazie della risspota...ed esiste un interfaccia che si puo usare sotto windows che ti faccia avere le librerie di linux

Ci sono programmi che possono essere "portati" sotto Windows senza troppe difficoltà, altri che richiedono modifiche più o meno pesanti, altri che non possono essere compilati affatto. Tutto dipende dal programma, non si può dare una risposta valida in assoluto.

Il progetto Cygwin (http://www.cygwin.com/) può rendere meno traumatica la fase di compilazione di programmi Linux sotto Windows.

[lucas87]

siccome io e l'inglese ci odiamo a vicenda...nn ho capito molot...è un prog da scaricare?

o cosa?

grazie

[variabilepippo]

siccome io e l'inglese ci odiamo a vicenda...nn ho capito molot...è un prog da scaricare?

Un programmatore che non conosce l'inglese è equiparabile ad un giocatore di hockey su ghiaccio che non sa pattinare. :doh:

Cygwin è un ambiente che ricrea sotto Windows le condizioni per compilare programmi Linux, ovviamente non ti consentirà di compilare qualsiasi sorgente ma sempre meglio di nulla!

[lucas87]

ok l'ho scaricato e installato...mi apre una finestra stile dos e devo scrive il comando...per compilare che comando devo inserire?

[variabilepippo]

per compilare che comando devo inserire?

Gli stessi che utilizzeresti in Linux (make, configure, gcc, ...), come ti ho già detto Cygwin crea un ambiente Unix-like in Windows.

[lucas87]

L'avevo supposto...ma gcc nomefile.c nn va...dice command not found...

[variabilepippo]

.ma gcc nomefile.c nn va...dice command not found...

Ipotesi:

A) Non hai installato GCC. Cercalo all'interno della cartella di installazione.

B) La cartella con gli eseguibili di Cygwin non è tra quelle contenute nella variabile PATH di Windows. Se non è presente aggiungi la cartella di cui sopra.

[lucas87]

nn ho installato gcc...ho messo solo Cygwin

[variabilepippo]

nn ho installato gcc...ho messo solo Cygwin

Tra i programmi installabili con Cygwin c'è ANCHE GCC, ovviamente devi sceglierlo durante la fase di installazione. L'hai fatto?

Hai verificato se nella cartella dove hai installato Cygwin ci sia anche GCC?

La cartella con gli eseguibili di Cygwin è tra quelle definite dalla variabile PATH?

[variabilepippo]

Non ci hai ancora detto cosa stai cercando di compilare sotto Windows... Cygwin potrebbe essere inutile nel tuo caso.

[lucas87]

Allora...mi apre di aver scelto tutto quando installavo...cmq la cartella cygwin l'ha messa sotto C:\
Anche se nn trovo gcc nella carte di gygwin...cmq ho creato per un progetto di un esame all'unversità dei file per implementare analizzatore sintattico e lessicale per file di tipo xsml, in più parte del progetto prevedeva l'implementazione di funzioni per analizzare delle query sempre nel linguaggio in xsml, e l'ho dovuto fare sotto linux perchè sotto windows non compilava mai, menter sotto linux andava tutto bene. pero adesso nn posso più utilizzare linux e devo fare in modo di poter programmare in C con windows

[variabilepippo]

e l'ho dovuto fare sotto linux perchè sotto windows non compilava mai, menter sotto linux andava tutto bene. pero adesso nn posso più utilizzare linux e devo fare in modo di poter programmare in C con windows

Puoi rendere accessibile il tuo sorgente? Sarà più facile determinare perché non riesci a compilarlo in Windows. Possibili cause: errori da parte tua, uso di librerie specifiche per Linux, uso di caratteristiche tipiche di Linux, ecc.

[lucas87]

Ora posterò la prima parte del progetto che consiste nell'analizzatore lessicale...cmq voglio specificare che sotto linux funge...quindi il file è corretto.

sono 3 file, l'header, il main e il file con le funzioni chiamato dal main.

#ifndef LEX_H
#define LEX_H

#include <stdio.h>

/* stati dell'analizzatore lessicale */
typedef enum
{
/* analisi del contenuto di un tag */
LEX_STATE_CONTENT,
/* analisi di uno start-tag o end-tag */
LEX_STATE_TAG
} lex_state;

/* struttura che rappresenta un file da analizzare */
typedef struct
{
/* stream di input dell'analizzatore */
FILE *file;
/* stato dell'analizzatore */
lex_state state;
/* posizione del prossimo carattere dello stream */
int riga, colonna;
} lex_an;

/* enumerazione dei tipi di token dell'analizzatore lessicale */
typedef enum
{
ERROR,
OPEN_START_TAG,
OPEN_END_TAG,
CLOSE_TAG,
EQUAL,
NAME,
STRING
} token_type;

/* tipi di errore */
enum
{
ERR_BAD_ARG = 1,
ERR_INPUT,
ERR_MEM,
ERR_EOF,
ERR_INVALID_TOKEN,
ERR_FILE,
ERR_GENERIC
};

/* rappresenta il token */
typedef struct
{
/* testo del token */
char *text;
/* tipo di token */
token_type type;
/* posizione del token nel documento */
int riga, colonna;
} token;

/* imposta il prossimo token */
int get_next_token(lex_an *pla, token *ptk);

/* crea un nuovo analizzatore lessicale */
int new_lexical_analyzer(char *fname, lex_an *pla);

/* chiude l'analizzatore lessicale */
int close_lexical_analyzer(lex_an *pla);

#endif






#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <ctype.h>

#include "xsml_lex.h"

#define MAX_STRING_LEN 255

int prev_colonna;

char get_next_char(lex_an *la)
{
char c = fgetc(la->file);

if (c != EOF)
{
if (c == '\n') { la->riga++; prev_colonna = la->colonna; la->colonna = 1; }
else la->colonna++;
}

return c;
}

void unget_char(char c, lex_an *la)
{
ungetc(c, la->file);

if (c == '\n') { la->riga--; la->colonna = prev_colonna; }
else la->colonna--;
}

int is_tag_char(char c, int position)
{
/* deve iniziare per carattere alfabetico o _ */
if (position == 0)
return isalpha(c) || c == '_';
else
return isalpha(c) || isdigit(c) || c == '-' || c == '.' || c == '_';
}

int get_next_tag_token(lex_an *la, token *tok)
{
int max_string_len = MAX_STRING_LEN;

char *str = (char *)malloc(max_string_len);

/* chiude la stringa per evitare di farlo in caso di errore */
str[0] = 0;

/* posizione attuale all'interno del buffer str */
int k = 0;

tok->text = str;

if (feof(la->file))
{
tok->type = ERROR;
return ERR_EOF;
}

/* legge un carattere */
char c = get_next_char(la);

/* salta eventuali caratteri di separazione */
while(c == ' ' || c == '\n' || c == '\t')
{
tok->riga = la->riga;
tok->colonna = la->colonna;

if (feof(la->file)) return ERR_EOF;
c = get_next_char(la);
}

switch(c)
{
case '<':
if (feof(la->file))
{
tok->type = ERROR;
return ERR_INVALID_TOKEN;
}
c = get_next_char(la);

/* apre un end tag */
if (c == '/')
{
tok->type = OPEN_END_TAG;
if (feof(la->file))
{
tok->type = ERROR;
return ERR_INVALID_TOKEN;
}
}
else
{
/* apre uno start tag */
tok->type = OPEN_START_TAG;
unget_char(c, la);
}

do
{
c = get_next_char(la);

/* se si e' arrivati alla fine del buffer */
if (k == max_string_len-1)
{
max_string_len *= 2;
str = realloc(str, max_string_len);
if (str == NULL)
{
tok->type = ERROR;
tok->text[k] = 0;
return ERR_MEM;
}
tok->text = str;
}

/* scrive il carattere */
str[k] = c;
} while(!feof(la->file) && is_tag_char(c, k++));

if (feof(la->file))
{
tok->type = ERROR;
tok->text[k] = 0;
return ERR_EOF;
}

if (c != '>' && c != ' ' && c != '\n' && c != '\t')
{
tok->type = ERROR;
tok->text[k] = 0;
return ERR_INVALID_TOKEN;
}

k--;
if (k == 0)
{
tok->type = ERROR;
tok->text[1] = 0;
return ERR_INVALID_TOKEN;
}
if (c == '>') unget_char(c, la);

str[k] = 0;
break;

/* chiude un tag */
case '>':
tok->type = CLOSE_TAG;
la->state = LEX_STATE_CONTENT;
break;

case '=':
tok->type = EQUAL;
break;

case '"':
case '\'':
{
char open_quote = c;
tok->type = STRING;

if (feof(la->file))
{
tok->type = ERROR;
return ERR_INVALID_TOKEN;
}

do
{
c = get_next_char(la);
if (feof(la->file))
{
tok->type = ERROR;
tok->text[k] = 0;
return ERR_EOF;
}

/* se si e' arrivati alla fine del buffer */
if (k == max_string_len-1)
{
max_string_len *= 2;
str = realloc(str, max_string_len);
if (str == NULL)
{
tok->type = ERROR;
tok->text[k] = 0;
return ERR_MEM;
}
tok->text = str;
}

/* scrive il carattere */
str[k++] = c;
}
while(c != open_quote && c != '>' && c != '<');

if (open_quote != c)
{
tok->type = ERROR;
str[k] = 0;
return ERR_INVALID_TOKEN;
}
else k--;
}
break;

default:
/* dovrebbe essere un NAME */
tok->type = NAME;

if (feof(la->file))
{
tok->type = ERROR;
return ERR_INVALID_TOKEN;
}

while(1)
{
/* se sono caratteri speciali */
if (!isdigit(c) && !isalpha(c) && c != '_' && c != '-')
{
if ((c == '>')||(c == '='))
{
unget_char(c, la);
break;
}
else if ((c == ' ')||(c == '\n')||(c == '\t')) break;

/* altrimenti errore */
tok->type = ERROR;
tok->text[k] = 0;
return ERR_INVALID_TOKEN;
}

/* se si e' arrivati alla fine del buffer */
if (k == max_string_len-1)
{
max_string_len *= 2;
str = realloc(str, max_string_len);
if (str == NULL)
{
tok->type = ERROR;
tok->text[k] = 0;
return ERR_MEM;
}
tok->text = str;
}

/* scrive il carattere */
str[k++] = c;

c = get_next_char(la);
if (feof(la->file))
{
tok->type = ERROR;
tok->text[k] = 0;
return ERR_INVALID_TOKEN;
}
}

break;
}

/* chiude la stringa */
str[k] = 0;

return 0;
}

int get_next_content_token(lex_an *la, token *tok)
{
int max_string_len = MAX_STRING_LEN;

char *str = (char *)malloc(max_string_len);

/* chiude la stringa per evitare di farlo in caso di errore */
str[0] = 0;

/* posizione attuale all'interno del buffer str */
int k = 0;

tok->text = str;

tok->type = STRING;

/* finch� non si e' raggiunta la file del file */
while(!feof(la->file))
{
/* legge un carattere */
char c = get_next_char(la);

if (feof(la->file))
{
if (k == 0)
{
tok->type = ERROR;
tok->text[k] = 0;
return ERR_EOF;
}
break;
}

/* se si e' arrivati alla fine del buffer */
if (k == max_string_len-1)
{
max_string_len *= 2;
str = realloc(str, max_string_len);
if (str == NULL)
{
tok->type = ERROR;
tok->text[k] = 0;
return ERR_MEM;
}
tok->text = str;
}

str[k++] = c;

/* apertura di un tag */
if (c == '<')
{
/* torna indietro di un carattere nella lettura del file */
unget_char(c, la);
k--;

/* passa allo stato che si occupa dell'analisi del tag */
la->state = LEX_STATE_TAG;

if (k == 0) return get_next_tag_token(la, tok);
break;
}
}

str[k] = 0;

return 0;
}

int get_next_token(lex_an *la, token *tok)
{
tok->riga = la->riga;
tok->colonna = la->colonna;

if (feof(la->file))
{
tok->text = (char *)malloc(1);
tok->text[0] = 0;
tok->type = ERROR;
return ERR_EOF;
}

switch(la->state)
{
case LEX_STATE_CONTENT:
return get_next_content_token(la, tok);
break;

case LEX_STATE_TAG:
return get_next_tag_token(la, tok);
break;
}

return ERR_GENERIC;
}

int new_lexical_analyzer(char *filename, lex_an *la)
{
la->file = fopen(filename, "r");
if (la->file == NULL) return ERR_FILE;

la->state = LEX_STATE_CONTENT;
la->riga = 1;
la->colonna = 1;

return 0;
}

int close_lexical_analyzer(lex_an *la)
{
fclose(la->file);

return 0;
}




#include <stdio.h>
#include <stdlib.h>
#include "xsml_lex.h"

/* numero dei tipi di token (incluso il tipo sconosciuto) */
#define TOKEN_TYPES_NUM 8

/* stringhe associate ai tipi di token */
static char *token_types[TOKEN_TYPES_NUM] = {
"unknown token type",
"ERROR",
"OPEN_START_TAG",
"OPEN_END_TAG",
"CLOSE_TAG",
"EQUAL",
"NAME",
"STRING"
};

/* restituisce la string associata al tipo di token in input */
char *token_type_to_string(int token_type)
{
/* token sconosciuto */
if (token_type >= TOKEN_TYPES_NUM-1) return token_types[0];

/* token noto */
return token_types[token_type+1];
}

int main(int argc, char **argv)
{
int error_code;
lex_an la;
token tok;

/* controlla che il numero di parametri sia 1 (il nome del file) */
if (argc != 2)
{
printf("Uso: lex_an <nome_file.xsml>\n");
return 1;
}

/* crea l'analizzatore lessicale */
if (error_code = new_lexical_analyzer(argv[1], &la))
{
printf("new_lexical_analyzer() ERROR_CODE = %d\n", error_code);
return error_code;
}

/* ottiene e stampa tutti i token contenuti nel file xsML */
do
{
error_code = get_next_token(&la, &tok);
if (tok.type == CLOSE_TAG || tok.type == EQUAL)
printf("%d,%d\t%s\n",
tok.riga, tok.colonna, token_type_to_string(tok.type));
else
printf("%d,%d\t%s\t\"%s\"\n",
tok.riga, tok.colonna, token_type_to_string(tok.type), tok.text);
}
while(!error_code);

printf("get_next_token() ERROR_CODE = %d\n", error_code);

/* chiude l'analizzatore lessicale */
if (error_code = close_lexical_analyzer(&la))
{
printf("close_lexical_analyzer() ERROR_CODE = %d\n", error_code);
return error_code;
}

return 0;
}



Il primo è l'header, il secondo il file con le funzioni, il terzo il main.

[variabilepippo]

Ora posterò la prima parte del progetto che consiste nell'analizzatore lessicale...cmq voglio specificare che sotto linux funge...quindi il file è corretto.

Nessuno lo mette in dubbio, il fatto che compili sotto Linux non significa che funzionerà necessariamente anche su Windows senza modifiche. Dovresti mettere TUTTO il sorgente in un file zippato e pubblicarlo su uno spazio Web (un tuo sito oppure su servizi tipo DepositFiles (http://depositfiles.com/en/)).

[lucas87]

Forse ho risolto sono stato un emerito coglione...basta usare dev c++, pero bisogna creare un nuovo progetto e mettere tutti e 3 i file che ho postato su quel progetto e compila e crea l'exe...l'unica cosa..che quando lancio l'exe mi da schermata dos per un secondo e poi esce senza farmi vedere niente, ho provato nel main alla fine sia a return 0, sia system("PAUSE") sia getchar().

[cionci]

Eseguilo da lanciando un prompt dei comandi: Start -> Esegui -> cmd -> Invio
Ti sposti nella directory del tuo progetto entri nella versione - suppongo - debug ed esegui il file. Probabilmente hai una exit prima e ti esce senza aspettare.

[lucas87]

Grazie a Cionci e a tutti gli altri...avevo pensato infatti di eseguirlo da dos e infatti va.

Potete chiudere.