irsstd.cpp

// Ñòàíäàðòàíàÿ áèáëèîòåêà ÈÐÑ
// Äàòà: 20.07.2010
// Ðàííÿÿ äàòà: 25.11.2007

// Íîìåð ôàéëà
#define IRSSTDCPP_IDX 15

#include <irspch.h>
#ifdef __BORLANDC__
#pragma hdrstop
#endif // __BORLANDC__

#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>

#include <irserror.h>

#include <irsstd.h>
//#include <irscpp.h>

#include <irsfinal.h>

// Êîíñòðóêòîð ïî óìîë÷àíèþ
mxconsole_t::mxconsole_t()
{
}
// Êîíñòðóêòîð
mxconsole_t::mxconsole_t(mxcondrv_t *a_condrv):
  f_condrv(a_condrv)
{
}
// Äåñòðóêòîð
mxconsole_t::~mxconsole_t()
{
}
// Âûâîä îòëàäî÷íîé èíôîðìàöèè ïî òèïó puts
void mxconsole_t::puts(const char *a_msg)
{
  const irs_u8 *msg = reinterpret_cast<const irs_u8 *>(a_msg);
  if (!f_condrv) return;
  if (!msg) return;
  irs_i32 len = strlen(reinterpret_cast<const char*>(msg));
  irs_u8 *msg_crlf = new irs_u8[len + 2];
  if (!msg_crlf) return;
  ::strcpy(reinterpret_cast<char*>(msg_crlf),
    reinterpret_cast<const char*>(msg));
  msg_crlf[len] = '\n';
  msg_crlf[len + 1] = 0;
  f_condrv->out(reinterpret_cast<const char*>(msg_crlf));
  delete []msg_crlf;
}
// Âûâîä îòëàäî÷íîé èíôîðìàöèè ïî òèïó printf
void mxconsole_t::printf(const char *a_format, ...)
{
  const irs_u8 *format = reinterpret_cast<const irs_u8 *>(a_format);
  if (!f_condrv) return;
  if (!format) return;
  irs_u8 *msgbuf;
  irs_i32 len;
  va_list arglist;
  va_start(arglist, a_format);
  len = vsnprintf(NULL, 0, reinterpret_cast<const char*>(format), arglist);
  len++;
  va_end(arglist);
  msgbuf = new irs_u8[len];
  if (!msgbuf) return;
  va_start(arglist, a_format);
  vsnprintf(reinterpret_cast<char*>(msgbuf), len,
    reinterpret_cast<const char*>(format), arglist);
  msgbuf[len - 1] = 0;
  va_end(arglist);
  f_condrv->out(reinterpret_cast<const char*>(msgbuf));
  delete []msgbuf;
}

// Êëàññ äëÿ ïðèëîæåíèÿ
mxapplication_t::mxapplication_t():
  first_exec(irs_true),
  stop_exec(irs_false),
  f_init(IRS_NULL),
  f_deinit(IRS_NULL),
  f_tick(IRS_NULL),
  f_stop(IRS_NULL),
  f_stopped(IRS_NULL)
{
}
mxapplication_t::~mxapplication_t()
{
}
irs_bool mxapplication_t::run(irs_bool exec)
{
  if (exec)
  if (first_exec) {
    first_exec = irs_false;
    init();
  }
  if (!first_exec) {
    if (!exec && !stop_exec) {
      stop_exec = irs_true;
      stop();
    }
    tick();
  }
  if (stopped() && !first_exec) {
    deinit();
    first_exec = irs_true;
    stop_exec = irs_false;
    return irs_false;
  } else {
    return irs_true;
  }
}
void mxapplication_t::set_init_event(void (*a_init)())
{
  f_init = a_init;
}
void mxapplication_t::set_denit_event(void (*a_deinit)())
{
  f_deinit = a_deinit;
}
void mxapplication_t::set_tick_event(void (*a_tick)())
{
  f_tick = a_tick;
}
void mxapplication_t::set_stop_event(void (*a_stop)())
{
  f_stop = a_stop;
}
void mxapplication_t::set_stopped_event(irs_bool (*a_stopped)())
{
  f_stopped = a_stopped;
}
void mxapplication_t::init()
{
  if (f_init) f_init();
}
void mxapplication_t::deinit()
{
  if (f_deinit) f_deinit();
}
void mxapplication_t::tick()
{
  if (f_tick) f_tick();
}
void mxapplication_t::stop()
{
  if (f_stop) f_stop();
}
irs_bool mxapplication_t::stopped()
{
  if (f_stopped) return f_stopped();
  else return irs_true;
}

// Ïåðåðàñïðåäåëåíèå ïàìÿòè ñ ñîõðàíåíèåì äàííûõ
void *irs_renew(void *pointer, size_t old_size, size_t new_size)
{
  if (old_size == new_size) return pointer;

  void *new_pointer = IRS_NULL;
  if (new_size) {
    new_pointer = reinterpret_cast<void*>(IRS_LIB_NEW_ASSERT(
      irs_u8 *[new_size], IRSSTDCPP_IDX));
    if (!new_pointer) return new_pointer;
  }
  if (pointer) {
    if (old_size && new_size) {
      memcpy(new_pointer, pointer, irs_min(old_size, new_size));
    }
    irs_u8*& pointer_u8 = reinterpret_cast<irs_u8*&>(pointer);
    IRS_LIB_ARRAY_DELETE_ASSERT(pointer_u8);
  }
  return new_pointer;
}
mxapplication_t *mxapplication = IRS_NULL;

void afloat_to_str(char *str, double N, size_t len, size_t accur,
  irs::num_mode_t a_num_mode)
{
  ostrstream strm(str, len + 1);
  switch (a_num_mode) {
    case irs::num_mode_invalid: {
      // Èãíîðèðóåì
    } break;
    case irs::num_mode_general: {
    } break;
    case irs::num_mode_fixed: {
      strm << fixed;
    } break;
    case irs::num_mode_scientific: {
      strm << scientific;
    } break;
  }
  strm << setw(len) << setprecision(accur) << N;
  strm << '\0';
  str[len] = '\0';
}

