/elec/propeller-clock : revision 64

To get this branch, use:

bzr branch
http://bzr.ed.am/elec/propeller-clock

« back to all changes in this revision

Viewing changes to src/utility/ios

Committer: Tim Marston
Date: 2012-03-09 23:42:20 UTC
Revision ID: tim@ed.am-20120309234220-xr1vxzve0o5n2oss

added support for eclipse project and converted to a manual Makefile

files added:
src/digital_clock_mode.cc

src/digital_clock_mode.h

src/display.cc

src/display.h

src/mode_base.h

src/text.cc

src/text.h

src/text_renderer.cc

src/text_renderer.h

src/util/PString.cpp

src/util/PString.h

files removed:
src/utility

src/utility/Jamfile

src/utility/Makefile

src/utility/README.md

src/utility/StandardCplusplus.h

src/utility/algorithm

src/utility/algorithm.cpp

src/utility/associative_base

src/utility/associative_base.cpp

src/utility/basic_definitions

src/utility/bitset

src/utility/bitset.cpp

src/utility/cassert

src/utility/cctype

src/utility/cerrno

src/utility/cfloat

src/utility/char_traits

src/utility/char_traits.cpp

src/utility/climits

src/utility/clocale

src/utility/cmath

src/utility/complex

src/utility/complex.cpp

src/utility/csetjmp

src/utility/csignal

src/utility/cstdarg

src/utility/cstddef

src/utility/cstdio

src/utility/cstdlib

src/utility/cstring

src/utility/ctime

src/utility/cwchar

src/utility/cwctype

src/utility/del_op.cpp

src/utility/del_opnt.cpp

src/utility/del_opv.cpp

src/utility/del_opvnt.cpp

src/utility/deque

src/utility/deque.cpp

src/utility/eh_alloc.cpp

src/utility/eh_globals.cpp

src/utility/exception

src/utility/exception.cpp

src/utility/fstream

src/utility/fstream.cpp

src/utility/func_exception

src/utility/func_exception.cpp

src/utility/functional

src/utility/iomanip

src/utility/iomanip.cpp

src/utility/ios

src/utility/ios.cpp

src/utility/iosfwd

src/utility/iostream

src/utility/iostream.cpp

src/utility/istream

src/utility/istream.cpp

src/utility/istream_helpers

src/utility/iterator

src/utility/iterator.cpp

src/utility/iterator_base

src/utility/limits

src/utility/limits.cpp

src/utility/list

src/utility/list.cpp

src/utility/locale

src/utility/locale.cpp

src/utility/map

src/utility/map.cpp

src/utility/memory

src/utility/new

src/utility/new_handler.cpp

src/utility/new_op.cpp

src/utility/new_opnt.cpp

src/utility/new_opv.cpp

src/utility/new_opvnt.cpp

src/utility/numeric

src/utility/numeric.cpp

src/utility/ostream

src/utility/ostream.cpp

src/utility/ostream_helpers

src/utility/queue

src/utility/queue.cpp

src/utility/serstream

src/utility/set

src/utility/set.cpp

src/utility/sstream

src/utility/sstream.cpp

src/utility/stack

src/utility/stack.cpp

src/utility/stdexcept

src/utility/stdexcept.cpp

src/utility/streambuf

src/utility/streambuf.cpp

src/utility/string

src/utility/string.cpp

src/utility/string_iostream

src/utility/support

src/utility/support.cpp

src/utility/system_configuration.h

src/utility/type_traits

src/utility/typeinfo

src/utility/typeinfo.cpp

src/utility/uartbuf

src/utility/unwind-cxx.h

src/utility/utility.cpp

src/utility/utility.h

src/utility/valarray

src/utility/valarray.cpp

src/utility/vector

src/utility/vector.cpp

files renamed:
src/propeller-clock.ino => src/propeller-clock.cc

src/mode_switcher.cc => src/switcher_major_mode.cc

src/mode_switcher.h => src/switcher_major_mode.h

files modified:
.bzrignore

arduino.mk

src/Makefile

src/analogue_clock_mode.cc

src/analogue_clock_mode.h

src/button.cc

src/button.h

src/config.h

src/drawer.cc

src/drawer.h

src/major_mode.h

src/minor_mode.cc

src/minor_mode.h

src/test_mode.cc

src/test_mode.h

src/time.cc

src/time.h

Show diffs side-by-side

added added

removed removed

src/utility/ios

This file is part of the uClibc++ Library.

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

#include <basic_definitions>

#include <cstddef>

#include <locale>

#include <iosfwd>

#ifndef __HEADER_STD_IOS

#define __HEADER_STD_IOS 1

#pragma GCC visibility push(default)

