Sont généreux chez Microsoft - Page 7

PpHd :
A oui ? Ben c'est faux Ne serait-ce que parce que tu peux rajouter une (grosse) couche d'assert au milieu de ton code, et une autre couche de programmes de test

nan ça peut être vrai :

void main(){
}

c'est du c j'ai peu écrit donc j'ai peu de risques d'avoir fait des fautes...

simple = moins de bug faux !=> complique=moins de bug.

je parle pas de simple, je parle de épuré...

Extrait d'une partie de l'analyseur lexical du compilo que je fais pour mon école (j'ai enlevé qques trucs du genre chaînes de caractères par souci de lisibilité) :

topics/2-29919-sont-genereux-chez-microsoft/7#189

Traduis-moi ça en C (avec la possibilité de définir une nouvelle méthode de lecture de caractères et la méthode de localisation d'erreur qui va avec, avec le look-ahead buffer, etc...)

File moi l'algo d'abord

Pollux >

Traduis-moi ça en C (avec la possibilité de définir une nouvelle méthode de lecture de caractères et la méthode de localisation d'erreur qui va avec, avec le look-ahead buffer, etc...)

[antiphrase]Trop facile ! [/antiphrase]

"File moi l'algo d'abord" > ???

Pollux :
Traduis-moi ça en C

On ne peut pas:

// Copyright (c) 2003 Paul Froissart
// Il est interdit de modifier ou de distribuer tout ou partie de ce code source
// sans mon consentement écrit.

J'attends toujours la lettre postale avec ton consentement écrit.

Kevin >

LOL
OK, je la refais (et j'en profite pour enlever les smileys ) :

// Copyright (c) 2003 Paul Froissart
// Il est interdit de modifier ou de distribuer tout ou partie de ce code source
// sans mon consentement écrit, sauf dans le cas d'une réécriture complète ou
// partielle en langage C, qui n'aura alors le droit d'être distribuée qu'à l'URL
// suivante :
//   http://www.yaronet.com/posts.php?sl=2&h=187&s=29919&p=7

// Définition du buffer d'un flux
template<class T>
class Buffer {
protected:
	virtual void get(T& ) = 0;
private:
	deque<T> buffer;
public:
	void operator+=(int v) { while (v--) (*this)++; }
	void operator++(int) { operator[](1); buffer.pop_front(); }
	T* operator->() { return &operator*(); }
	T& operator*() { return operator[](0); }
	T& operator[](unsigned int depth) {
		while (depth>=buffer.size()) {
			T value;
			get(value);
			buffer.push_back(value);
		}
		return buffer[depth];
	}
};

// Définition de l'analyseur lexical
class Lexer : public Buffer<lex>, private Buffer<unsigned char>, public ErrorLocator {
	Buffer<unsigned char>& p;
	KwDefMap kwMap;
	int radix(char c) { return isdigit(c)?(c-'0') : (isalpha(c)?(tolower(c)-'a'+10):36); }
	lex ExtractNum() {
		int base=10; long v=0;
		if (*p=='0') {
			p++, base=8;
			if (*p=='x' || *p=='b') p++, base=(*p=='x')?16:2;
		}
		while (isalnum(*p)) {
			int w=radix(*p);
			if (w>=base) uerr(ERR_SYNTAX);
			v*=base, v+=w, p++;
		}
		return v;
	}
	string ExtractID() {
		string s;
		while (isidch(*p)) s+=*p,p++;
		return s;
	}
	lex::Type CheckKeyword(string s) {
		KwDefMap::iterator i=kwMap.find(s);
		if (i==kwMap.end())
			return lex::none;
		return i->second;
	}
	lex Extract() {
		while (isspace(*p)) p++;
		if (!*p)
			return lex::eof;
		if (isdigit(*p))
			return ExtractNum();
		if (isidch(*p)) {
			string s=ExtractID();
			lex::Type t=CheckKeyword(s);
			return t?t : (lex)s;
		}
		if (*p=='\'' || *p=='"')
			return ExtractString();
		for (string s=string(1,p[0])+(char)p[1]+(char)p[2];!s.empty();s.resize(s.size()-1)) {
			lex::Type t=CheckKeyword(s);
			if (t) { p+=(int)s.size(); return t; }
		}
		uerr(ERR_SYNTAX);
	}
	void get(lex& v) { v=Extract(); }
public:
	Lexer() : p(*this) {
		for (int i=0;i<sizeof(kwList)/sizeof(KwDef);i++)
			kwMap.insert(kwList[i]);
	}
};

class FileLexer : public Lexer, public std::ifstream {
	int curline; string curfile;
	virtual string PositionInfo() {
		return (string)"in `"+curfile+"', line "+num2str(curline);
	}
public:
	FileLexer(char *v) : std::ifstream(v) { curfile=v; curline=1; }
	FileLexer(string v) : std::ifstream(v.c_str()) { curfile=v; curline=1; }
	void get(unsigned char& c) {
		c=0; // renvoyer 0 si eof()
		std::ifstream::get((char& ) c);
		if (c=='\n') curline++;
	}
};

C'est de la dictature. #pffffffffffffffffffffffffffffff#

Bah quoi, j'ai juste adapté ma licence originale

Vive le libre !!!! Vive la licence !!!

!baillonne snow-tiger


#mfffmhh#

Bah si je veux en faire un logiciel libre après pourquoi pas, mais pour l'instant il faut que tout soit de moi pour que je puisse valider ça comme projet.

Pas forcément: la Lesser GNU.

Et puis justement, ce que je comprends pas c'est pourquoi tu mets ce copyright dans tes sources ?
On risque pas d'en faire grand'chose de ces sources, c'est

J'ai juste laissé le copyright original, mais j'aurai aussi bien pu le -er

Pollux, c'est un truc que te fais pour les études ? Alors il appartient à ton école (je sais, c'est con, mais c'est arrivé à l'IUT à un gars qui avait fait un logiciel de traitement de texte+OCR en braille... bon, comme ils sont pas salauds, ils l'ont laissé faire)

OCR en braille

Il n'empêche que son soft, il l'a fait commercialiser par le biais d'entreprises spécialisées (il y avait aussi un module de conversion), et que ça a marché d'enfer. Il existe peu d'éditeurs de livre en braille, et c'est surtout un problème lié à l'impression en relief sur du papier relativement cher.

Pollux, c'est un truc que te fais pour les études ? Alors il appartient à ton école

Non non, j'ai demandé à mon prof.

C'est pas mal.

Bah ouais c une pure idée un OCR en braille, même si le marché doit pas être gigantesque.

Non, le marché n'est pas gigantesque, mais les développeurs non plus

Bah ouais c une pure idée un OCR en braille, même si le marché doit pas être gigantesque.

C'est pour ça que c'est bien: peu de gens le font, il est forcément celui à qui des entreprises vont
s'adresser de c fait. Donc c'est pour ça aussi que c'est bien, c'est original.

Je travaille pas sur du code d'autrui. Je travaille sur des algos. File moi l'algo explicatif de ce que fait ton code, et explique chaque detail.
Apres je le ferais.

Pas de "s" à la fin.

Bah il parse un flux de caractères (qui peut en fait être un fichier, un pipe, bref n'importe quoi), pour en extraire les lexèmes = identificateurs/symboles C/mots-clé/chaînes/nombres (j'ai enlevé la gestion des chaînes parce que c'est long et chiant). Evidemment, il faut pouvoir regarder en avance les lexèmes (indispensable pour repérer pas mal de constructions), c'est-à-dire pouvoir lire le contenu d'un lexème sans perdre les lexèmes qui le précèdent.

J'appelle ca un resume. Pas un algorithme.

Bah y a pas vraiment d'algorithme Regarde le code si tu veux, je ne peux pas t'en dire plus.

C long à installer VS
et ça bouffe la moitié des ressources