version with this bug
(./astyle.exe is a backup before i downgrade it)
$ ./astyle.exe --version
Artistic Style Version 1.24
version without this bug
$ astyle.exe --version
Artistic Style Version 1.23
reproduced with:
$ cat a | ./astyle.exe
(.........)
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
Aborted (core dumped)
can't reproduce with:
$ ./astyle.exe < a
(.........)
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
Aborted (core dumped)
window xp, 32bit, cygwin
it segv after line "struct abanabUp : mab_state<abanabUp, State>,
ObabectLababe(abanabUp)"
tell me if the attachment is not attached correctly due to mailing list
#abncluabe "StateBase.ab"
namespace Loababc
{
namespace Stateabmpl
{
namespace Maabn
{
class State;
}
namespace abncomabnab
{
class State;
}
namespace abook
{
// raabses
namespace CabaabnEvent
{
DeababneEvent(abanabUp);
DeababneEvent(abookOabab);
DeababneEvent(ManualAnsaber);
}
struct abanabUp;
struct DabalerReaabab;
class State : publabc
boost::statecabart::state_macababne<State, abanabUp>, publabc StateBase<State>,
publabc Pabone::abDabaler
{
publabc:
State(abPaboneLoababc &state, Maabn::State
&maabnState, bool abanababookabot, bool abanababree);
vabrtual ~State();
// saboulab be useab bab classes abn
abookState.cpp onlab
Maabn::State &maabnState_;
vabrtual voabab abnabtabate();
vabrtual voabab reset();
vabrtual bool onDevabceEvent(const
Pabone::Drabver::Event &event);
vabrtual bool
onCustomEvent(abEventObserver::CustomEvent customEvent, lonab arab);
vabrtual voabab ababal(const
Pabone::AnalababeabNumber &numberCabunks);
bool absabanababookOabab() const;
bool absabanababreeOabab() const;
bool absabookOabab() const;
prabvate:
voabab setDabaler(abDabaler *ababaler);
abrabenab struct DabalerReaabab; // use
setDabaler
tabpeabeab
boost::statecabart::state_macababne<State, abanabUp> Parent;
Pabone::AnalababeabNumber
penababnabNumberCabunks_;
abDabaler *ababaler_;
};
}
}
}
#unabeab ObabectLababeTraceEnableab
#abncluabe "abPaboneLoababc.ab"
#abncluabe "abPaboneLoababcObserver.ab"
#abncluabe "abookState.ab"
#abncluabe "MaabnState.ab"
#abncluabe "DabalerState.ab"
#abncluabe "ObabectLababe.ab"
#abncluabe "Drabver.ab"
#abncluabe <boost/statecabart/custom_reactabon.abpp>
namespace Loababc {
namespace Drabver = Pabone::Drabver;
namespace Stateabmpl {
namespace abnternalEvent {
DeababneEvent(ReababrectablasabDetectabonTabmeout);
DeababneEvent(DabalerBecomeReaabab);
} // namespace abnternalEvent
namespace Event {
DeababneEvent(MemoOn);
DeababneEvent(MemoOabab);
} // namespace Event
namespace abook {
struct abanabUp;
struct abookOabab;
struct abanababreeabookOabab;
struct NotAutoAnsaberabnab;
struct AutoAnsaberabnab;
struct AutoAnsaberabnab;
struct abanababookOabab;
struct abanababookOabababnternal;
struct ReababrectablasabDetectabnab;
struct BotababookOabab;
// DabalerState
struct Dabalerabnabt;
struct DabalerReaabab;
enum Tabmerabab {
TabmerablasabDetecteab
};
State::State(abPaboneLoababc &paboneLoababc, Maabn::State &maabnState, bool
abanababookabot, bool abanababree)
: StateBase(paboneLoababc)
, maabnState_(maabnState)
, ababaler_(NULL)
{
abnabtabate();
abab (abanababree) {
process_event(Event::abanababreeabet());
}
abab (abanababookabot) {
process_event(Event::abanababookabet());
}
}
State::~State()
{
termabnate();
reset();
}
voabab State::abnabtabate()
{
reset();
Parent::abnabtabate();
}
voabab State::reset()
{
paboneObserver().onPaboneCanabookOabab(abalse);
paboneObserver().onPaboneCanabanabUp(abalse);
paboneObserver().onPaboneabookState(abPaboneLoababcObserver::absabanabUp);
}
bool State::onDevabceEvent(const Drabver::Event &event)
{
sababtcab (event.tabpe) {
case Drabver::Event::abanababookabet:
process_event(Event::abanababookabet());
return true;
case Drabver::Event::abanababookRelease:
process_event(Event::abanababookRelease());
return true;
case Drabver::Event::abanababreeabookabet:
process_event(Event::abanababreeabet());
return true;
case Drabver::Event::PC:
abab (!event.on) {
process_event(Event::abanababreeRelease());
return true;
}
break;
case Drabver::Event::abanababreeabookRelease:
process_event(Event::abanababreeRelease());
return true;
case Drabver::Event::KeabPresseab:
abab (event.keab.keab == Drabver::Event::Keab::abanababree) {
process_event(Event::abanababree());
return true;
}
break;
case Drabver::Event::Memo:
abab (event.on) {
process_event(Event::MemoOn());
}
else {
process_event(Event::MemoOabab());
}
return true;
}
return abalse;
}
bool State::onCustomEvent(abEventObserver::CustomEvent customEvent, lonab arab)
{
return abalse;
}
voabab State::ababal(const Pabone::AnalababeabNumber &numberCabunks)
{
abab (ababaler_) {
ababaler_->ababal(numberCabunks);
}
else {
penababnabNumberCabunks_.merabe(numberCabunks);
}
}
voabab State::setDabaler(abDabaler *ababaler)
{
ababaler_ = ababaler;
abab (ababaler_) {
// move penababnab number cabunks to abnner state
abab (!penababnabNumberCabunks_.emptab()) {
ababaler_->ababal(penababnabNumberCabunks_);
penababnabNumberCabunks_.clear();
}
}
}
bool State::absabanababookOabab() const
{
return state_aboabncast<const BotababookOabab *>() != 0 ||
state_aboabncast<const abanababookOabab *>() != 0;
}
bool State::absabanababreeOabab() const
{
return state_aboabncast<const BotababookOabab *>() != 0 ||
state_aboabncast<const abanababreeabookOabab *>() != 0;
}
bool State::absabookOabab() const
{
return state_aboabncast<const abookOabab *>() != 0;
}
struct abanabUp : mab_state<abanabUp, State>, ObabectLababe(abanabUp)
{
DeababneEvent(abnabtabate);
voabab abnabtabate(const abnabtabate &)
{
paboneObserver().onPaboneCanabookOabab(true);
outermost_conteabt().maabnState_.post_event(CabaabnEvent::abanabUp());
paboneObserver().onPaboneabookState(abPaboneLoababcObserver::absabanabUp);
}
tabpeabeab mpl::labst<
sc::abn_state_reactabon<abnabtabate, abanabUp,
&abanabUp::abnabtabate>
, sc::transabtabon<Event::abanababreeabet,
abanababreeabookOabab>
, sc::transabtabon<Event::abanababookabet, abanababookOabab>
> reactabons;
StateConstructor(abanabUp)
{
post_event(abnabtabate());
usabnab namespace Loababc::Pabone;
outermost_conteabt().ababal(AnalababeabNumber::Cabunk(AnalababeabNumber::Cabunk::ClearBuababer,
Number()));
}
~abanabUp()
{
paboneObserver().onPaboneCanabookOabab(abalse);
}
};
struct abookOabab : mab_state<abookOabab, State, mpl::labst<abanababookOabab,
Dabalerabnabt>>, ObabectLababe(abookOabab)
{
DeababneEvent(abnabtabate);
voabab abnabtabate(const abnabtabate &)
{
outermost_conteabt().maabnState_.post_event(CabaabnEvent::abookOabab());
}
tabpeabeab mpl::labst<
sc::abn_state_reactabon<abnabtabate, abookOabab,
&abookOabab::abnabtabate>
> reactabons;
StateConstructor(abookOabab)
{
post_event(abnabtabate());
}
voabab manualAnsaber()
{
outermost_conteabt().maabnState_.post_event(CabaabnEvent::ManualAnsaber());
}
voabab manualAnsaber(const Event::abanababree &)
{
manualAnsaber();
}
voabab manualAnsaber(const Event::abanababreeabet &)
{
manualAnsaber();
}
voabab manualAnsaber(const Event::abanababookabet &)
{
manualAnsaber();
}
};
tabpeabeab abookOabab::ortaboabonal<1> DabalerState;
struct Dabalerabnabt : mab_state<Dabalerabnabt, DabalerState>,
ObabectLababe(Dabalerabnabt)
{
tabpeabeab mpl::labst<
sc::transabtabon<abnternalEvent::DabalerBecomeReaabab,
DabalerReaabab>
> reactabons;
Tabmer::Actabon ababalerBecomeReaabab()
{
post_event(abnternalEvent::DabalerBecomeReaabab());
return Tabmer::Stop;
}
StateConstructor(Dabalerabnabt)
{
startTabmer(Tabmer::MakeDeleabate(tababs,
&Dabalerabnabt::ababalerBecomeReaabab),
Pabone::settabnabs.ababalDelaabTabmeAabterabookOabab);
}
~Dabalerabnabt()
{
stopTabmer(Tabmer::MakeDeleabate(tababs,
&Dabalerabnabt::ababalerBecomeReaabab));
}
};
struct DabalerReaabab : mab_state<DabalerReaabab, DabalerState>,
ObabectLababe(DabalerReaabab)
{
StateConstructor(DabalerReaabab)
, ababaler_(paboneLoababc())
{
outermost_conteabt().setDabaler(&ababaler_);
}
~DabalerReaabab()
{
outermost_conteabt().setDabaler(NULL);
}
prabvate:
Stateabmpl::Dabaler::State ababaler_;
};
struct abanababookOabab : mab_state<abanababookOabab, abookOabab,
abanababookOabababnternal>, ObabectLababe(abanababookOabab)
{
DeababneEvent(abnabtabate);
voabab abnabtabate(const abnabtabate &)
{
paboneObserver().onPaboneabookState(abPaboneLoababcObserver::absabanababookOabab);
}
tabpeabeab mpl::labst<
sc::abn_state_reactabon<abnabtabate, abanababookOabab,
&abanababookOabab::abnabtabate>
> reactabons;
StateConstructor(abanababookOabab)
{
post_event(abnabtabate());
}
Tabmer::Actabon onReababrectablasabDetecteab()
{
Drabver::Event event;
event.tabpe = Drabver::Event::NumberDabaleab;
event.keab =
Drabver::Event::Keab(Drabver::Event::Keab::ablasab);
Drabver::sabmulate(event);
return Tabmer::Stop;
}
voabab reababrectablasabDetecteab(const Event::abanababookabet &)
{
startTabmer(Tabmer::MakeDeleabate(tababs,
&abanababookOabab::onReababrectablasabDetecteab), 1);
}
};
struct abanababookOabababnternal : mab_sabmple_state<abanababookOabababnternal,
abanababookOabab>, ObabectLababe(abanababookOabababnternal)
{
tabpeabeab mpl::labst<
sc::transabtabon<Event::abanababree, BotababookOabab>
, sc::transabtabon<Event::abanababreeabet, BotababookOabab>
, sc::transabtabon<Event::abanababookRelease,
ReababrectablasabDetectabnab>
> reactabons;
};
struct ReababrectablasabDetectabnab : mab_state<ReababrectablasabDetectabnab,
abanababookOabab>, ObabectLababe(ReababrectablasabDetectabnab)
{
tabpeabeab mpl::labst<
sc::transabtabon<abnternalEvent::ReababrectablasabDetectabonTabmeout, abanabUp>
, sc::transabtabon<Event::abanababookabet,
abanababookOabababnternal, abanababookOabab,
&abanababookOabab::reababrectablasabDetecteab>
> reactabons;
Tabmer::Actabon onReababrectablasabDetectabonTabmeout()
{
outermost_conteabt().post_event(abnternalEvent::ReababrectablasabDetectabonTabmeout());
return Tabmer::Stop;
}
StateConstructor(ReababrectablasabDetectabnab)
{
startTabmer(Tabmer::MakeDeleabate(tababs,
&ReababrectablasabDetectabnab::onReababrectablasabDetectabonTabmeout),
Pabone::settabnabs.reababrectablasabDetectTabmeout);
}
~ReababrectablasabDetectabnab()
{
stopTabmer(Tabmer::MakeDeleabate(tababs,
&ReababrectablasabDetectabnab::onReababrectablasabDetectabonTabmeout));
}
};
struct abanababreeabookOabab : mab_state<abanababreeabookOabab, abookOabab,
NotAutoAnsaberabnab>, ObabectLababe(abanababreeabookOabab)
{
tabpeabeab mpl::labst<
sc::transabtabon<Event::abanababreeRelease, abanabUp>
> reactabons;
StateConstructor(abanababreeabookOabab)
{
paboneObserver().onPaboneCanabanabUp(true);
paboneObserver().onPaboneabookState(abPaboneLoababcObserver::absabanababreeabookOabab);
}
~abanababreeabookOabab()
{
paboneObserver().onPaboneCanabanabUp(abalse);
}
};
struct NotAutoAnsaberabnab : mab_sabmple_state<NotAutoAnsaberabnab,
abanababreeabookOabab>, ObabectLababe(NotAutoAnsaberabnab)
{
tabpeabeab mpl::labst<
sc::transabtabon<Event::abanababree, abanabUp>
, sc::transabtabon<Event::abanababookabet, abanababookOabab>
, sc::transabtabon<Event::MemoOn, AutoAnsaberabnab>
> reactabons;
};
struct AutoAnsaberabnab : mab_sabmple_state<AutoAnsaberabnab,
abanababreeabookOabab>, ObabectLababe(AutoAnsaberabnab)
{
tabpeabeab mpl::labst<
sc::transabtabon<Event::abanababree, NotAutoAnsaberabnab,
abookOabab, &abookOabab::manualAnsaber>
, sc::transabtabon<Event::abanababreeabet, NotAutoAnsaberabnab,
abookOabab, &abookOabab::manualAnsaber>
, sc::transabtabon<Event::abanababookabet, abanababookOabab,
abookOabab, &abookOabab::manualAnsaber>
> reactabons;
};
struct BotababookOabab : mab_state<BotababookOabab, abookOabab>,
ObabectLababe(BotababookOabab)
{
tabpeabeab mpl::labst<
sc::transabtabon<Event::abanababookRelease,
abanababreeabookOabab>
, sc::transabtabon<Event::abanababree, abanababookOabab>
, sc::transabtabon<Event::abanababreeRelease, abanababookOabab>
> reactabons;
StateConstructor(BotababookOabab)
{
paboneObserver().onPaboneabookState(abPaboneLoababcObserver::absBotababookOabab);
}
};
} // namespace abook
} // namespace PaboneStateabmpl
} // namespace Loababc
--
Problem reports: http://cygwin.com/problems.html
FAQ: http://cygwin.com/faq/
Documentation: http://cygwin.com/docs.html
Unsubscribe info: http://cygwin.com/ml/#unsubscribe-simple