#if defined(__ICCAVR__) || defined(__ICCARM__)
#if defined(__ICCAVR__)
__flash irs_u8 lcd_table[] =
#elif defined(__ICCARM__)
const irs_u8 lcd_table[] =
#endif
{
  0x20, // '~':0
  0xFF, // '~':1 //Êóðñîð êâàäðàòîì
  0x20, // '~':2
  0x20, // '~':3
  0x20, // '~':4
  0x20, // '~':5
  0x20, // '~':6
  0x20, // '~':7
  0x20, // '~':8
  0x20, // '~':9
  0x20, // '~':10
  0x20, // '~':11
  0x20, // '~':12
  0x20, // '~':13
  0x20, // '~':14
  0x20, // '~':15
  0x20, // '~':16
  0x20, // '~':17
  0x20, // '~':18
  0x20, // '~':19
  0x20, // '~':20
  0x20, // '~':21
  0x20, // '~':22
  0x20, // '~':23
  0x20, // '~':24
  0x20, // '~':25
  0x20, // '~':26
  0x20, // '~':27
  0x20, // '~':28
  0x20, // '~':29
  0x20, // '~':30
  0x20, // '~':31
  0x20, // ' ':32
  0x21, // '!':33
  0x22, // '"':34
  0xEF,//0x23, // '#':35-------led on
  0xEE, // '$':36--------------led off
  0x25, // '%':37
  0x26, // '&':38
  0x27, // ''':39
  0x28, // '(':40
  0x29, // ')':41
  0x2A, // '*':42
  0x2B, // '+':43
  0x2C, // ',':44
  0x2D, // '-':45
  0x2E, // '.':46
  0x2F, // '/':47
  0x30, // '0':48
  0x31, // '1':49
  0x32, // '2':50
  0x33, // '3':51
  0x34, // '4':52
  0x35, // '5':53
  0x36, // '6':54
  0x37, // '7':55
  0x38, // '8':56
  0x39, // '9':57
  0x3A, // ':':58
  0x3B, // ';':59
  0x3C, // '<':60
  0x3D, // '=':61
  0x3E, // '>':62
  0x3F, // '?':63
  0x40, // '@':64
  0x41, // 'A':65
  0x42, // 'B':66
  0x43, // 'C':67
  0x44, // 'D':68
  0x45, // 'E':69
  0x46, // 'F':70
  0x47, // 'G':71
  0x48, // 'H':72
  0x49, // 'I':73
  0x4A, // 'J':74
  0x4B, // 'K':75
  0x4C, // 'L':76
  0x4D, // 'M':77
  0x4E, // 'N':78
  0x4F, // 'O':79
  0x50, // 'P':80
  0x51, // 'Q':81
  0x52, // 'R':82
  0x53, // 'S':83
  0x54, // 'T':84
  0x55, // 'U':85
  0x56, // 'V':86
  0x57, // 'W':87
  0x58, // 'X':88
  0x59, // 'Y':89
  0x5A, // 'Z':90
  0x5B, // '[':91
  0x5C, // '\':92
  0x5D, // ']':93
  0xD9, // '^':94 ñòðåëêà ââåðõ
  0x5F, // '_':95
  0x60, // '`':96
  0x61, // 'a':97
  0x62, // 'b':98
  0x63, // 'c':99
  0x64, // 'd':100
  0x65, // 'e':101
  0x66, // 'f':102
  0x67, // 'g':103
  0x68, // 'h':104
  0x69, // 'i':105
  0x6A, // 'j':106
  0x6B, // 'k':107
  0x6C, // 'l':108
  0x6D, // 'm':109
  0x6E, // 'n':110
  0x6F, // 'o':111
  0x70, // 'p':112
  0x71, // 'q':113
  0x72, // 'r':114
  0x73, // 's':115
  0x74, // 't':116
  0x75, // 'u':117
  0x76, // 'v':118
  0x77, // 'w':119
  0x78, // 'x':120
  0x79, // 'y':121
  0x7A, // 'z':122
  0x20, // '{':123
  0x20, // '|':124
  0x20, // '}':125
  0xDA, // '~':126 ñòðåëêà âíèç
  0x20, // '':127
  0x20, // '€':128
  0x20, // '':129
  0x20, // '‚':130
  0x20, // 'ƒ':131
  0xCA, // '„':132
  0x20, // '…':133
  0x20, // '†':134
  0x20, // '‡':135
  0x7E, // 'ˆ':136 'enter'
  0xD4, // '‰':137
  0x20, // 'Š':138
  0x20, // '‹':139
  0x20, // 'Œ':140
  0x20, // '':141
  0x20, // 'Ž':142
  0xE9, // '':143
  0x20, // '':144
  0x27, // '‘':145
  0x27, // '’':146
  0xCB, // '“':147
  0xCB, // '”':148
  0xDF, // '•':149
  0x2D, // '–':150
  0x2D, // '—':151
  0x20, // '~':152
  0x20, // '™':153
  0x20, // 'š':154
  0x3E, // '›':155
  0x20, // 'œ':156
  0x20, // '':157
  0x20, // 'ž':158
  0x20, // 'Ÿ':159
  0x20, // ' ':160
  0x20, // '¡':161
  0x20, // '¢':162
  0x4A, // '£':163
  0x20, // '¤':164
  0x20, // '¥':165
  0x20, // '¦':166
  0xFD, // '§':167
  0xA2, // '¨':168
  0x20, // '©':169
  0x20, // 'ª':170
  0xC8, // '«':171
  0x20, // '¬':172
  0x2D, // '­':173
  0x20, // '®':174
  0x20, // '¯':175
  0xEF, // '°':176
  0x20, // '±':177
  0x49, // '²':178
  0x69, // '³':179
  0xB4, // '´':180
  0x75, // 'µ':181
  0xFE, // '¶':182
  0xDF, // '·':183
  0xB5, // '¸':184
  0x23, // '¹':185
  0x20, // 'º':186
  0xC9, // '»':187
  0x6A, // '¼':188
  0x53, // '½':189
  0x73, // '¾':190
  0x69, // '¿':191
  0x41, // 'À':192
  0xA0, // 'Á':193
  0x42, // 'Â':194
  0xA1, // 'Ã':195
  0xE0, // 'Ä':196
  0x45, // 'Å':197
  0xA3, // 'Æ':198
  0x33, // 'Ç':199
  0xA5, // 'È':200
  0xA6, // 'É':201
  0x4B, // 'Ê':202
  0xA7, // 'Ë':203
  0x4D, // 'Ì':204
  0x48, // 'Í':205
  0x4F, // 'Î':206
  0xA8, // 'Ï':207
  0x50, // 'Ð':208
  0x43, // 'Ñ':209
  0x54, // 'Ò':210
  0xA9, // 'Ó':211
  0xAA, // 'Ô':212
  0x58, // 'Õ':213
  0xE1, // 'Ö':214
  0xAB, // '×':215
  0xAC, // 'Ø':216
  0xE2, // 'Ù':217
  0xAD, // 'Ú':218
  0xAE, // 'Û':219
  0xAD, // 'Ü':220 = 'Ú'
  0xAF, // 'Ý':221
  0xB0, // 'Þ':222
  0xB1, // 'ß':223
  0x61, // 'à':224
  0xB2, // 'á':225
  0xB3, // 'â':226
  0xB4, // 'ã':227
  0xE3, // 'ä':228
  0x65, // 'å':229
  0xB6, // 'æ':230
  0xB7, // 'ç':231
  0xB8, // 'è':232
  0xB9, // 'é':233
  0xBA, // 'ê':234
  0xBB, // 'ë':235
  0xBC, // 'ì':236
  0xBD, // 'í':237
  0x6F, // 'î':238
  0xBE, // 'ï':239
  0x70, // 'ð':240
  0x63, // 'ñ':241
  0xBF, // 'ò':242
  0x79, // 'ó':243
  0xE4, // 'ô':244
  0x78, // 'õ':245
  0xE5, // 'ö':246
  0xC0, // '÷':247
  0xC1, // 'ø':248
  0xE6, // 'ù':249
  0xC2, // 'ú':250
  0xC3, // 'û':251
  0xC4, // 'ü':252
  0xC5, // 'ý':253
  0xC6, // 'þ':254
  0xC7  // 'ÿ':255
};
#endif //defined(__ICCAVR__) || defined(__ICCARM__)

#ifdef __ICCAVR__
// Êàðòà ïðåîáðàçîâàíèÿ íîìåðîâ êëàâèø â êîäû
// äëÿ âåðòèêàëüíîãî ðàñïîëîæåíèÿ êëàâèàòóðû
__flash irskey_t irskbd_table_vertical[] =
{
  irskey_none,      // 0
  irskey_0,         // 1
  irskey_1,         // 2
  irskey_2,         // 3
  irskey_3,         // 4
  irskey_4,         // 5
  irskey_5,         // 6
  irskey_6,         // 7
  irskey_7,         // 8
  irskey_8,         // 9
  irskey_9,         // 10
  irskey_point,     // 11
  irskey_enter,     // 12
  irskey_up,        // 13
  irskey_down,      // 14
  irskey_backspace, // 15
  irskey_escape     // 16
};

// Êàðòà ïðåîáðàçîâàíèÿ íîìåðîâ êëàâèø â êîäû
// äëÿ ãîðèçîíòàëüíîãî ðàñïîëîæåíèÿ êëàâèàòóðû
__flash irskey_t irskbd_table_horisontal[] =
{
  irskey_none,      // 0
  irskey_enter,     // 1
  irskey_backspace, // 2
  irskey_3,         // 3
  irskey_6,         // 4
  irskey_point,     // 5
  irskey_2,         // 6
  irskey_5,         // 7
  irskey_0,         // 8
  irskey_1,         // 9
  irskey_4,         // 10
  irskey_down,      // 11
  irskey_escape,    // 12
  irskey_8,         // 13
  irskey_9,         // 14
  irskey_up,        // 15
  irskey_7          // 16
};

// Êàðòà ïðåîáðàçîâàíèÿ íîìåðîâ êëàâèø â êîäû
// äëÿ ðàñïîëîæåíèÿ êëàâèàòóðû äëÿ ÃÒ× rev 0 (ìàêåòêà edition)
__flash irskey_t irskbd_table_gtch_rev_0[] =
{
  irskey_none,      // 0
  irskey_none,      // 1
  irskey_none,      // 2
  irskey_escape,    // 3
  irskey_6,         // 4
  irskey_none,      // 5
  irskey_2,         // 6
  irskey_5,         // 7
  irskey_none,      // 8
  irskey_1,         // 9
  irskey_4,         // 10
  irskey_enter,     // 11
  irskey_up,        // 12
  irskey_8,         // 13
  irskey_9,         // 14
  irskey_down,      // 15
  irskey_7          // 16
};

