--- ply-3.3-orig/ply/yacc.py	2009-09-02 16:27:23.000000000 +0200
+++ ply-3.3-patched/ply/yacc.py	2010-04-13 11:30:28.753330468 +0200
@@ -303,7 +303,7 @@
 
         # If input was supplied, pass to lexer
         if input is not None:
-            lexer.input(input)
+            lexer.input(input.readline())
 
         if tokenfunc is None:
            # Tokenize function
@@ -341,6 +341,11 @@
             if not lookahead:
                 if not lookaheadstack:
                     lookahead = get_token()     # Get the next token
+                    
+                    # If we finished with the current line, then process the next
+                    if lookahead is None and input is not None:
+                        lexer.input(input.readline());
+                        lookahead = get_token()     # Get the next token
                 else:
                     lookahead = lookaheadstack.pop()
                 if not lookahead:
@@ -614,7 +619,7 @@
 
         # If input was supplied, pass to lexer
         if input is not None:
-            lexer.input(input)
+            lexer.input(input.readline())
 
         if tokenfunc is None:
            # Tokenize function
@@ -647,6 +652,11 @@
             if not lookahead:
                 if not lookaheadstack:
                     lookahead = get_token()     # Get the next token
+
+                    # If we finished with the current line, then process the next
+                    if lookahead is None and input is not None:
+                        lexer.input(input.readline());
+                        lookahead = get_token()     # Get the next token 
                 else:
                     lookahead = lookaheadstack.pop()
                 if not lookahead:
@@ -886,7 +896,7 @@
 
         # If input was supplied, pass to lexer
         if input is not None:
-            lexer.input(input)
+            lexer.input(input.readline())
 
         if tokenfunc is None:
            # Tokenize function
@@ -919,6 +929,11 @@
             if not lookahead:
                 if not lookaheadstack:
                     lookahead = get_token()     # Get the next token
+
+                    # If we finished with the current line, then process the next
+                    if lookahead is None and input is not None:
+                        lexer.input(input.readline());
+                        lookahead = get_token()     # Get the next token
                 else:
                     lookahead = lookaheadstack.pop()
                 if not lookahead:

f = open('data.txt')
yacc.parse(f)
f.close()

import StringIO
yacc.parse(StringIO.StringIO("1 + 2 + 3 + 4 + 5"))

import StringIO
file = open('data2.txt')
line = file.readline()
while line != "":
    yacc.parse(StringIO.StringIO(line))
    line = file.readline()
f.close()

// File: Voto.h
 
#ifndef VOTO_H_
#define VOTO_H_
 
#include<string>
using namespace std;
 
enum Tipo { SENATO = 0, CAMERA, REGIONE };
 
/*
 
Un oggetto di tipo Voto rappresenta l'espressione di una preferenza di un elettore
su una delle tre possibili schede: SENATO, CAMERA e REGIONE.
 
Se il flag "nullo" e' true, allora il voto e' nullo.
 
Se "coalizione" e' la stringa vuota, allora il voto equivale ad una scheda bianca
(chiaramente cio' vale solo se il flag "nullo" e' false; se fosse true la scheda
sarebbe nulla indipendentemente dal campo "coalizione").
 
Questa classe e' gia' implementata e non necessita di modifiche.
Eventuali metodi accessori sono comunque ammessi.
 
*/
class Voto
{
private:
	string coalizione;
	Tipo tipo;
	bool nullo;
 
public:
	Voto(string ="", Tipo = SENATO, bool = false);
 
	string dammiCoalizione() const;
	Tipo dammiTipo() const;
	bool dimmiSeNullo() const;
 
	void impostaCoalizione(string);
	void impostaTipo(Tipo);
	void impostaNullo(bool);
 
	bool operator==(const Voto&) const;
};
 
#endif

// File: Voto.cpp
 
#include "Voto.h"
 
Voto::Voto(string c, Tipo t, bool n):coalizione(c), tipo(t), nullo(n)
{}
 
string Voto::dammiCoalizione() const
{
	return coalizione;
}
 
Tipo Voto::dammiTipo() const
{
	return tipo;
}
 
bool Voto::dimmiSeNullo() const
{
	return nullo;
}
 
void Voto::impostaCoalizione(string c)
{
	coalizione = c;
}
 
void Voto::impostaTipo(Tipo t)
{
	tipo = t;
}
 
void Voto::impostaNullo(bool t)
{
	nullo = t;
}
 
bool Voto::operator==(const Voto& o) const
{
	return coalizione == o.coalizione && tipo == o.tipo && nullo == o.nullo;
}

