procedure _tostr_proc(var s:string);
begin
  Replace(s, '\', '\\');
  Replace(s, '"', '\"');
  Replace(s, #10, '\n');
end;

const
  lng_count = 1;
  lngs:array[0..lng_count-1] of TLangRec = (
     (entry:'EntryPoint';     name:'cpp';  str_del_o: '"'; str_del_c: '"'; op_del: ' + '; var_mask:'%n%i'; tostr_proc:_tostr_proc)
  );

var
  UT_QTime:integer;
  UT_QPixmap:integer;
  UT_QIcon:integer;
  UT_QWidget:integer;
  UT_QByteArray:integer;
  UT_QIODevice:integer;
  UT_QDateTime:integer;
  UT_QDatabase:integer;
  UT_QSqlQuery:integer;

function _getType(dt:PScData):integer;
begin
  Result := dt.getType;
  if(Result = data_code)or(Result = data_array)then
    Result := dt.getSubType;
end;

function _toCode(data:PScData; toType:byte):PScData;
var ok:boolean;
begin
   Result := data;
   ok := false;
   case toType of
     data_int:
      case _getType(data) of
       data_null:
        begin
          Result := MakeData('0', true);
          ok := true;
        end;
       data_str:
        begin
          Result := MakeData('(', true);
          Result.AddValue(data, true);
          Result.AddValue(MakeData(').toInt()', true), true);
          ok := true;
        end;
       data_real:
        begin
          Result := MakeData('(int)(', true);
          Result.AddValue(data, true);
          Result.AddValue(MakeData(')', true), true);
          ok := true;
        end;
      end;
     data_str:
      case _getType(data) of
       data_null:
        begin
          Result := MakeData('');
          ok := true;
        end;
       data_int:
        begin
          Result := MakeData('QString::number (', true);
          Result.AddValue(data, true);
          Result.AddValue(MakeData(')', true), true);
          ok := true;
        end;
       data_real:
        begin
          Result := MakeData('QString::number(', true);
          Result.AddValue(data, true);
          Result.AddValue(MakeData(')', true), true);
          ok := true;
        end;
      end;
     data_real:
      case _getType(data) of
       data_null:
        begin
          Result := MakeData('0.0', true);
          ok := true;
        end;
       data_str:
        begin
          Result := MakeData('(', true);
          Result.AddValue(data, true);
          Result.AddValue(MakeData(').toDouble()', true), true);
          ok := true;
        end;
      end
   end;
  if ok then Result.SetSubType(toType);
end;

type
  lng_indexer = (
      lng_begin,
      lng_end,
      lng_blk_priv_var,
      lng_blk_loc_var,
      lng_project_name,
      lng_get_type,
      lng_decl_var,
      lng_get_type_name,
      lng_to_color,
      lng_begin_unit,
      lng_end_unit,
      lng_make_unit,
      lng_switch_to_loc,
      lng_switch_to_parent,
      lng_begin_func,
      lng_end_func,
      lng_get_linked_obj,
      lng_include,
//      lng_get_linked_obj_id,
      lng_last);

function _cpp_type(b:byte):string;
var i:integer;
begin
  case b of
   data_int: result := 'int';
   data_str: result := 'QString';
   data_real: result := 'float';
   else
     for i := 0 to LngTypeCounter - data_object - 1 do
      if integer(LngUserTypes.Objects[i]) = b then
       begin
         Result := LngUserTypes[i];
         exit;
       end;
     Result := '';
  end;
end;


const
  BCOUNT = 11;
  var_names:array [0..BCOUNT + 1] of string = ('blk_body', 'blk_inc', 'blk_binc', 'blk_priv', 'blk_slot', 'blk_pub', 'blk_mtd', 'blk_init', 'blk_loc', 'blk_sig', 'blk_close', 'blk_destr', 'cur_class');

procedure _begin_unit(parser:TParser; use_lst:boolean; const args,parent:string; iswidget:boolean);
var
    dt:PScData;
    cl,id,s:string;
    i:byte;
begin
   parser.VarList.AddArg('__use_lst__').SetValue(use_lst);
   parser.VarList.AddArg('__args__').SetValue(args);
   parser.VarList.AddArg('__parent__').SetValue(parent);
   parser.VarList.AddArg('__iswidget__').SetValue(iswidget);
   parser.fdata._vars_.AddArg('__oldb__').SetValue(parser.codeb.CurBlockName);

   dt := GVarList.find('cur_class');
   parser.VarList.AddArg('_cur_class')^ := dt^;
   id := parser.cgt.elGetCodeName(parser.el);
   cl := string(parser.cgt.elGetClassName(parser.el)) + id;
   dt.SetValue(cl, data_code);
   parser.codeb.select(GVarList.find('blk_inc').toStr);
   parser.Print('#include "hi' + cl + '.h"');
   parser.PrintLine;
   for i := 0 to BCOUNT do
    begin
      dt := GVarList.find(var_names[i]);
      parser.VarList.AddArg('_' + var_names[i]).SetValue(dt.toStr);
      s := 'unit_' + var_names[i] + '_' + id;
      parser.codeb.reg(s);
      dt.SetValue(s, data_code);
    end;

   dt := GVarList.find('sources');
   dt.SetValue(dt.ToStr() + ' hi' + cl + '.cpp');
   dt := GVarList.find('headers');
   dt.SetValue(dt.ToStr() + ' hi' + cl + '.h');
end;

procedure _end_unit(parser:TParser);
var
    i:byte;
    dt:PScData;
begin
   for i := 0 to BCOUNT + 1 do
    begin
      dt := parser.VarList.find('_' + var_names[i]);
      GVarList.find(var_names[i])^ := dt^;
    end;
   parser.codeb.select(parser.fdata._vars_.find('__oldb__').toStr());
end;

procedure _make_unit(parser:TParser; e:id_element);
var lst,src:TStringList;
    s,id,cc,c_args:string;
    i:byte;
    use_lst,iswidget:boolean;
    args,parent:string;
    old_e:id_element;
    //h1,h2:TMD5Digest;
begin
   old_e := parser.el;
   parser.setElement(e);
   use_lst := parser.VarList.find('__use_lst__').ToBool();
   args := parser.VarList.find('__args__').ToStr();
   parent := parser.VarList.find('__parent__').ToStr();
   iswidget := parser.VarList.find('__iswidget__').ToBool();
   parser.setElement(old_e);

   src := TStringList.Create;

   id := parser.cgt.elGetCodeName(e);
   cc := string(parser.cgt.elGetClassName(e)) + id;
   lst := TStringList.Create;
   lst.Add('#ifndef _' + UpperCase(cc));
   lst.Add('#define _' + UpperCase(cc));
   lst.Add('#include <QApplication>');
   lst.Add('#include <QWidget>');
   lst.Add('#include <QtGui>');
   parser.codeb.select('unit_blk_inc_' + id);
   lst.Add(parser.codeb.AsCode);
   lst.Add('');
   lst.Add('class ' + cc + ' : public ' + parent + ' {');
   lst.Add('  Q_OBJECT');
   lst.Add('public:');
   if iswidget then
     c_args := cc + '(QWidget *_parent'
   else  c_args := cc + '(QObject *_parent';
   if use_lst then
    begin
     lst.Add('  QList<' + cc + '*> *list;');
     c_args := c_args + ', QList<' + cc + '*> *_list';
    end;
   if args <> '' then
     c_args := c_args + ', ' + args;
   lst.Add('  ' + c_args + ');');
   lst.Add('  ~' + cc + '();');
   parser.codeb.select('unit_blk_pub_' + id);
   lst.Add(parser.codeb.AsCode);
   lst.Add('public slots:');
   parser.codeb.select('unit_blk_slot_' + id);
   lst.Add(parser.codeb.AsCode);
   lst.Add('signals:');
   parser.codeb.select('unit_blk_sig_' + id);
   lst.Add(parser.codeb.AsCode);
   lst.Add('private:');
   parser.codeb.select('unit_blk_priv_' + id);
   lst.Add(parser.codeb.AsCode);
   lst.Add('};');
   lst.Add('');
   lst.Add('#endif');
   s := parser.cgt.ReadCodeDir(parser.el) + 'hi' + cc + '.h';
   if fileexists(s) then
      begin
        src.LoadFromFile(s);
        if not compareTwoLists(lst, src) then
          begin
            lst.savetofile(s);
            writeln('save unit: ', s, 'l1:', lst.count, ' l2:', src.count);
          end
        else writeln('already saved: ', s);
      end
   else
     begin
       lst.savetofile(s);
       writeln('save unit: ', s);
     end;
   parser.cgt.resAddFile(PChar(s));
   lst.clear;

   lst.Add('#include "hi' + cc + '.h"');
   parser.codeb.select('unit_blk_binc_' + id);
   lst.Add(parser.codeb.AsCode);
   lst.Add('');
   lst.Add(cc + '::' + c_args + '):' + parent + '(_parent) {');
   if use_lst then
     lst.Add('  _list->append(this); '#13#10'  list = _list;');
   parser.codeb.select('unit_blk_loc_' + id);
   lst.Add(parser.codeb.AsCode);
   parser.codeb.select('unit_blk_body_' + id);
   lst.Add(parser.codeb.AsCode);
   parser.codeb.select('unit_blk_init_' + id);
   lst.Add(parser.codeb.AsCode);
   lst.Add('}');
   lst.Add('');
   lst.Add(cc + '::~' + cc + '() {');
   parser.codeb.select('unit_blk_close_' + id);
   lst.Add(parser.codeb.AsCode);
   parser.codeb.select('unit_blk_destr_' + id);
   lst.Add(parser.codeb.AsCode);
   lst.Add('}');
   lst.Add('');
   parser.codeb.select('unit_blk_mtd_' + id);
   lst.Add(parser.codeb.AsCode);
   lst.Add('');

   s := parser.cgt.ReadCodeDir(parser.el) + 'hi' + cc + '.cpp';
   if fileexists(s) then
    begin
     src.LoadFromFile(s);
     if not compareTwoLists(lst, src) then
       lst.savetofile(s);
    end
   else  lst.savetofile(s);
   parser.cgt.resAddFile(PChar(s));

   lst.Free;
   src.Free;

   for i := 0 to BCOUNT do
     parser.codeb.delete('unit_' + var_names[i] + '_' + id);
end;

procedure _lng_switch_to(parser:TParser; dir:integer);
var i:byte;
    dt,v:PScData;
    id,cl:string;
begin
   id := parser.cgt.elGetCodeName(parser.el);
   cl := string(parser.cgt.elGetClassName(parser.el)) + id;
   for i := 0 to BCOUNT+1 do
    begin
      dt := GVarList.find(var_names[i]);
      parser.fdata._vars_.AddArg('_loc_' + var_names[i])^ := dt^;
      if dir = 0 then
        if i = BCOUNT+1 then
          dt.SetValue(cl, data_code)
        else dt.SetValue('unit_' + var_names[i] + '_' + id, data_code)
      else
       begin
        v := parser.VarList.find('_' + var_names[i]);
        if v <> nil then dt^ := v^ else parser.debug('not found _' + var_names[i]);
       end;
    end;
end;

procedure _lng_switch_return(parser:TParser);
var i:byte;
    dt:PScData;
begin
   for i := 0 to BCOUNT+1 do
    begin
      dt := GVarList.find(var_names[i]);
      dt^ := parser.fdata._vars_.find('_loc_' + var_names[i])^;
    end;
end;

procedure _lng_begin_func(parser:TParser; const name:string);
var oldb, tmp, old_loc, loc_dt, fname:PScData;
    s:string;
begin
  oldb := parser.VarList.find('old_block');
  tmp := parser.VarList.find('tmp_block');
  old_loc := parser.VarList.find('loc_block');
  fname := parser.VarList.find('_fname_');

  if oldb = nil then
    oldb := parser.VarList.addArg('old_block');
  if tmp = nil then
    tmp := parser.VarList.addArg('tmp_block');
  if old_loc = nil then
    old_loc := parser.VarList.addArg('loc_block');
  if fname = nil then
    fname := parser.VarList.addArg('_fname_');

  fname.setValue(name);

  loc_dt := GVarList.find('blk_loc');
  old_loc.setValue(loc_dt.toStr());
  loc_dt.SetValue(parser.codeb.reggen(), data_code);

  s := parser.codeb.reggen();
  tmp.SetValue(s);

  oldb.setValue(parser.codeb.select(s));
end;

procedure _lng_end_func(parser:TParser; const scope:string);
var
    loc_dt:PScData;
    name,b:string;
begin
  loc_dt := GVarList.find('blk_loc');

  name := parser.VarList.find('_fname_').toStr();
  parser.codeb.select(scope);
  parser.Print('void ' + name + ';');
  parser.PrintLine();

  parser.codeb.select(GVarList.find('blk_mtd').toStr());
  parser.Print('void ' + GVarList.find('cur_class').toStr() + '::' + name + ' {');
  parser.PrintLine();
  parser.codeb.level := parser.codeb.level + 1;
    parser.codeb.CopyTo(loc_dt.toStr(), parser.codeb.CurBlockName);
    parser.codeb.delete(loc_dt.toStr());
    loc_dt.setValue(parser.VarList.find('loc_block').toStr(), data_code);
    b := parser.VarList.find('tmp_block').toStr();
    parser.codeb.CopyTo(b, parser.codeb.CurBlockName);
    parser.codeb.delete(b);
  parser.codeb.level := parser.codeb.level - 1;
  parser.Print('}');
  parser.PrintLine();
  parser.codeb.select(parser.VarList.find('old_block').toStr());
end;

function ExtractFileNameWithoutExt(const AFilename: string): string;
var
  StartPos: Integer;
  ExtPos: Integer;
begin
  StartPos:=length(AFilename)+1;
  while (StartPos>1)
  and (AFilename[StartPos-1]<>PathDelim)
  {$IFDEF Windows}and (AFilename[StartPos-1]<>':'){$ENDIF}
  do
    dec(StartPos);
  ExtPos:=length(AFilename);
  while (ExtPos>=StartPos) and (AFilename[ExtPos]<>'.') do
    dec(ExtPos);
  if (ExtPos<StartPos) then ExtPos:=length(AFilename)+1;
  Result:=copy(AFilename,StartPos,ExtPos-StartPos);
end;

function lng_proc(parser:TParser; obj:pointer; index:integer; args:TArgs):TScData;
var dt,d:PScData;
    old,s:string;
    buf:array[0..256] of char;
    t,b,r:byte;
    e,te:id_element;
    sdk1,sdk2:id_sdk;
begin
  Result.SetValue('');
  case lng_indexer(index) of
   lng_begin:
    begin
      parser.codeb.level := parser.codeb.level + 1;
      parser.Print('{');
      parser.PrintLine;
    end;
   lng_end:
    begin
      parser.Print('}');
      parser.PrintLine;
      parser.codeb.level := parser.codeb.level - 1;
    end;
   lng_blk_priv_var:
    begin
      dt := GVarList.find('blk_priv');
      if dt = nil then
        parser.debug('BLK_PRIV - not found')
      else
       begin
         old := parser.codeb.select(dt.toStr());
         parser.Print(args.Values[1].toStr);
         parser.Print(' ' + args.Values[0].toStr + ';');
         parser.PrintLine;
         parser.codeb.select(old);
       end;
    end;
   lng_blk_loc_var:
    begin
      dt := GVarList.find('blk_loc');
      if dt = nil then
        parser.debug('BLK_LOC - not found')
      else
       begin
         old := parser.codeb.select(dt.toStr());
         parser.Print(args.Values[1].toStr);
         parser.Print(' ' + args.Values[0].toStr + ';');
         parser.PrintLine;
         parser.codeb.select(old);
       end;
    end;
   lng_project_name:
    begin
      id_element(pointer(@buf[0])^) := parser.el;
      parser.cgt.GetParam(PARAM_PROJECT_NAME, @buf[0]);
      Result.SetValue(ExtractFileNameWithoutExt(buf));
    end;
   lng_get_type: Result.Setvalue(_getType(args.Values[0]));
   lng_get_type_name: Result.Setvalue(_cpp_type(args.Values[0].toInt), data_code);
   lng_decl_var:
    begin
      d := Parser.regGVar(args.Values[0].toStr());
      t := args.Values[1].toInt();
      if(t <> data_int)and(t <> data_real)then
        t := data_str;
      d.SetSubType(t);
      s := d.toCode();
      if args.Values[3].toInt() = 0 then
       begin
         dt := GVarList.find('blk_priv');
         if dt = nil then
          begin
            parser.debug('BLK_PRIV - not found');
            exit;
          end
         else
          begin
            old := parser.codeb.select(dt.toStr());
            parser.Print(_cpp_type(d.GetSubType()) + ' ' + s + ';');
            parser.PrintLine;
            parser.codeb.select(old);
          end;
         dt := GVarList.find('blk_body');
         if dt = nil then
          begin
            parser.debug('BLK_BODY - not found');
            exit;
          end
         else
          begin
            old := parser.codeb.select(dt.toStr());
            parser.Print(s + ' = ' + args.Values[2].toCode() + ';');
            parser.PrintLine;
            parser.codeb.select(old);
          end;
       end
      else
       begin
         dt := GVarList.find('blk_loc');
         if dt = nil then
          begin
            parser.debug('BLK_LOC - not found');
            exit;
          end
         else
          begin
            old := parser.codeb.select(dt.toStr());
            parser.Print(_cpp_type(d.GetSubType()) + ' ' + s + ' = ' + args.Values[2].toCode() + ';');
            parser.PrintLine;
            parser.codeb.select(old);
          end;
       end;
    end;
   lng_to_color:
    begin
      r := args.Values[0].toInt() and $0000FF;
      t := (args.Values[0].toInt() and $00FF00) shr 8;
      b := (args.Values[0].toInt() and $FF0000) shr 16;
      Result.SetValue('QColor(' + inttostr(r) + ',' + inttostr(t) + ',' + inttostr(b) + ',' + args.Values[1].toCode() + ')', data_code);
    end;
   lng_begin_unit: _begin_unit(parser, args.Values[0].toBool(), args.Values[1].toStr(), args.Values[2].toStr(), args.Values[3].toBool());
   lng_end_unit: _end_unit(parser);
   lng_make_unit: _make_unit(parser, id_element(args.Values[0].toInt()));
   lng_switch_to_loc: _lng_switch_to(parser, args.Values[0].toInt());
   lng_switch_to_parent: _lng_switch_return(parser);
   lng_begin_func: _lng_begin_func(parser, args.Values[0].toStr());
   lng_end_func: _lng_end_func(parser, args.Values[0].toStr());
   lng_get_linked_obj:
    begin
       e := parser.cgt.propGetLinkedElement(parser.el, PChar(args.Values[0].toStr()));
       if e = nil then
         Result.Setvalue('', data_code)
       else
        begin
          if parser.cgt.elGetData(e) = nil then
            call_init(parser.cgt, e, 'init');
          sdk1 := parser.cgt^.elGetParent(e);
          te := parser.el;
          sdk2 := parser.cgt^.elGetParent(te);
          s := 'this';
          while sdk1 <> sdk2 do
            begin
              te := parser.cgt^.sdkGetParent(sdk2);
              sdk2 := parser.cgt^.elGetParent(te);
              s := s + '->parent()';
            end;
          te := parser.cgt^.sdkGetElement(sdk2, 0);
          //writeln();
          Result.Setvalue('((hi' + parser.cgt.elGetClassName(te) + parser.cgt.elGetCodeName(te) + '*)' + s + ')->' + lowercase(parser.cgt.elGetClassName(e)) + parser.cgt.elGetCodeName(e), data_code);
        end;
    end;
   lng_include:
    begin
       old := parser.codeb.select(GVarList.find('blk_inc').toStr);
       s := '#include <' + args.Values[0].toStr() + '>';
       if pos(s, parser.codeb.AsCode) = 0 then
        begin
         parser.print(s);
         parser.PrintLine;
        end;
       parser.codeb.select(old);
    end;
//   lng_get_linked_obj_id:
//       Result.Setvalue(parser.cgt.propGetLinkedElement(parser.el, PChar(args.Values[0].toStr())));
  end;
end;

procedure _readCustomProperty(Result:PScData; e:id_element; cgt:PCodeGenTools; prop:id_prop);
begin
//  if(Result.value.data_type = data_str)or(Result.value.data_type = data_list) then
//     _tostr_proc(Result.value.sdata);
end;

procedure fill_lng_object(var methods:TAObjMethod; var count:integer);
begin
  UT_QTime := RegisterUserType('QTime');
  UT_QPixmap := RegisterUserType('QPixmap');
  UT_QIcon := RegisterUserType('QIcon');
  UT_QWidget := RegisterUserType('QWidget');
  UT_QByteArray := RegisterUserType('QByteArray');
  UT_QIODevice := RegisterUserType('QIODevice');
  UT_QDateTime := RegisterUserType('QDateTime');
  UT_QDatabase := RegisterUserType('QDatabase');
  UT_QSqlQuery := RegisterUserType('QSqlQuery');

  readCustomProperty := _readCustomProperty;

  count := integer(lng_last);
  setlength(methods, count);
  methods[integer(lng_begin)] := MakeMethod('begin',     0, '');
  methods[integer(lng_end)] := MakeMethod('end',     0, '');
  methods[integer(lng_blk_priv_var)] := MakeMethod('decl_priv_var',     2, 'name, type');
  methods[integer(lng_blk_loc_var)] := MakeMethod('decl_loc_var',     2, 'name, type');
  methods[integer(lng_project_name)] := MakeMethod('project_name', 0, '');
  methods[integer(lng_get_type)] := MakeMethod('get_type',     1, 'expression');
  methods[integer(lng_decl_var)] := MakeMethod('decl_var',     4, 'var, type, default, scope');
  methods[integer(lng_get_type_name)] := MakeMethod('get_type_name',    1, 'type');
  methods[integer(lng_to_color)] := MakeMethod('to_color',    2, 'color, alpha');
  methods[integer(lng_begin_unit)] := MakeMethod('begin_unit',    4, 'use_list, args, parent, iswidget');
  methods[integer(lng_end_unit)] := MakeMethod('end_unit',    0, '');
  methods[integer(lng_make_unit)] := MakeMethod('make_unit',    1, 'id_element');
  methods[integer(lng_switch_to_loc)] := MakeMethod('switch_to',    1, 'direction');
  methods[integer(lng_switch_to_parent)] := MakeMethod('switch_return',    0, '');
  methods[integer(lng_begin_func)] := MakeMethod('begin_func',    1, 'name');
  methods[integer(lng_end_func)] := MakeMethod('end_func',    1, 'scope');
  methods[integer(lng_get_linked_obj)] := MakeMethod('get_linked_obj',  1, 'propName');
  methods[integer(lng_include)] := MakeMethod('include',  1, 'unitName');
//  methods[integer(lng_get_linked_obj_id)] := MakeMethod('get_linked_obj_id',  1, 'propName');
end;