// Êàðòà ïðåîáðàçîâàíèÿ íîìåðîâ êëàâèø â êîäû
// äëÿ ðàñïîëîæåíèÿ êëàâèàòóðû äëÿ ÃÒ× rev 1 (÷åìîäàí edition)
__flash irskey_t irskbd_table_gtch_rev_1[] =
{
  irskey_none,      // 0
  irskey_none,      // 1
  irskey_none,      // 2
  irskey_2,         // 3
  irskey_5,         // 4
  irskey_none,      // 5
  irskey_escape,    // 6
  irskey_6,         // 7
  irskey_none,      // 8
  irskey_enter,     // 9
  irskey_down,      // 10
  irskey_1,         // 11
  irskey_7,         // 12
  irskey_9,         // 13
  irskey_8,         // 14
  irskey_4,         // 15
  irskey_up         // 16
};

//#define avr_port_map_size IRS_ARRAYOFSIZE(avr_port_map);
const irs_avr_port_map_t* irs::get_avr_port_map()
{
  static const irs_avr_port_map_t avr_port_map_i[] = {
    {&PORTA, &PINA, &DDRA},
    {&PORTB, &PINB, &DDRB},
    {&PORTC, &PINC, &DDRC},
    {&PORTD, &PIND, &DDRD},
    {&PORTE, &PINE, &DDRE},
    {&PORTF, &PINF, &DDRF},
    {&PORTG, &PING, &DDRG}
  };

  return avr_port_map_i;
}


//__flash irs_u8 lcd_table[] =

mxkey_drv_avr_t::mxkey_drv_avr_t(irskbd_t type, irskbd_map_t map_type,
  irs_avr_port_t a_port):
  m_high_set_bit(7),
  m_high_get_bit(3),
  mp_set(avr_port_map[a_port].set),
  mp_get(avr_port_map[a_port].get),
  mp_dir(avr_port_map[a_port].dir)
{
  switch (type) {
    case irskbd_high_pull_up: {
      m_high_set_bit = 3;
      m_high_get_bit = 7;
      (*mp_dir) = 0x0F;
    } break;

    default:
    case irskbd_low_pull_up: {
      m_high_set_bit = 7;
      m_high_get_bit = 3;
      (*mp_dir) = 0xF0;
    } break;
  }
  switch(map_type) {
    default:
    case irskbd_map_vertical: {
      mp_key_map = irskbd_table_vertical;
    } break;

    case irskbd_map_horisontal: {
      mp_key_map = irskbd_table_horisontal;
    } break;

    case irskbd_map_gtch_rev_1: {
      mp_key_map = irskbd_table_gtch_rev_1;
    } break;
  }
  (*mp_set) = (*mp_dir)^0xFF;
}
mxkey_drv_avr_t::~mxkey_drv_avr_t()
{
  (*mp_dir) = 0x00;
  (*mp_set) = 0x00;
}
irskey_t mxkey_drv_avr_t::operator()()
{
  reshor(0);
  sethor(1);
  sethor(2);
  sethor(3);
  if (!chkver(0)) return mp_key_map[8];
  if (!chkver(1)) return mp_key_map[9];
  if (!chkver(2)) return mp_key_map[10];
  if (!chkver(3)) return mp_key_map[16];
  sethor(0);
  reshor(1);
  sethor(2);
  sethor(3);
  if (!chkver(0)) return mp_key_map[5];
  if (!chkver(1)) return mp_key_map[6];
  if (!chkver(2)) return mp_key_map[7];
  if (!chkver(3)) return mp_key_map[13];
  sethor(0);
  sethor(1);
  reshor(2);
  sethor(3);
  if (!chkver(0)) return mp_key_map[2];
  if (!chkver(1)) return mp_key_map[3];
  if (!chkver(2)) return mp_key_map[4];
  if (!chkver(3)) return mp_key_map[14];
  sethor(0);
  sethor(1);
  sethor(2);
  reshor(3);
  if (!chkver(0)) return mp_key_map[1];
  if (!chkver(1)) return mp_key_map[11];
  if (!chkver(2)) return mp_key_map[15];
  if (!chkver(3)) return mp_key_map[12];

  return mp_key_map[0];
}

//  Ïåðåêîäèðîâêà ñèìâîëîâ Windows-1251 â êîäû êîíòðîëëåðà Epson íà áàçå
// HD44780 ñ ðàçíûìè ïðèáàìáàñàìè

// Êëàññ äðàéâåðà äèñïëåÿ AVR

#define LCD_INIT_DELAY_MS 15
#define LCD_TICK_DELAY_US 100 //100
#define LCD_CYCLE_DELAY_US 40

//#define LCD_SIZE 80 //symbols
#define LINE0 0
#define LINE1 20
#define LINE2 40
#define LINE3 60
#define LINE0_ADR 0x00
#define LINE1_ADR 0x40
#define LINE2_ADR 0x14
#define LINE3_ADR 0x54
//#define LINE_LEN 20

#define IMAGE_ON 0x0C   //  Âêëþ÷åíèå èçîáðàæåíèÿ, êóðñîðîâ åñòü
#define IMAGE_OFF 0x08  //  Âûêëþ÷åíèå èçîáðàæåíèÿ
#define BUS_8BIT 0x30   //  Èíèöèàëèçàöèîííàÿ êîìàíäà - âûáîð øèðèíû øèíû
                        // äàííûõ = 8 áèò
#define TWO_LINES 0x38  //  8 áèò øèíà äàííûõ, ðåæèì îòîáðàæåíèÿ 2 ñòðîêè,
                        // ðàçìåð ìàòðèöû ñèìâîëà 5 õ 8 òî÷åê
#define ADR_INC 0x06    //  Ñ÷åò÷èê àäðåñà èíêðåìåíòèðóåòñÿ
#define LCD_NULL 0      //  Íè÷î

// Êðàøåíèííèêîâ: Ïî÷åìó-òî îòñóòñâîâàëè îïðåäåëåíèÿ OLED_
// Êîíêðåòíûå çíà÷åíèÿ âçÿòû èç mxdisplay_drv_gen_t
#define OLED_FUNCTION_SET 0x3A
#define OLED_DISPLAY_ON 0x0C
#define OLED_DISPLAY_CLEAR 0x01

#define lcd_delay_mcs(delay)\
{\
  set_to_cnt(lcd_timer, MCS_TO_CNT(delay));\
  while (!test_to_cnt(lcd_timer));\
}
#define lcd_delay_ms(delay)\
{\
  set_to_cnt(lcd_timer, MS_TO_CNT(delay));\
  while (!test_to_cnt(lcd_timer));\
}
#define lcd_init_command(command)\
{\
  lcd_IR_enable();\
  set_to_cnt(lcd_timer, MS_TO_CNT(LCD_INIT_DELAY_MS));\
  while (!test_to_cnt(lcd_timer));\
  lcd_enable();\
  set_to_cnt(lcd_timer, MS_TO_CNT(LCD_INIT_DELAY_MS));\
  while (!test_to_cnt(lcd_timer));\
  lcd_out(command);\
  set_to_cnt(lcd_timer, MS_TO_CNT(LCD_INIT_DELAY_MS));\
  while (!test_to_cnt(lcd_timer));\
  lcd_disable();\
  set_to_cnt(lcd_timer, MS_TO_CNT(LCD_INIT_DELAY_MS));\
  while (!test_to_cnt(lcd_timer));\
  lcd_out(LCD_NULL);\
}