namespace std{

typedef signed long int streamoff;

template <class stateT> class fpos;

class _UCXXEXPORT ios_base {

public:

class failure;

#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__

class failure : public exception {

public:

explicit failure(const std::string& msg) { }

explicit failure() { }

virtual const char* what() const throw() {

return "std::ios_base failure exception";

}

};

#endif

#ifdef __UCLIBCXX_SUPPORT_CDIR__

class _UCXXLOCAL Init{

public:

_UCXXEXPORT Init();

_UCXXEXPORT ~Init();

private:

static int init_cnt;

};

#endif

public:

typedef unsigned short int fmtflags;

static const fmtflags skipws = 0x0001;

static const fmtflags left = 0x0002;

static const fmtflags right = 0x0004;

static const fmtflags internal = 0x0008;

static const fmtflags boolalpha = 0x0010;

static const fmtflags dec = 0x0020;

static const fmtflags oct = 0x0040;

static const fmtflags hex = 0x0080;

static const fmtflags scientific = 0x0100;

static const fmtflags fixed = 0x0200;

static const fmtflags showbase = 0x0400;

static const fmtflags showpoint = 0x0800;

static const fmtflags showpos = 0x1000;

static const fmtflags uppercase = 0x2000;

static const fmtflags adjustfield = left | right | internal;

static const fmtflags basefield = dec | oct | hex;

static const fmtflags floatfield = fixed | scientific;

static const fmtflags unitbuf = 0x4000;

typedef unsigned char iostate;

static const iostate goodbit = 0x00;

static const iostate badbit = 0x01;

static const iostate eofbit = 0x02;

static const iostate failbit = 0x04;

typedef unsigned char openmode;

static const openmode app = 0x01;

static const openmode ate = 0x02;

static const openmode binary = 0x04;

static const openmode in = 0x08;

static const openmode out = 0x10;

100

static const openmode trunc = 0x20;

101

102

typedef unsigned char seekdir;

103

static const seekdir beg = 0x01;

104

static const seekdir cur = 0x02;

105

static const seekdir end = 0x04;

106

107

_UCXXEXPORT fmtflags flags() const{

108

return mformat;

109

}

110

_UCXXEXPORT fmtflags flags(fmtflags fmtfl);

111

112

fmtflags setf(fmtflags fmtfl);

113

fmtflags setf(fmtflags fmtfl, fmtflags mask );

114

115

_UCXXEXPORT void unsetf(fmtflags mask){

116

mformat&= ~mask;

117

}

118

119

_UCXXEXPORT streamsize precision() const{

120

return mprecision;

121

}

122

123

_UCXXEXPORT streamsize precision(streamsize prec);

124

125

_UCXXEXPORT streamsize width() const{

126

return mwidth;

127

}

128

129

_UCXXEXPORT streamsize width(streamsize wide);

130

131

_UCXXEXPORT locale imbue(const locale& loc);

132

133

_UCXXEXPORT locale getloc() const{

134

return mLocale;

135

}

136

137

// FIXME - These need to be implemented

138

// static int xalloc();

139

// long& iword(int index);

140

// void*& pword(int index);

141

142

_UCXXEXPORT ~ios_base() { }

143

144

enum event { erase_event, imbue_event, copyfmt_event };

145

146

typedef void (*event_callback)(event, ios_base&, int index);

147

// void register_callback(event_call_back fn, int index);

148

149

//We are going to wrap stdio so we don't need implementation of the following:

150

inline static bool sync_with_stdio(bool = true) { return true; }

151

152

protected:

153

_UCXXEXPORT ios_base() : mLocale(), mformat(dec | skipws ), mstate(goodbit),

154

mmode(), mdir(), mprecision(6), mwidth(0)

155

#ifdef __UCLIBCXX_SUPPORT_CDIR__

156

,mInit()

157

#endif

158

{

159

160

}

161

locale mLocale;

162

fmtflags mformat;

163

iostate mstate;

164

openmode mmode;

165

seekdir mdir;

166

streamsize mprecision;

167

streamsize mwidth;

168

#ifdef __UCLIBCXX_SUPPORT_CDIR__

169

Init mInit;

170

#endif

171

};

172

173

174

//ios_base manipulators

175

176

177

inline ios_base& boolalpha (ios_base& str){

178

str.setf(ios_base::boolalpha);

179

return str;

180

}

181

inline ios_base& noboolalpha(ios_base& str){

182

str.unsetf(ios_base::boolalpha);

183

return str;

184

}

185

inline ios_base& showbase (ios_base& str){

186

str.setf(ios_base::showbase);

187

return str;

188

}

189

inline ios_base& noshowbase (ios_base& str){

190

str.unsetf(ios_base::showbase);

191

return str;

192

}

193

inline ios_base& showpoint (ios_base& str){

194

str.setf(ios_base::showpoint);

195

return str;

196

}

197

inline ios_base& noshowpoint(ios_base& str){

198

str.unsetf(ios_base::showpoint);

199

return str;

200

}

201

inline ios_base& showpos (ios_base& str){

202

str.setf(ios_base::showpos);

203

return str;

204

}

205

inline ios_base& noshowpos (ios_base& str){

206

str.unsetf(ios_base::showpos);

207

return str;

208

}

209

inline ios_base& skipws (ios_base& str){

210

str.setf(ios_base::skipws);

211

return str;

212

}

213

inline ios_base& noskipws (ios_base& str){

214

str.unsetf(ios_base::skipws);

215

return str;

216

}

217

inline ios_base& uppercase (ios_base& str){

218

str.setf(ios_base::uppercase);

219

return str;

220

}

221

inline ios_base& nouppercase(ios_base& str){

222

str.unsetf(ios_base::uppercase);

223

return str;

224

}

225

226

inline ios_base& unitbuf (ios_base& str){

227

str.setf(ios_base::unitbuf);

228

return str;

229

}

230

inline ios_base& nounitbuf (ios_base& str){

231

str.unsetf(ios_base::unitbuf);

232

return str;

233

}

234

inline ios_base& internal (ios_base& str){

235

str.setf(ios_base::internal, ios_base::adjustfield);

236

return str;

237

}

238

inline ios_base& left (ios_base& str){

239

str.setf(ios_base::left, ios_base::adjustfield);

240

return str;

241

}

242

inline ios_base& right (ios_base& str){

243

str.setf(ios_base::right, ios_base::adjustfield);

244

return str;

245

}

246

247

inline ios_base& dec (ios_base& str){

248

str.setf(ios_base::dec, ios_base::basefield);

249

return str;

250

}

251

inline ios_base& hex (ios_base& str){

252

str.setf(ios_base::hex, ios_base::basefield);

253

return str;

254

}

255

inline ios_base& oct (ios_base& str){

256

str.setf(ios_base::oct, ios_base::basefield);

257

return str;

258

}

259

260

inline ios_base& fixed (ios_base& str){

261

str.setf(ios_base::fixed, ios_base::floatfield);

262

return str;

263

}

264

inline ios_base& scientific (ios_base& str){

265

str.setf(ios_base::scientific, ios_base::floatfield);

266

return str;

267

}

268

269

270

//basic_ios class definition

271

272

273

template <class charT, class traits > class _UCXXEXPORT basic_ios

274

: public ios_base

275

{

276

public:

277

// Types:

278

typedef charT char_type;

279

typedef typename traits::int_type int_type;

280

typedef typename traits::pos_type pos_type;

281

typedef typename traits::off_type off_type;

282

typedef traits traits_type;

283

284

_UCXXEXPORT operator void*() const{

285

if(fail() ){

286

return 0;

287

}

288

return (void *)(1); //Must return a non-NULL pointer (though it can be *any* pointer)

289

}

290

291

_UCXXEXPORT bool operator!() const{

292

return fail();

293

}

294

_UCXXEXPORT iostate rdstate() const{

295

return mstate;

296

}

297

_UCXXEXPORT void clear(iostate state = goodbit){

298

if(rdbuf()!=0){

299

mstate = state;

300

}else{

301

mstate = state|ios_base::badbit;

302

}

303

}

304

_UCXXEXPORT void setstate(iostate state) {

305

clear(rdstate() | state);

306

#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__

307

if(rdstate() & throw_mask){

308

throw failure();

309

}

310

#endif

311

}

312

313

_UCXXEXPORT bool good() const{

314

return (rdstate() == 0);

315

}

316

_UCXXEXPORT bool eof() const{

317

if(rdstate() & eofbit){

318

return true;

319

}

320

return false;

321

}

322

_UCXXEXPORT bool fail() const{

323

if( mstate & (failbit | badbit) ){

324

return true;

325

}

326

return false;

327

}

328

329

_UCXXEXPORT bool bad() const{

330

if(mstate & badbit){

331

return true;

332

}

333

return false;

334

}

335

336

_UCXXEXPORT iostate exceptions() const{

337

return throw_mask;

338

}

339

_UCXXEXPORT void exceptions(iostate except){

340

throw_mask = except;

341

}

342

343

explicit _UCXXEXPORT basic_ios(basic_streambuf<charT,traits>* sb) : fill_char(' '), mtied(0), mstreambuf(0){

344

init(sb);

345

}

346

347

basic_ios() : mtied(0), mstreambuf(0){ }

348

349

virtual _UCXXEXPORT ~basic_ios(){

350

}

351

352

_UCXXEXPORT basic_ostream<charT,traits>* tie() const{

353

return mtied;

354

}

355

_UCXXEXPORT basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr){

356

basic_ostream<charT,traits>* retval= mtied;

357

mtied = tiestr;

358

return retval;

359

}

360

_UCXXEXPORT basic_streambuf<charT,traits>* rdbuf() const{

361

return mstreambuf;

362

}

363

_UCXXEXPORT basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb){

364

basic_streambuf<charT,traits>* retval = mstreambuf;

365

mstreambuf = sb;

366

return retval;

367

}