// File: Urna.h
 
#ifndef URNA_H
#define URNA_H
 
#include "Voto.h"
#include <cstdlib>
#include <iostream>
#include <list>
using namespace std;
 
/* 
 
Questa classe modella un'URNA contente solo schede votate.
Assumiamo che un oggetto di tipo Voto rappresenti una scheda votata,
che puo' essere anche nulla o bianca (come specificato nella documentazione
della classe Voto).
Quindi, l'urna sara' rappresentata da una lista di istanze della classe Voto
(nello specifico, la lista "voti").
 
I voti sono esattamente di 3 tipi,
come specificato nella classe Voto (senato, camera e regione).
 
Ogni elettore *deve* votare tutte e tre le schede, ma l'ordine in cui 
le tre schede votate (ovvero i tre oggetti di tipo Voto) vengono 
inserite nell'urna e' a sua discrezione.
Di conseguenza, dopo che un elettore ha votato e inserito tutte
e tre le schede nell'urna, la dimensione dell'urna sara' un multiplo di 3
(nello specifico, 3 moltiplicato il numero di elettori che hanno votato).
 
Ad esempio, dopo quattro votanti, il tipo delle schede presenti nell'urna 
potrebbe essere il seguente:
 
Urna = [CAMERA,     REGIONE,    SENATO, 
        SENATO,     CAMERA,     REGIONE, 
        SENATO,     REGIONE,    CAMERA,
        CAMERA,     SENATO,     REGIONE ]
 
Si richiede di implementare nel file Urna.cpp
tutti i metodi di questa classe ad eccezione del costruttore
(la cui implementazione e' data e non puo' essere modificata).
 
 */
class Urna // questa riga e' corretta NON MODIFICARE
{
 
private:
    // Le schede dell' URNA sono memorizzate in una lista.
    list<Voto> voti;
 
public:
 
    /*
 
    Questo metodo aggiunge una scheda all'urna solo se non viola la suddetta struttura dell'urna.
    In questo caso, il metodo ritorna true.
    Altrimenti, se la proprieta' non e' soddisfatta, restituisce false senza inserire la scheda.
 
    Ad esempio, se il tipo delle schede nell'urna e' il seguente:
 
    Urna = [SENATO,     CAMERA,     REGIONE,
            REGIONE ]
 
    il metodo restituira' true solo se la scheda e' di tipo CAMERA o SENATO.
 
    */
    bool aggiungiVoto(Voto v);
 
    /*
 
    Dato un Tipo, il metodo restituisce true se e solo se il numero di schede nulle di quel tipo
    e` maggiore o uguale al numero di schede nulle degli altri tipi (presi singolarmente).
    Ad esempio, se l'urna contenesse i seguenti voti:
 
    Urna = [("Coal1", CAMERA,  true),  ("Coal1", REGIONE, false), ("Coal2", SENATO, false), 
            ("Coal1", REGIONE, true),  ("Coal2", CAMERA,  false), ("",      SENATO, false), 
            ("Coal2", CAMERA,  true),  ("Coal1", REGIONE, false), ("Coal2", SENATO, false) ]
 
    il metodo "maggioranzaVotiNulli(CAMERA)"  restituirebbe true  (due nulle),
    il metodo "maggioranzaVotiNulli(REGIONE)" restituirebbe false (una nulla),
    il metodo "maggioranzaVotiNulli(SENATO)"  restituirebbe false (zero nulle).
 
    */
    bool maggioranzaVotiNulli(Tipo t);
 
    /*
 
    Dato un Tipo, restituire la lista di coalizione con piu' voti per quel Tipo.
    Se piu' di una coalizione risulta vincente, la lista deve essere costruita
    dando priorita' alla coalizione che per prima ha preso un voto valido.
    Ad esempio, se l'urna contenesse i seguenti voti:
 
    Urna = [("Coal1", CAMERA,  false), ("Coal1", REGIONE, false), ("Coal2", SENATO, false), 
            ("Coal1", REGIONE, true),  ("Coal2", CAMERA,  false), ("",      SENATO, true), 
            ("Coal2", CAMERA,  false), ("Coal1", REGIONE, false), ("Coal2", SENATO, false), 
            ("",      SENATO,  false), ("Coal1", REGIONE, true),  ("Coal1", CAMERA, true),
            ("Coal1", CAMERA,  false), ("Coal1", REGIONE, false), ("Coal2", SENATO, false) ]
 
    il metodo "coalizioniVincenti(CAMERA)" restituirebbe ["Coal1", "Coal2"] in quest'ordine. 
    Infatti, "Coal1" ha due voti validi (righe 1 e 5; la riga 4 ha un voto nullo).
    Allo stesso modo, "Coal2" ha due voti validi (righe 2 e 3).
    "Coal1" precede "Coal2" nella lista restituita in quanto il primo voto valido
    di "Coal1" e' sulla riga 1, mentre per "Coal2" e' sulla riga 2.
 
     */
    list<string> coalizioniVincenti(Tipo t);
 