mxdisplay_drv_avr_t::mxdisplay_drv_avr_t(
  irslcd_t a_type,
  irs_avr_port_t a_data_port,
  irs_avr_port_t a_control_port,
  irs_u8 a_control_pin
):
  mp_set_data(avr_port_map[a_data_port].set),
  mp_get_data(avr_port_map[a_data_port].get),
  mp_dir_data(avr_port_map[a_data_port].dir),
  mp_set_control(avr_port_map[a_control_port].set),
  mp_get_control(avr_port_map[a_control_port].get),
  mp_dir_control(avr_port_map[a_control_port].dir),
  m_LCD_E(a_control_pin + 0),
  m_LCD_RS(a_control_pin + 1),
  LINE_COUNT(4),
  LINE_LEN(20),
  LCD_SIZE(LINE_LEN*LINE_COUNT),
  lcd_status(LCD_BEGIN),
  lcd_ram(IRS_NULL),
  lcd_current_symbol(0),
  lcd_current_symbol_address(0),
  lcd_init_counter(0),
  lcd_timer(0),
  lcd_address_jump(irs_false)
{
  init_to_cnt();

  lcd_ram = new irs_u8[LCD_SIZE];
  memset(lcd_ram, ' ', LCD_SIZE);

  //IRS_PAUSE(TIME_TO_CNT(1, 1));

  //  Èíèöèàëèçàöèÿ ïîðòîâ ââîäà/âûâîäà
  (*mp_dir_data) = 0xFF;  //  Øèíà äàííûõ LCD
  (*mp_set_data) = 0x00;
  (*mp_dir_control) |= ((1 << m_LCD_RS)|(1 << m_LCD_E)); //  Ëèíèè E è RS LCD
  (*mp_set_control) &= (((1 << m_LCD_RS)|(1 << m_LCD_E))^0xFF);

  // Íà÷àëüíàÿ ïàóçà äëÿ ñòàáèëèçàöèè ïèòàíèÿ
  irs::pause(irs::make_cnt_ms(200));

  switch (a_type) {
    // Èíèöèàëèçàöèÿ OLED-èíäèêàòîðà
    case irslcd_oled_4x20: {
      lcd_init_command(OLED_FUNCTION_SET);
      irs::pause(irs::make_cnt_ms(LCD_INIT_DELAY_MS));
      lcd_init_command(OLED_DISPLAY_ON);
      irs::pause(irs::make_cnt_ms(LCD_INIT_DELAY_MS));
      lcd_init_command(OLED_DISPLAY_CLEAR);
      irs::pause(irs::make_cnt_ms(LCD_INIT_DELAY_MS));
      lcd_init_command(ADR_INC);
    } break;
    // Èíèöèàëèçàöèÿ LCD-èíäèêàòîðà
    default: {
      for (irs_u8 i = 0; i < 3; i++)
      {
        //  Âûäåðæêà
        lcd_delay_ms(LCD_INIT_DELAY_MS);
        //  Êîìàíäà
        lcd_init_command(BUS_8BIT);
        //  È òàê - 3 ðàçà
      }
      lcd_delay_ms(LCD_INIT_DELAY_MS);
      lcd_init_command(TWO_LINES);
      lcd_delay_ms(LCD_INIT_DELAY_MS);
      lcd_init_command(IMAGE_ON);
      lcd_delay_ms(LCD_INIT_DELAY_MS);
      lcd_init_command(ADR_INC);
    }
  }
}
mxdisplay_drv_avr_t::~mxdisplay_drv_avr_t()
{
  //  Ãàøåíèå èíäèêàòîðà
  lcd_delay_mcs(LCD_TICK_DELAY_US);
  lcd_init_command(IMAGE_OFF);
  //  Äåèíèöèàëèçàöèÿ ïîðòîâ ââîäà/âûâîäà
  //  Øèíà äàííûõ LCD
  (*mp_dir_data) = 0x0;
  (*mp_set_data) = 0x00;
  //  Ëèíèè E è RS LCD
  (*mp_dir_control) &= (((1 << m_LCD_RS)&(1 << m_LCD_E))^0xFF);
  (*mp_set_control) &= (((1 << m_LCD_RS)&(1 << m_LCD_E))^0xFF);

  delete []lcd_ram;

  deinit_to_cnt();
}
mxdisp_pos_t mxdisplay_drv_avr_t::get_height()
{
  return LINE_COUNT;
}
mxdisp_pos_t mxdisplay_drv_avr_t::get_width()
{
  return LINE_LEN;
}
void mxdisplay_drv_avr_t::outtextpos(mxdisp_pos_t a_left, mxdisp_pos_t a_top,
  const char *text)
{
  irs_u8 begin = (irs_u8)(a_top*LINE_LEN) + a_left;
  irs_u8 delta = LCD_SIZE - begin;
  for (irs_u8 i = 0; (i < strlen(text))&&(i < delta); i++) {
    lcd_ram[begin + i] = lcd_table[(irs_u8)text[i]];
  }
}
void mxdisplay_drv_avr_t::tick()
{
  switch (lcd_status)
  {
  case LCD_BEGIN:
    {
      set_to_cnt(lcd_timer, MCS_TO_CNT(LCD_TICK_DELAY_US));
      lcd_status = LCD_RS;
      break;
    }
  case LCD_RS:
    {
      if (test_to_cnt(lcd_timer))
      {
        set_to_cnt(lcd_timer, MCS_TO_CNT(LCD_TICK_DELAY_US));
        if (lcd_current_symbol > LCD_SIZE-1) lcd_current_symbol = 0;
        if (lcd_address_jump == irs_false)
        {
          switch (lcd_current_symbol)
          {
          case LINE0:
            {
              lcd_current_symbol_address = LINE0_ADR;
              lcd_status = LCD_ADDRESS_OUT;
              lcd_address_jump = irs_true;
              lcd_IR_enable();
              break;
            }
          case /*(irs_u8)(LCD_SIZE/2)*/LINE1:
            {
              //  Ïåðåõîä íà âòîðóþ ñòðîêó. Àäðåñ çàïèñûâàåòñÿ â èíäèêàòîð
              // òîëüêî ïðè ïåðåõîäå íà íîâóþ ñòðîêó
              lcd_current_symbol_address = LINE1_ADR;
              lcd_status = LCD_ADDRESS_OUT;
              lcd_address_jump = irs_true;
              lcd_IR_enable();
              break;
            }
          case LINE2:
            {
              //  Ïåðåõîä íà òðåòüþ ñòðîêó. Àäðåñ çàïèñûâàåòñÿ â èíäèêàòîð
              // òîëüêî ïðè ïåðåõîäå íà íîâóþ ñòðîêó
              lcd_current_symbol_address = LINE2_ADR;
              lcd_status = LCD_ADDRESS_OUT;
              lcd_address_jump = irs_true;
              lcd_IR_enable();
              break;
            }
          case LINE3:
            {
              //  Ïåðåõîä íà ÷åòâåðòóþ ñòðîêó. Àäðåñ çàïèñûâàåòñÿ â èíäèêàòîð
              // òîëüêî ïðè ïåðåõîäå íà íîâóþ ñòðîêó
              lcd_current_symbol_address = LINE3_ADR;
              lcd_status = LCD_ADDRESS_OUT;
              lcd_address_jump = irs_true;
              lcd_IR_enable();
              break;
            }
          default:
            {
              lcd_status = LCD_DATA_OUT;
              lcd_DR_enable();
              break;
            }
          }
        }
        else
        {
          lcd_status = LCD_DATA_OUT;
          lcd_DR_enable();
          lcd_address_jump = irs_false;
        }
      }
      break;
    }
  case LCD_DATA_OUT:
    {
      if (test_to_cnt(lcd_timer))
      {
        lcd_status = LCD_E_RISE;
        lcd_out(lcd_ram[lcd_current_symbol]);
        lcd_current_symbol++;
        set_to_cnt(lcd_timer, MCS_TO_CNT(LCD_TICK_DELAY_US));
      }
      break;
    }
  case LCD_ADDRESS_OUT:
    {
      if (test_to_cnt(lcd_timer))
      {
        set_to_cnt(lcd_timer, MCS_TO_CNT(LCD_TICK_DELAY_US));
        lcd_status = LCD_E_RISE;
        lcd_out(lcd_current_symbol_address|0x80);
      }
      break;
    }
  case LCD_E_RISE:
    {
      if (test_to_cnt(lcd_timer))
      {
        set_to_cnt(lcd_timer, MCS_TO_CNT(LCD_TICK_DELAY_US));
        lcd_status = LCD_E_FALL;
        lcd_enable();
      }
      break;
    }
  case LCD_E_FALL:
    {
      if (test_to_cnt(lcd_timer))
      {
        set_to_cnt(lcd_timer, MCS_TO_CNT(LCD_CYCLE_DELAY_US));
        lcd_status = LCD_RS;
        lcd_disable();
      }
      break;
    }
  case LCD_FREE:
    {
      lcd_disable();
      lcd_out(0);
      break;
    }
  }
}
#endif //__ICCAVR__

#if defined(__ICCAVR__) || defined(__ICCARM__)

mxdisplay_drv_gen_t::mxdisplay_drv_gen_t(
  irslcd_t a_type,
  irs::gpio_port_t& a_data_port,
  irs::gpio_pin_t& a_rs_pin,
  irs::gpio_pin_t& a_e_pin
):
  m_data_port(a_data_port),
  m_rs_pin(a_rs_pin),
  m_e_pin(a_e_pin),
  m_line_cnt(0),
  m_line_len(0),
  m_lcd_size(m_line_cnt * m_line_len),
  m_status(lcd_init_wait),
  m_target_status(lcd_init),
  m_ram_vector(m_lcd_size, ' '),
  m_current_symbol(0),
  m_current_symbol_address(0),
  m_lcd_init_counter(0),
  m_timer(irs::make_cnt_ms(m_start_interval)),
  m_address_jump(false),
  m_command(m_com_null)
{
  if (a_type == irslcd_4x20) {
    m_line_cnt = 4;
    m_line_len = 20;
    m_lcd_size = m_line_cnt * m_line_len;
  }
  m_ram_vector.resize(m_lcd_size, ' ');
  m_data_port.set(0);
  m_rs_pin.clear();
  m_e_pin.clear();
  m_timer.start();
}