368

_UCXXEXPORT basic_ios& copyfmt(const basic_ios& rhs);

369

_UCXXEXPORT char_type fill() const{

370

return fill_char;

371

}

372

_UCXXEXPORT char_type fill(char_type ch){

373

char_type temp = fill_char;

374

fill_char = ch;

375

return temp;

376

}

377

378

_UCXXEXPORT locale imbue(const locale& loc){

379

return ios_base::imbue(loc);

380

}

381

_UCXXEXPORT char narrow(char_type c, char dfault) const;

382

_UCXXEXPORT char_type widen(char c) const;

383

384

protected:

385

char_type fill_char;

386

basic_ostream<charT,traits>* mtied;

387

basic_streambuf<charT,traits>* mstreambuf;

388

iostate throw_mask;

389

_UCXXEXPORT basic_ios(const basic_ios<charT,traits> &){ }

390

_UCXXEXPORT basic_ios<charT,traits> & operator=(const basic_ios<charT,traits> &){ return *this; }

391

_UCXXEXPORT void init(basic_streambuf<charT,traits>* sb){

392

ios_base::mformat = skipws|dec;

393

mstreambuf = sb;

394

mstate = goodbit;

395

throw_mask = goodbit;

396

}

397

};

398

399

#ifdef __UCLIBCXX_EXPAND_IOS_CHAR__