    /*
 
    Dato un Tipo, restituire la lista di coalizione con piu' voti consecutivi per quel Tipo.
    Se piu' di una coalizione soddisfa la condizione, la lista deve essere costruita
    dando priorita' alla coalizione che per prima ha preso un voto valido.
    Ad esempio, se l'urna contenesse i seguenti voti:
 
    Urna = [("Coal1", CAMERA,  false), ("Coal1", REGIONE, false), ("Coal2", SENATO, false), 
            ("Coal1", REGIONE, true),  ("Coal2", CAMERA,  false), ("",      SENATO, true), 
            ("Coal2", CAMERA,  false), ("Coal1", REGIONE, false), ("Coal2", SENATO, false), 
            ("",      SENATO,  false), ("Coal1", REGIONE, true),  ("Coal1", CAMERA, true),
            ("Coal1", CAMERA,  false), ("Coal1", REGIONE, false), ("Coal2", SENATO, false) ]
 
    il metodo "coalizioniConSequenzePiuLunghe(CAMERA)" restituirebbe ["Coal2"]. 
    Infatti, "Coal1" compare in due sequenze di lunghezza 1: la prima in riga 1, 
    la seconda in riga 5 (da notare che il voto per "Coal1" in riga 4 e' nullo).
    "Coal2", invece, compare in una sola lista di lunghezza 2: da riga 2 a riga 3.
    Non essendoci altre coalizzioni votate alla CAMERA, "Coal2" risulta essere
    la sola coalizione con la sequenza piu' lunga di voti consecutivi alla CAMERA.
 
    */
 
    list<string> coalizioniConSequenzePiuLunghe(Tipo t);
 
    inline list<Voto>& getContent();
};
 
list<Voto>& Urna::getContent()
{
    return voti;
}
 
#endif

bool Urna::aggiungiVoto(Voto v)
{
    // Se non e' un voto di un nuovo elettore, allora controlliamo il tipo degli altri voti espressi dall'elettore
    if(voti.size() % 3 >= 1)
    {
        // Troviamo gli ultimi due voti
        Voto ultima, penultima;
        for(list<Voto>::const_iterator it = voti.begin(); it != voti.end(); it++)
        {
            penultima = ultima;
            ultima = *it;
        }
 
        // Non possiamo aggiungere un voto dello stesso tipo dell'ultimo voto presente nell'urna
        if(v.dammiTipo() == ultima.dammiTipo())
            return false;
 
        // Se questa e' la terza scheda di un elettore eseguiamo il controllo anche per il penultimo voto
        if(voti.size() % 3 == 2 && v.dammiTipo() == penultima.dammiTipo())
            return false;
    }
 
    voti.push_back(v);
    return true;
}

bool Urna::aggiungiVoto(Voto v)
{
    // Se non e' un voto di un nuovo elettore, allora controlliamo il tipo degli altri voti espressi dall'elettore
    if(voti.size() % 3 >= 1)
    {
        list<Voto>::const_reverse_iterator it = voti.rbegin();    
        Voto ultima = *it, penultima;
 
        // Non possiamo aggiungere un voto dello stesso tipo dell'ultimo voto presente nell'urna
        if(v.dammiTipo() == ultima.dammiTipo())
            return false;
 
        // Se questa e' la terza scheda di un elettore eseguiamo il controllo anche per il penultimo voto
        if(voti.size() % 3 == 2)
        {
            it++;
            penultima = *it;
            if(v.dammiTipo() == penultima.dammiTipo())
                return false;
        }
    }
 
    voti.push_back(v);
    return true;
}

bool Urna::maggioranzaVotiNulli(Tipo t)
{
    int count[] = {0,0,0};  // equivale a: int count[3]; count[SENATO] = count[CAMERA] = count[REGIONE] = 0;
 
    // Contiamo i voti nulli per ogni tipo
    for(list<Voto>::const_iterator it = voti.begin(); it != voti.end(); it++)
        if(it->dimmiSeNullo())
            count[it->dammiTipo()]++;
 
    // Ritorniamo true se count[t] è maggiore o uguale di tutti gli altri
    return count[t] >= count[0] && count[t] >= count[1] && count[t] >= count[2];
}