mxdisplay_drv_gen_t::~mxdisplay_drv_gen_t()
{
  m_data_port.set(0);
  m_rs_pin.clear();
  m_e_pin.clear();
}
mxdisp_pos_t mxdisplay_drv_gen_t::get_height()
{
  return m_line_cnt;
}
mxdisp_pos_t mxdisplay_drv_gen_t::get_width()
{
  return m_line_len;
}
void mxdisplay_drv_gen_t::outtextpos(mxdisp_pos_t a_left, mxdisp_pos_t a_top,
  const char *text)
{
  irs_u8 begin = (irs_u8)(a_top * m_line_len) + a_left;
  irs_u8 end = m_lcd_size - begin;
  irs_u8 len = strlen(text);
  if (end > len) end = len;
  for (irs_u8 i = 0; i < end; i++) {
    m_ram_vector[begin + i] = lcd_table[(irs_u8)text[i]];
  }
}
void mxdisplay_drv_gen_t::tick()
{
  switch (m_status) {
    case lcd_init_wait: {
      if (m_timer.check()) {
        m_status = lcd_init;
      }
    } break;
    case lcd_init: {
      m_target_status = lcd_init;
      switch (m_lcd_init_counter) {
        case 0: m_command = m_com_function_set;   break;
        case 1: m_command = m_com_disp_on;        break;
        case 2: m_command = m_com_disp_clear;     break;
        case 3: m_command = m_com_entry_mode_set; break;
        default: {
          m_target_status = lcd_begin;
        }
      }
      m_lcd_init_counter++;
      m_status = lcd_data_out;
      m_timer.set(irs::make_cnt_mcs(m_trans_interval));
    } break;
    case lcd_data_out: {
      if (m_timer.check()) {
        m_timer.start();
        m_data_port.set(m_command);
        m_status = lcd_e_rise;
      } break;
    }
    case lcd_e_rise: {
      if (m_timer.check()) {
        m_timer.start();
        m_e_pin.set();
        m_status = lcd_e_fall;
      } break;
    }
    case lcd_e_fall: {
      if (m_timer.check()) {
        if (m_command == m_com_disp_clear) {
          m_timer.set(irs::make_cnt_ms(m_clear_interval));
        } else {
          m_timer.set(irs::make_cnt_mcs(m_trans_interval));
        }
        m_timer.start();
        m_e_pin.clear();
        m_status = lcd_data_clear;
      }
    } break;
    case lcd_data_clear: {
      if (m_timer.check()) {
        m_data_port.set(m_com_null);
        m_status = m_target_status;
      }
    } break;
    case lcd_begin: {
      m_timer.start();
      if (m_current_symbol > m_lcd_size - 1) m_current_symbol = 0;
      if (!m_address_jump) {
        m_address_jump = true;
        switch (m_current_symbol) {
          case m_line_0: m_command = 0x80|m_line_0_addr; break;
          case m_line_1: m_command = 0x80|m_line_1_addr; break;
          case m_line_2: m_command = 0x80|m_line_2_addr; break;
          case m_line_3: m_command = 0x80|m_line_3_addr; break;
          default: {
            m_address_jump = false;
            m_command = m_ram_vector[m_current_symbol];
            m_current_symbol++;
          }
        }
      } else {
        m_address_jump = false;
        m_command = m_ram_vector[m_current_symbol];
        m_current_symbol++;
      }
      if (m_address_jump) {
        m_rs_pin.clear();
      } else {
        m_rs_pin.set();
      }
      m_status = lcd_data_out;
      m_target_status = lcd_begin;
    } break;
  }
}

#endif  //  __ICCAVR__ || __ICCARM__

#ifdef __BORLANDC__
// Âñïîìîãàòåëüíûé êëàññ äðàéâåðà êëàâèàòóðû Ñ++ Builder
class mxkdb_keystate_t: TObject
{
  Word f_key;
  void __fastcall KeyDown(System::TObject* Sender, Word &Key,
    Classes::TShiftState Shift);
  void __fastcall KeyUp(System::TObject* Sender, Word &Key,
    Classes::TShiftState Shift);
public:
  mxkdb_keystate_t();
  virtual __fastcall ~mxkdb_keystate_t();
  void connect(TMemo *input);
  Word operator()();
};

// Êëàññ äðàéâåðà êîíñîëè äëÿ îáúåêòà TStrings C++ Builder
mxbuilder_condrv_t::mxbuilder_condrv_t()
{
}
mxbuilder_condrv_t::mxbuilder_condrv_t(TStrings *Console):
  f_console(Console)
{
}
void mxbuilder_condrv_t::out(const char *str)
{
  int len_s = strlen((char *)str);
  //char *message = (char *)malloc(len_s + 1);
  char *message = new char[len_s + 1];
  if (!message) return;
  ::strcpy(message, (char *)str);
  char *message_line = message;
  //TStrings *Console = MainForm->Memo1->Lines;
  for (int i_msg_ch = 0; i_msg_ch < len_s; i_msg_ch++) {
    if ('\n' == message[i_msg_ch]) {
      message[i_msg_ch] = 0;
      if (f_console->Count <= 0) f_console->Add("");
      String ConsoleLine = f_console->Strings[f_console->Count - 1];
      ConsoleLine += String(message_line);
      f_console->Strings[f_console->Count - 1] = ConsoleLine;
      f_console->Add("");
      message_line = &message[i_msg_ch + 1];
    }
  }
  if (len_s > 0)
  if (message[len_s - 1] != '\n') {
    if (f_console->Count <= 0) f_console->Add("");
    String ConsoleLine = f_console->Strings[f_console->Count - 1];
    ConsoleLine += String(message_line);
    f_console->Strings[f_console->Count - 1] = ConsoleLine;
  }
  delete []message;
}

// Êëàññ äëÿ àâòîïîäêëþ÷åíèÿ mainprg ê ïðèëîæåíèþ íà C++ Builder
__fastcall mpc_builder_t::mpc_builder_t():
  m_timer(IRS_NULL),
  m_SavedCloseEvent(IRS_NULL),
  m_form(IRS_NULL),
  m_app_proc(IRS_NULL),
  m_mxapplication(IRS_NULL)
{
}
__fastcall mpc_builder_t::~mpc_builder_t()
{
  if (m_timer) delete m_timer;
  m_timer = IRS_NULL;
  if (m_mxapplication) delete m_mxapplication;
  m_mxapplication = IRS_NULL;
}
void mpc_builder_t::TimerInit(TNotifyEvent Event)
{
  m_timer = new TTimer(IRS_NULL);
  m_timer->OnTimer = Event;
  m_timer->Interval = 10;
  m_timer->Enabled = true;
}

void mpc_builder_t::Connect(TForm *Form, void (*a_init)(), void (*a_deinit)(),
  void (*a_tick)(), void (*a_stop)(), irs_bool (*a_stopped)())
{
  m_form = Form;
  m_SavedCloseEvent = m_form->OnClose;
  m_form->OnClose = MainFormClose;

  m_mxapplication = new mxapplication_t();
  m_mxapplication->set_init_event(a_init);
  m_mxapplication->set_denit_event(a_deinit);
  m_mxapplication->set_tick_event(a_tick);
  m_mxapplication->set_stop_event(a_stop);
  m_mxapplication->set_stopped_event(a_stopped);
  m_mxapplication->run(irs_true);

  TimerInit(TimerEvent);
}
void __fastcall mpc_builder_t::MainFormClose(System::TObject* Sender,
  TCloseAction &Action)
{
  if (m_SavedCloseEvent) m_SavedCloseEvent(Sender, Action);
  while (m_mxapplication->run(irs_false));
}
void __fastcall mpc_builder_t::TimerEvent(System::TObject* Sender)
{
  if (!m_mxapplication->run(irs_true)) {
    m_timer->Enabled = false;
    m_form->Close();
    return;
  }
}
void mpc_builder_t::Connect(TForm *a_Form, mx_proc_t *a_app_proc)
{
  m_form = a_Form;
  m_SavedCloseEvent = m_form->OnClose;
  m_form->OnClose = ProcClose;

  m_app_proc = a_app_proc;

  TimerInit(ProcTimer);
}
void __fastcall mpc_builder_t::ProcClose(System::TObject* Sender,
  TCloseAction &Action)
{
  if (m_SavedCloseEvent) m_SavedCloseEvent(Sender, Action);
  m_app_proc->abort();
  while (m_app_proc->tick());
}
void __fastcall mpc_builder_t::ProcTimer(System::TObject* Sender)
{
  if (!m_app_proc->tick()) {
    m_timer->Enabled = false;
    m_form->Close();
    return;
  }
}