400

#ifndef __UCLIBCXX_COMPILE_IOS__

401

402

template <> _UCXXEXPORT void basic_ios<char, char_traits<char> >::clear(iostate state);

403

template <> _UCXXEXPORT void basic_ios<char, char_traits<char> >::setstate(iostate state);

404

405

#endif

406

#endif

407

408

409

template <class charT, class traits>

410

inline char basic_ios<charT, traits>::narrow(char_type c, char dfault) const

411

{

412

return dfault;

413

}

414

415

template <>

416

inline char basic_ios<char, char_traits<char> >::narrow(char_type c, char) const

417

{

418

return c;

419

}

420

421

#ifdef __UCLIBCXX_HAS_WCHAR__

422

423

template <>

424

inline char basic_ios<wchar_t, char_traits<wchar_t> >::narrow(char_type c, char dfault) const

425

{

426

char retval = wctob (c);

427

if(retval == EOF){

428

retval = dfault;

429

}

430

return retval;

431

}

432

433

#endif //__UCLIBCXX_HAS_WCHAR__

434

435

template <class charT, class traits>

436

inline typename basic_ios<charT, traits>::char_type

437

basic_ios<charT, traits>::widen(char c) const

438

{

439

return c;

440

}

441

442

template <>

443

inline basic_ios<char, char_traits<char> >::char_type

444

basic_ios<char, char_traits<char> >::widen(char c) const

445

{

446

return c;

447

}

448

449

#ifdef __UCLIBCXX_HAS_WCHAR__

450

451

template <>

452

inline basic_ios<wchar_t, char_traits<wchar_t> >::char_type

453

basic_ios<wchar_t, char_traits<wchar_t> >::widen(char c) const

454

{

455

return btowc(c);

456

}

457

458

#endif //__UCLIBCXX_HAS_WCHAR__

459

460

461

template <class stateT> class _UCXXEXPORT fpos{

462

public:

463

_UCXXEXPORT fpos(stateT s){

464

st = s;

465

}

466

_UCXXEXPORT stateT state() const{

467

return st;

468

}

469

_UCXXEXPORT void state(stateT s){

470

st = s;

471

}

472

_UCXXEXPORT bool operator==(const fpos &rhs){

473

return st == rhs.st;

474

}

475

_UCXXEXPORT bool operator!=(const fpos &rhs){

476

return st == rhs.st;

477

}

478

_UCXXEXPORT fpos & operator+(const streamoff & o){

479

st += o;

480

return *this;

481

}

482

_UCXXEXPORT fpos & operator-(const streamoff & o){

483

st -= o;

484

return *this;

485

}

486

_UCXXEXPORT streamoff operator-(const fpos & rhs){

487

return st - rhs.st;

488

}

489

490

491

private:

492

stateT st;

493

};

494

495

496

}

497

498

#pragma GCC visibility pop

499

500

#endif

501

Older »