list<string> Urna::coalizioniVincenti(Tipo t)
{
    list<string> vincenti;
    int max = 0;
 
    // Iteriamo sui voti presenti nell'urna
    for(list<Voto>::const_iterator it = voti.begin(); it != voti.end(); it++)
    {
        // Se il voto e' valido e del tipo richiesto, allora contiamo i voti per questa coalizione
        if(it->dammiTipo() == t && !it->dimmiSeNullo() && it->dammiCoalizione() != "")
        {
            int count = 0;
 
            // Contiamo tutti i voti presenti nell'urna a partire da it
            for(list<Voto>::const_iterator it2 = it; it2 != voti.end(); it2++)
                // Se il voto e' valido, dello stesso tipo e coalizione di it, allora incrementa count
                if(it2->dammiTipo() == t && !it2->dimmiSeNullo() && it2->dammiCoalizione() != it->dammiCoalizione())
                    count++;
 
            // Se questa coalizione ha preso piu' voti di tutti (finora)
            if(count > max)
            {
                // Abbiamo un nuovo massimo
                max = count;
 
                // Quindi la lista dovra' contenere solo questa coalizione
                vincenti.erase(vincenti.begin(), vincenti.end());   // equivale a: vincenti = list<string>();
                vincenti.push_back(it->dammiCoalizione());
            }
            // Se invece questa coalizione ha il massimo dei voti a parimerito di altre coalizioni
            else if(count == max)
                // Aggiungiamo la coalizione alla lista
                vincenti.push_back(it->dammiCoalizione());
        }
    }
 
    return vincenti;
}

list<string> Urna::coalizioniVincenti(Tipo t)
{
	vector<string> coalizioni;
	vector<int> numPref;
 
	for(list<Voto>::const_iterator it = voti.begin(); it != voti.end(); it++)
	{
		Voto v = *it;
		if(v.dammiTipo() == t && !v.dimmiSeNullo() && v.dammiCoalizione() != "")
		{
			bool trovato = false;
			for(int i = 0; i < coalizioni.size(); i++)
				if(coalizioni[i] == v.dammiCoalizione())
				{
					numPref[i]++;
					trovato = true;
				}
 
			if(!trovato)
			{
				coalizioni.push_back(v.dammiCoalizione());
				numPref.push_back(1);
			}
 
		}
	}
 
    list<string> vincenti;
	int max = 0;
	for(int i = 0; i < coalizioni.size(); i++)
		if(numPref[i] > max)
		{
			max = numPref[i];
			vincenti.erase(vincenti.begin(), vincenti.end());
			vincenti.push_back(coalizioni[i]);
		}
		else if(numPref[i] == max)
			vincenti.push_back(coalizioni[i]);
 
	return vincenti;
}

list<string> Urna::coalizioniVincenti(Tipo t)
{
    list<string> vincenti;
    int max = 0;
 
    // Iteriamo sui voti presenti nell'urna
    for(list<Voto>::const_iterator it = voti.begin(); it != voti.end(); it++)
    {
        // Se il voto e' valido e del tipo richiesto, allora contiamo i voti per questa coalizione
        if(it->dammiTipo() == t && !it->dimmiSeNullo() && it->dammiCoalizione() != "")
        {
            int count = 0;
 
            // Contiamo tutti i voti consecutivi presenti nell'urna a partire da it
            for(list<Voto>::const_iterator it2 = it; 
                    it2 != voti.end() && it2->dammiTipo() == t && 
                    !it2->dimmiSeNullo() && it2->dammiCoalizione() != it->dammiCoalizione(); 
                    it2++)
                count++;
 
            // Se questa coalizione ha preso piu' voti di tutti (finora)
            if(count > max)
            {
                // Abbiamo un nuovo massimo
                max = count;
 
                // Quindi la lista dovra' contenere solo questa coalizione
                vincenti.erase(vincenti.begin(), vincenti.end());   // equivale a: vincenti = list<string>();
                vincenti.push_back(it->dammiCoalizione());
            }
            // Se invece questa coalizione ha il massimo dei voti a parimerito di altre coalizioni
            else if(count == max)
                // Aggiungiamo la coalizione alla lista
                vincenti.push_back(it->dammiCoalizione());
        }
    }
 
    return vincenti;
}