// Êëàññ äðàéâåðà êëàâèàòóðû Ñ++ Builder
mxkey_drv_builder_t::mxkey_drv_builder_t():
  keystate(IRS_NULL)
{
  keystate = (void *)new mxkdb_keystate_t();
}
mxkey_drv_builder_t::~mxkey_drv_builder_t()
{
  delete (mxkdb_keystate_t *)keystate;
}
void mxkey_drv_builder_t::connect(TMemo *a_display)
{
  ((mxkdb_keystate_t *)keystate)->connect(a_display);
}
irskey_t mxkey_drv_builder_t::operator()()
{
  typedef struct _key_map_t {
    Word win_key;
    irskey_t irs_key;
  } key_map_t;
  key_map_t key_map[] = {
    {VK_RETURN,     irskey_enter},
    {VK_SEPARATOR,  irskey_enter},
    {VK_ESCAPE,     irskey_escape},
    {VK_UP,         irskey_up},
    {VK_DOWN,       irskey_down},
    {'0',           irskey_0},
    {'1',           irskey_1},
    {'2',           irskey_2},
    {'3',           irskey_3},
    {'4',           irskey_4},
    {'5',           irskey_5},
    {'6',           irskey_6},
    {'7',           irskey_7},
    {'8',           irskey_8},
    {'9',           irskey_9},
    {VK_NUMPAD0,    irskey_0},
    {VK_NUMPAD1,    irskey_1},
    {VK_NUMPAD2,    irskey_2},
    {VK_NUMPAD3,    irskey_3},
    {VK_NUMPAD4,    irskey_4},
    {VK_NUMPAD5,    irskey_5},
    {VK_NUMPAD6,    irskey_6},
    {VK_NUMPAD7,    irskey_7},
    {VK_NUMPAD8,    irskey_8},
    {VK_NUMPAD9,    irskey_9},
    {VK_DECIMAL,    irskey_point},
    {VK_BACK,       irskey_backspace}
  };
  const irs_u8 key_map_size = sizeof(key_map)/sizeof(key_map_t);

  for (irs_u8 key_map_index = 0; key_map_index < key_map_size;
    key_map_index++) {
    if (key_map[key_map_index].win_key == (*(mxkdb_keystate_t *)keystate)())
    {
      return key_map[key_map_index].irs_key;
    }
  }
  return irskey_none;
}

// Âñïîìîãàòåëüíûé êëàññ äðàéâåðà êëàâèàòóðû Ñ++ Builder
mxkdb_keystate_t::mxkdb_keystate_t():
  f_key(0)
{
}
__fastcall mxkdb_keystate_t::~mxkdb_keystate_t()
{
}
Word mxkdb_keystate_t::operator()()
{
  return f_key;
}
void __fastcall mxkdb_keystate_t::KeyDown(System::TObject* Sender, Word &Key,
  Classes::TShiftState Shift)
{
  f_key = Key;
}
void __fastcall mxkdb_keystate_t::KeyUp(System::TObject* Sender, Word &Key,
  Classes::TShiftState Shift)
{
  f_key = 0;
}
void mxkdb_keystate_t::connect(TMemo *input)
{
  input->OnKeyDown = KeyDown;
  input->OnKeyUp = KeyUp;
}


// Êëàññ äðàéâåðà äèñïëåÿ Ñ++ Builder

// Âðåìÿ èíòåðâàëà ïîâòîðà ïî óìîë÷àíèþ
#define mxdisplay_refresh_time_def TIME_TO_CNT(1, 20)

mxdisplay_drv_builder_t::mxdisplay_drv_builder_t(mxdisp_pos_t a_height,
  mxdisp_pos_t a_width):
  mp_display(IRS_NULL),
  mp_console(IRS_NULL),
  m_height(a_height),
  m_width(a_width),
  m_length(mxdisp_pos_t(m_height*m_width)),
  mp_display_ram(new char[m_length]),
  m_display_ram_changed(irs_true),
  m_refresh_timer(irs::make_cnt_ms(50))
{
}
mxdisplay_drv_builder_t::~mxdisplay_drv_builder_t()
{
  deinit_to_cnt();
  delete []mp_display_ram;
}
mxdisp_pos_t mxdisplay_drv_builder_t::get_height()
{
  return m_height;
}
mxdisp_pos_t mxdisplay_drv_builder_t::get_width()
{
  return m_width;
}
void mxdisplay_drv_builder_t::outtextpos(
  mxdisp_pos_t a_left, mxdisp_pos_t a_top, const char *ap_text)
{
  if ((a_left < m_width) && (a_top < m_height)) {
    m_display_ram_changed = irs_true;
    mxdisp_pos_t text_len = (mxdisp_pos_t)strlen(ap_text);
    if (a_left + text_len > m_width) text_len = mxdisp_pos_t(m_width - a_left);
    memcpy((void *)(mp_display_ram + a_top*m_width + a_left),
      (void *)ap_text, text_len);
  }
}
void mxdisplay_drv_builder_t::tick()
{
  if (m_refresh_timer.check()) {
    if (m_display_ram_changed)
    if (mp_console) {
      m_display_ram_changed = irs_false;
      mp_console->BeginUpdate();
      mp_console->Clear();
      const irs_u32 add_chr_cnt = 2;
      const irs_u32 line_cur_size = m_width + add_chr_cnt + 1;
      char *line_cur = new char [line_cur_size];
      memset((void *)line_cur, '-', line_cur_size - 1);
      line_cur[line_cur_size - 1] = 0;
      mp_console->Add(line_cur);
      for (mxdisp_pos_t line_ind = 0; line_ind < m_height; line_ind++) {
        line_cur[0] = '|';
        memcpy((void *)&line_cur[1], mp_display_ram + line_ind*m_width,
          m_width);
        line_cur[line_cur_size - 2] = '|';
        line_cur[line_cur_size - 1] = 0;
        mp_console->Add(line_cur);
      }
      memset((void *)line_cur, '-', line_cur_size - 1);
      line_cur[line_cur_size - 1] = 0;
      mp_console->Add(line_cur);
      mp_console->EndUpdate();
      delete []line_cur;
    }
  }
}
void mxdisplay_drv_builder_t::connect(TMemo *ap_display)
{
  mp_display = ap_display;
  mp_console = mp_display->Lines;
}
void mxdisplay_drv_builder_t::set_refresh_time(counter_t a_refresh_time)
{
  m_refresh_timer.set(a_refresh_time);
}


//Êëàññ äðàéâåð äëÿ êîíñîëè Windows
irs_win32_console_display_t::irs_win32_console_display_t():
  m_Written(0),
  m_top_displey(0)
{
  m_Coord.X=0;   // êîîðäèíàòû âûâîäà(x,y)
  m_Coord.Y=0;   // êîîðäèíàòû âûâîäà(x,y)
  //ïðîñèì äåñðèïòîð ñòàíäàðòíîãî ââîäà
  m_InpHandle=GetStdHandle(STD_INPUT_HANDLE);
  //ïðîñèì äåñêðèïðòîð ñòàíäàðòíîãî âûâîäà
  m_OutHandle=GetStdHandle(STD_OUTPUT_HANDLE);
  //ñ÷èòûâàåì ïàðàìåòðû áóôåðà
  GetConsoleScreenBufferInfo(m_OutHandle, &m_BufInfo);
  //ùàñ ïîãàñèì êóðñîð
  CONSOLE_CURSOR_INFO lpConsoleCursorInfo;
  GetConsoleCursorInfo(m_OutHandle,&lpConsoleCursorInfo);
  lpConsoleCursorInfo.bVisible=false;   //ãàñèì êóðñîð
  SetConsoleCursorInfo(m_OutHandle,&lpConsoleCursorInfo);
  //m_textbuf=newx char[get_width()];
  //if (SetConsoleCP(1252));
}

mxdisp_pos_t irs_win32_console_display_t::get_height()
{
  return static_cast<mxdisp_pos_t>(m_BufInfo.srWindow.Bottom+1);//.dwSize.Y;
}
mxdisp_pos_t irs_win32_console_display_t::get_width()
{
  return static_cast<mxdisp_pos_t>(m_BufInfo.srWindow.Right+1);//.dwSize.X;
}
void irs_win32_console_display_t::outtextpos(
  mxdisp_pos_t a_left,
  mxdisp_pos_t a_top,
  const char *text)
{
  if((a_left < static_cast<mxdisp_pos_t>(m_BufInfo.srWindow.Right+1)) &&
    (a_top < static_cast<mxdisp_pos_t>(m_BufInfo.srWindow.Bottom+1)))
  {
    irs_u32 width=get_width();
    m_Coord.X=static_cast<short>(a_left);
    m_Coord.Y=static_cast<short>(a_top+m_top_displey);
    irs_u32 lentext=min(strlen(text), static_cast<size_t>(width-a_left));
    irs::auto_arr<wchar_t> unicode_text(new wchar_t[lentext+1]);
    MultiByteToWideChar(
      1251/*UINT CodePage*/,
      MB_PRECOMPOSED /*DWORD dwFlags*/,
      text/*LPCSTR lpMultiByteStr*/,
      lentext/*int cbMultiByte*/,
      unicode_text.get()/*LPWSTR lpWideCharStr*/,
      lentext/*int cchWideChar*/);
    WriteConsoleOutputCharacterW(
      m_OutHandle,              // screen buffer handle
      unicode_text.get(),        // pointer to source string
      lentext,                  // length of string
      m_Coord,                  // first cell to write to
      &m_Written);              // actual number written
  }
}
void irs_win32_console_display_t::tick()
{
}


// Êëàññ äðàéâåð äëÿ âëàâèàòóðû
irs_win32_console_key_drv_t::irs_win32_console_key_drv_t():
  m_flag_event_KeyDown(false),
  m_temporary_irs_key(irskey_none),
  m_Written(0)
{
  //ïðîñèì äåñðèïòîð ñòàíäàðòíîãî ââîäà
  m_InpHandle=GetStdHandle(STD_INPUT_HANDLE);
  m_fdwMode = ENABLE_WINDOW_INPUT;
  SetConsoleMode(m_InpHandle, m_fdwMode);
}
irskey_t irs_win32_console_key_drv_t::operator()()
{

  typedef struct _key_map_t {
    irs_i16 win_key;
    irskey_t irs_key;
  } key_map_t;
  key_map_t key_map[] = {
    {VK_RETURN,     irskey_enter},
    {VK_SEPARATOR,  irskey_enter},
    {VK_ESCAPE,     irskey_escape},
    {VK_UP,         irskey_up},
    {VK_DOWN,       irskey_down},
    {'0',           irskey_0},
    {'1',           irskey_1},
    {'2',           irskey_2},
    {'3',           irskey_3},
    {'4',           irskey_4},
    {'5',           irskey_5},
    {'6',           irskey_6},
    {'7',           irskey_7},
    {'8',           irskey_8},
    {'9',           irskey_9},
    {VK_NUMPAD0,    irskey_0},
    {VK_NUMPAD1,    irskey_1},
    {VK_NUMPAD2,    irskey_2},
    {VK_NUMPAD3,    irskey_3},
    {VK_NUMPAD4,    irskey_4},
    {VK_NUMPAD5,    irskey_5},
    {VK_NUMPAD6,    irskey_6},
    {VK_NUMPAD7,    irskey_7},
    {VK_NUMPAD8,    irskey_8},
    {VK_NUMPAD9,    irskey_9},
    {VK_DECIMAL,    irskey_point},
    {VK_BACK,       irskey_backspace}
  };
  const irs_u8 key_map_size = sizeof(key_map)/sizeof(key_map_t);

  GetNumberOfConsoleInputEvents(m_InpHandle,&m_cNumRead);
  if(m_cNumRead>0)
  {
    ReadConsoleInput(m_InpHandle, m_irInBuf, m_len_buf, &m_cNumRead);
    for(irs_u32 i=0;i< m_cNumRead; i++)
      if(m_irInBuf[i].EventType==KEY_EVENT)    //åñëè ñîáûòèå ñ êëàâèàòóðû
      {
        //åñëè ñîáûòèå ïðè íàæàòèè êëàâèøè è êëàâèøà íå áûëà íàæàòà
        if(m_irInBuf[i].Event.KeyEvent.bKeyDown==true
          && m_flag_event_KeyDown==false)
        {
          //ñìîòðèì, ñîâïàäàåò ëè ñ îäíîé èç êíîïîê
          for (irs_u8 key_map_index = 0; key_map_index < key_map_size;
          key_map_index++)
          {
            //åñëè ñîâïàäàåò, îòïðàâëÿåì åå
            if(key_map[key_map_index].win_key==
              m_irInBuf[i].Event.KeyEvent.wVirtualKeyCode)  //âèðòóàëüíûé êîä
            {
              m_flag_event_KeyDown=true;
              m_temporary_irs_key=key_map[key_map_index].irs_key;
              return m_temporary_irs_key;
            }
          }
        }
        //åñëè ïðîèçîøëî îòïóñêàíèå êíîïêè, è êëàâèøà áûëà íàæàòà
        else  if(m_irInBuf[i].Event.KeyEvent.bKeyDown==false &&
          m_flag_event_KeyDown==true)
        {
          m_flag_event_KeyDown=false;
          m_temporary_irs_key=irskey_none;
          return m_temporary_irs_key;
        }
        else  if(m_flag_event_KeyDown==true)  //åñëè âñå åùå êëàâèøà íàæàòà
        {
          return m_temporary_irs_key;
        }
      }
  }
  else  if(m_flag_event_KeyDown==true)        //åñëè âñå åùå êëàâèøà íàæàòà
  {
    return m_temporary_irs_key;
  }

  m_temporary_irs_key=irskey_none;
  return m_temporary_irs_key;
}

// Êîíôèãóðàöèÿ êîíñîëè äëÿ C++ Builder
irs::conio_cfg_t& irs::arch_conio_cfg::def()
{
  static irs_win32_console_key_drv_t key_drv;
  static irs_win32_console_display_t display;
  static conio_cfg_t conio_cfg_i(key_drv, display);
  return conio_cfg_i;
}
// Êîíôèãóðàöèÿ êîíñîëè äëÿ Memo C++ Builder
irs::conio_cfg_t& irs::arch_conio_cfg::memo(TMemo *ap_memo,
  mxdisp_pos_t a_height, mxdisp_pos_t a_width)
{
  static mxkey_drv_builder_t key_drv;
  static mxdisplay_drv_builder_t display(a_height, a_width);
  static conio_cfg_t conio_cfg_i(key_drv, display);
  key_drv.connect(ap_memo);
  display.connect(ap_memo);
  return conio_cfg_i;
}

#if !defined(IRSSTRM_NEW_MEMOBUF) || !defined(IRS_FULL_STDCPPLIB_SUPPORT)
// Áóôåð ñòàíäàðòíûõ ïîòîêîâ äëÿ Memo
irs::memobuf::memobuf(const memobuf& a_buf):
  m_outbuf_size(a_buf.m_outbuf_size),
  m_outbuf(new char[m_outbuf_size + 1]),
  mp_memo(a_buf.mp_memo)
{
  memset(m_outbuf.get(), 0, m_outbuf_size);
  setp(m_outbuf.get(), m_outbuf.get() + m_outbuf_size);
}
irs::memobuf::memobuf(TMemo *ap_memo, int a_outbuf_size):
  m_outbuf_size(a_outbuf_size),
  m_outbuf(new char[m_outbuf_size + 1]),
  mp_memo(ap_memo)
{
  memset(m_outbuf.get(), 0, m_outbuf_size);
  setp(m_outbuf.get(), m_outbuf.get() + m_outbuf_size);
}
irs::memobuf::~memobuf()
{
}
void irs::memobuf::connect(TMemo *ap_memo)
{
  mp_memo = ap_memo;
}
int irs::memobuf::overflow(int c)
{
  if (!mp_memo) return 0;

  int len_s = pptr() - pbase();
  TStrings *Console = mp_memo->Lines;
  if (len_s > 0) {
    *pptr() = 0;

    char *message = pbase();
    char *message_line = message;
    for (int i_msg_ch = 0; i_msg_ch < len_s; i_msg_ch++) {
      if ('\n' == message[i_msg_ch]) {
        message[i_msg_ch] = 0;
        if (Console->Count <= 0) Console->Add("");
        String ConsoleLine = Console->Strings[Console->Count - 1];
        ConsoleLine += String(message_line);
        Console->Strings[Console->Count - 1] = ConsoleLine;
        Console->Add("");
        message_line = &message[i_msg_ch + 1];
      }
    }
    if (message[len_s - 1] != '\n') {
      if (Console->Count <= 0) Console->Add("");
      String ConsoleLine = Console->Strings[Console->Count - 1];
      ConsoleLine += String(message_line);
      Console->Strings[Console->Count - 1] = ConsoleLine;
    }
  }
  if (c != EOF)
  {
    if (c != '\n') {
      if (Console->Count <= 0) Console->Add("");
      String ConsoleLine = Console->Strings[Console->Count - 1];
      char char_str[] = " ";
      char_str[0] = static_cast<char>(c);
      ConsoleLine += char_str;
      Console->Strings[Console->Count - 1] = ConsoleLine;
    } else {
      Console->Add("");
    }
  }
  setp(m_outbuf.get(), m_outbuf.get() + m_outbuf_size);
  return 0;
}
int irs::memobuf::sync()
{
  return overflow();
}
#endif //!defined(IRSSTRM_NEW_MEMOBUF) || !defined(IRS_FULL_STDCPPLIB_SUPPORT)

#endif //__BORLANDC__

#if defined(__WATCOMC__)
// Ïðåîáðàçîâàíèå ÷èñëà double â ñòðîêó â %g ôîðìàòå
irs_u8 *irs_gcvt(double value, int ndigits, irs_u8 *buffer)
{
  return (irs_u8 *)gcvt(value, ndigits, (char *)buffer);
}

//Êëàññ äðàéâåð äëÿ êîíñîëè Windows
irs_win32_console_display_t::irs_win32_console_display_t():
  m_Written(0),
  m_top_displey(0)
{
  m_Coord.X=0;   // êîîðäèíàòû âûâîäà(x,y)
  m_Coord.Y=0;   // êîîðäèíàòû âûâîäà(x,y)
  //ïðîñèì äåñðèïòîð ñòàíäàðòíîãî ââîäà
  m_InpHandle=GetStdHandle(STD_INPUT_HANDLE);
  //ïðîñèì äåñêðèïðòîð ñòàíäàðòíîãî âûâîäà
  m_OutHandle=GetStdHandle(STD_OUTPUT_HANDLE);
  //ñ÷èòûâàåì ïàðàìåòðû áóôåðà
  GetConsoleScreenBufferInfo(m_OutHandle, &m_BufInfo);
  //ùàñ ïîãàñèì êóðñîð
  CONSOLE_CURSOR_INFO lpConsoleCursorInfo;
  GetConsoleCursorInfo(m_OutHandle,&lpConsoleCursorInfo);
  lpConsoleCursorInfo.bVisible=false;   //ãàñèì êóðñîð
  SetConsoleCursorInfo(m_OutHandle,&lpConsoleCursorInfo);
  m_textbuf=new char[get_width()];
}

mxdisp_pos_t irs_win32_console_display_t::get_height()
{
  return static_cast<mxdisp_pos_t>(m_BufInfo.srWindow.Bottom+1);//.dwSize.Y;
}
mxdisp_pos_t irs_win32_console_display_t::get_width()
{
  return static_cast<mxdisp_pos_t>(m_BufInfo.srWindow.Right+1);//.dwSize.X;
}
void irs_win32_console_display_t::outtextpos(
  mxdisp_pos_t a_left,
  mxdisp_pos_t a_top,
  const char *text)
{
  if((a_left < m_BufInfo.srWindow.Right+1) &&
    (a_top < m_BufInfo.srWindow.Bottom+1))
  {
    irs_u32 width=get_width();
    m_Coord.X = static_cast<SHORT>(a_left);
    m_Coord.Y = static_cast<SHORT>(a_top+m_top_displey);
    irs_u32 lentext=min(strlen(text), static_cast<unsigned int>(width-a_left));
    WriteConsoleOutputCharacter(
      m_OutHandle,              // screen buffer handle
      text,                     // pointer to source string
      lentext,                  // length of string
      m_Coord,                  // first cell to write to
      &m_Written);              // actual number written
  }
}

void irs_win32_console_display_t::tick()
{
}

// Êëàññ äðàéâåð äëÿ âëàâèàòóðû
irs_win32_console_key_drv_t::irs_win32_console_key_drv_t():
  m_flag_event_KeyDown(irs_false),
  m_temporary_irs_key(irskey_none),
  m_Written(0)
{
  //ïðîñèì äåñðèïòîð ñòàíäàðòíîãî ââîäà
  m_InpHandle=GetStdHandle(STD_INPUT_HANDLE);
  m_fdwMode = ENABLE_WINDOW_INPUT;
  SetConsoleMode(m_InpHandle, m_fdwMode);
}
irskey_t irs_win32_console_key_drv_t::operator()()
{

  typedef struct _key_map_t {
    irs_i16 win_key;
    irskey_t irs_key;
  } key_map_t;
  key_map_t key_map[] = {
    {VK_RETURN,     irskey_enter},
    {VK_SEPARATOR,  irskey_enter},
    {VK_ESCAPE,     irskey_escape},
    {VK_UP,         irskey_up},
    {VK_DOWN,       irskey_down},
    {'0',           irskey_0},
    {'1',           irskey_1},
    {'2',           irskey_2},
    {'3',           irskey_3},
    {'4',           irskey_4},
    {'5',           irskey_5},
    {'6',           irskey_6},
    {'7',           irskey_7},
    {'8',           irskey_8},
    {'9',           irskey_9},
    {VK_NUMPAD0,    irskey_0},
    {VK_NUMPAD1,    irskey_1},
    {VK_NUMPAD2,    irskey_2},
    {VK_NUMPAD3,    irskey_3},
    {VK_NUMPAD4,    irskey_4},
    {VK_NUMPAD5,    irskey_5},
    {VK_NUMPAD6,    irskey_6},
    {VK_NUMPAD7,    irskey_7},
    {VK_NUMPAD8,    irskey_8},
    {VK_NUMPAD9,    irskey_9},
    {VK_DECIMAL,    irskey_point},
    {VK_BACK,       irskey_backspace}
  };
  const irs_u8 key_map_size = sizeof(key_map)/sizeof(key_map_t);

  GetNumberOfConsoleInputEvents(m_InpHandle,&m_cNumRead);
  if(m_cNumRead>0)
  {
    //irInBuf-buffer to read into
    //128-size of read buffer
    //cNumRead-number of records read
    ReadConsoleInput(m_InpHandle, m_irInBuf, m_len_buf, &m_cNumRead);
    for(irs_u32 i=0;i< m_cNumRead; i++)
      if(m_irInBuf[i].EventType==KEY_EVENT)    //åñëè ñîáûòèå ñ êëàâèàòóðû
      {
        //åñëè ñîáûòèå ïðè íàæàòèè êëàâèøè è êëàâèøà íå áûëà íàæàòà
        if(m_irInBuf[i].Event.KeyEvent.bKeyDown==irs_true
          && m_flag_event_KeyDown==irs_false)
        {
          //ñìîòðèì, ñîâïàäàåò ëè ñ îäíîé èç êíîïîê
          for (irs_u8 key_map_index = 0; key_map_index < key_map_size;
          key_map_index++)
          {
            //åñëè ñîâïàäàåò, îòïðàâëÿåì åå
            if(key_map[key_map_index].win_key==
              m_irInBuf[i].Event.KeyEvent.wVirtualKeyCode)  //âèðòóàëüíûé êîä
            {
              m_flag_event_KeyDown=irs_true;
              m_temporary_irs_key=key_map[key_map_index].irs_key;
              return m_temporary_irs_key;
            }
          }
        }
        //åñëè ïðîèçîøëî îòïóñêàíèå êíîïêè, è êëàâèøà áûëà íàæàòà
        else  if(m_irInBuf[i].Event.KeyEvent.bKeyDown==irs_false &&
          m_flag_event_KeyDown==irs_true)
        {
          m_flag_event_KeyDown=irs_false;
          m_temporary_irs_key=irskey_none;
          return m_temporary_irs_key;
        }
        else  if(m_flag_event_KeyDown==irs_true)  //åñëè âñå åùå êëàâèøà íàæàòà
        {
          return m_temporary_irs_key;
        }
      }
  }
  else  if(m_flag_event_KeyDown==irs_true)        //åñëè âñå åùå êëàâèøà íàæàòà
  {
    return m_temporary_irs_key;
  }

  m_temporary_irs_key=irskey_none;
  return m_temporary_irs_key;
}
#endif //defined(__WATCOMC__)

// Çàêîìåíòàðåíî, ò. ê. Watcom âûäàåò çäåñü exception ïðè êîìïèëÿöèè
#ifdef NOP
#ifdef __WATCOMC__
// Êîíôèãóðàöèÿ êîíñîëè äëÿ Watcom C++
irs::conio_cfg_t& irs::arch_conio_cfg::def()
{
  static irs_win32_console_key_drv_t key_drv;
  static irs_win32_console_display_t display;
  static conio_cfg_t conio_cfg_i(key_drv, display);
  return conio_cfg_i;
}
#endif //__WATCOMC__
#endif //NOP