/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2000 by Ilfak Guilfanov.
 *      ALL RIGHTS RESERVED.
 *                              E-mail: ig@datarescue.com
 *
 */

#include "../idaldr.h"
#include "geos2.h"
#include "common.cpp"
#include <struct.hpp>
#include <enum.hpp>
#include <typeinf.hpp>

//--------------------------------------------------------------------------
static int create_seg(
        ea_t base,
        ea_t start,
        ea_t end,
        const char *name,
        const char *sclass)
{
  if ( start != BADADDR && end < start )
    return 0;
  segment_t s;
  s.sel     = setup_selector(base);
  s.start_ea = start;
  s.end_ea   = end;
  s.align   = saRelByte;
  s.comb    = (sclass != NULL && strcmp(sclass,"STACK") == 0) ? scStack : scPub;
  s.bitness = 0;
  return add_segm_ex(&s, name, sclass, ADDSEG_NOSREG|ADDSEG_SPARSE);
}

//--------------------------------------------------------------------------
static int idaapi accept_file(
        qstring *fileformatname,
        qstring *processor,
        linput_t *li,
        const char *)
{
  union
  {
    GEOSheader h1;
    GEOS2header h2;
  } h;
  qlseek(li, 0);
  if ( qlread(li, &h, sizeof(h)) != sizeof(h) )
    return 0;

  qoff64_t apppos;
  int version;
  if ( h.h1.ID == GEOS_ID && h.h1.fclass == 0 )
  {
    apppos = 0xC8;
    version = 1;
  }
  else if ( h.h2.ID == GEOS2_ID && h.h2.fclass == 1 )
  {
    apppos = sizeof(GEOS2header);
    version = 2;
  }
  else
  {
    return 0;
  }

  GEOSappheader ah;
  qlseek(li, apppos, SEEK_SET);
  if ( qlread(li, &ah, sizeof(ah)) != sizeof(ah) )
    return 0;
  const char *stype;
  switch ( ah.type )
  {
    case 1:  stype = "Application"; break;
    case 2:  stype = "Library";     break;
    case 3:  stype = "Driver";      break;
    default: stype = "Unknown type";break;
  }
  fileformatname->sprnt("GEOS%d %s", version, stype);
  *processor = "metapc";
  return 1;
}

//--------------------------------------------------------------------------
static ea_t get_segea(const GEOSappheader &ah, const uint32 *segea, uint16 s)
{
  if ( s >= ah.numseg )
  {
    ask_for_feedback("Bad segment number %d", s);
    return BADADDR;
  }
  return segea[s] == uint32(BADADDR) ? BADADDR : segea[s];
}

//--------------------------------------------------------------------------
static netnode get_node(const GEOSappheader &ah, const netnode *modnode, uint16 libn)
{
  if ( libn >= ah.numlib )
  {
    ask_for_feedback("Bad library number %d", libn);
    return BADNODE;
  }
  return modnode[libn];
}

//--------------------------------------------------------------------------
static tid_t get_class_struct_flags_enum()
{
  static const char enum_name[] = "ClassFlags";
  enum_t id = get_enum(enum_name);
  if ( id != BADNODE )
    return id;
  id = add_enum(-1, enum_name, hex_flag());
  set_enum_bf(id, true);
  add_enum_member(id, "CLASSF_HAS_DEFAULT",     (1<<0), (1<<0));
  add_enum_member(id, "CLASSF_MASTER_CLASS",    (1<<1), (1<<1));
  add_enum_member(id, "CLASSF_VARIANT_CLASS",   (1<<2), (1<<2));
  add_enum_member(id, "CLASSF_DISCARD_ON_SAVE", (1<<3), (1<<3));
  add_enum_member(id, "CLASSF_NEVER_SAVED",     (1<<4), (1<<4));
  add_enum_member(id, "CLASSF_HAS_RELOC",       (1<<5), (1<<5));
  add_enum_member(id, "CLASSF_C_HANDLERS",      (1<<6), (1<<6));
  return id;
}

//--------------------------------------------------------------------------
#if 0
static void declare_parameter_types(ea_t ea, int count)
{
  static const char class_name[] = "CMethodDef";
  struc_t *sptr = get_struc(get_struc_id(class_name));
  if ( sptr == NULL )
  {
    sptr = get_struc(add_struc(-1, class_name));
    if ( sptr == NULL )
      return;
    add_struc_member(sptr, "methodParameterDef", -1, word_flag(), NULL, 2);
    add_struc_member(sptr, "handlerTypeDef",     -1, byte_flag(), NULL, 1);
  }
  size_t size = get_struc_size(sptr);
  create_struct(ea, size*count, sptr->id);
}
#endif

//--------------------------------------------------------------------------
static void declare_class(ea_t ea, const char *entryname)
{
  static const char class_name[] = "ClassStruct";
  struc_t *sptr = get_struc(get_struc_id(class_name));
  if ( sptr == NULL )
  {
    sptr = get_struc(add_struc(BADADDR, class_name));
    if ( sptr == NULL )
      return;
    opinfo_t mt;
    mt.ri.flags = REF_OFF32;
    mt.ri.target = BADADDR;
    mt.ri.base = 0;
    mt.ri.tdelta = 0;
    add_struc_member(sptr, "superClass",   BADADDR, off_flag()|dword_flag(), &mt, 4);
    add_struc_member(sptr, "masterOffset", BADADDR, word_flag(), NULL, 2);
    add_struc_member(sptr, "methodCount",  BADADDR, dec_flag()|word_flag(), NULL, 2);
    add_struc_member(sptr, "instanceSize", BADADDR, dec_flag()|word_flag(), NULL, 2);
    add_struc_member(sptr, "vdRelocTable", BADADDR, word_flag(), NULL, 2);
    add_struc_member(sptr, "relocTable",   BADADDR, word_flag(), NULL, 2);
    mt.ec.tid = get_class_struct_flags_enum();
    mt.ec.serial = 0;
    add_struc_member(sptr, "flags",        BADADDR, enum_flag()|byte_flag(), &mt, 1);
    add_struc_member(sptr, "masterMethods",BADADDR, byte_flag(), NULL, 1);
  }
  asize_t size = get_struc_size(sptr);
  create_struct(ea, size, sptr->id);

  segment_t *s = getseg(ea);
  if ( s == NULL )
    return;
  int count = get_word(ea+6);
//  bool c_handlers = get_byte(ea+14) & (1<<6);
  ea += size;
  if ( ea+2*count >= s->end_ea )
    return;
  ea_t messages = ea;
  create_word(ea, count*2);
  op_dec(ea, 0);
  ea += 2*count;
  if ( ea+4*count > s->end_ea )
    return;
  create_dword(ea, count*4);
  op_plain_offset(ea, 0, 0);
  for ( int i=0; i < count; i++ )
  {
    ea_t idx = ea + 4*i;
    ea_t pea = to_ea(get_word(idx+2), get_word(idx));
    auto_make_proc(pea);
    char name[MAXSTR];
    qsnprintf(name, sizeof(name), "%s_%u", entryname, get_word(messages+2*i));
    add_entry(pea, pea, name, true, AEF_IDBENC);
  }
// commented out because it doesn't work properly
// see geoplan.geo, entry number 1 for example
//  if ( c_handlers )
//    declare_parameter_types(ea+count*4, count);
}

//--------------------------------------------------------------------------
static void describe_app(const GEOSappheader &ah, const uint32 *segea)
{
  char buf[MAXSTR];
  char *end = buf + sizeof(buf);
  char *ptr = buf + qsnprintf(buf, sizeof(buf), "Pgm attrs   :");
  if ( ah.attr & GA_PROCESS                   ) APPEND(ptr, end, " GA_PROCESS");
  if ( ah.attr & GA_LIBRARY                   ) APPEND(ptr, end, " GA_LIBRARY");
  if ( ah.attr & GA_DRIVER                    ) APPEND(ptr, end, " GA_DRIVER");
  if ( ah.attr & GA_KEEP_FILE_OPEN            ) APPEND(ptr, end, " GA_KEEP_FILE_OPEN");
  if ( ah.attr & GA_SYSTEM                    ) APPEND(ptr, end, " GA_SYSTEM");
  if ( ah.attr & GA_MULTI_LAUNCHABLE          ) APPEND(ptr, end, " GA_MULTI_LAUNCHABLE");
  if ( ah.attr & GA_APPLICATION               ) APPEND(ptr, end, " GA_APPLICATION");
  if ( ah.attr & GA_DRIVER_INITIALIZED        ) APPEND(ptr, end, " GA_DRIVER_INITIALIZED");
  if ( ah.attr & GA_LIBRARY_INITIALIZED       ) APPEND(ptr, end, " GA_LIBRARY_INITIALIZED");
  if ( ah.attr & GA_GEODE_INITIALIZED         ) APPEND(ptr, end, " GA_GEODE_INITIALIZED");
  if ( ah.attr & GA_USES_COPROC               ) APPEND(ptr, end, " GA_USES_COPROC");
  if ( ah.attr & GA_REQUIRES_COPROC           ) APPEND(ptr, end, " GA_REQUIRES_COPROC");
  if ( ah.attr & GA_HAS_GENERAL_CONSUMER_MODE ) APPEND(ptr, end, " GA_HAS_GENERAL_CONSUMER_MODE");
  if ( ah.attr & GA_ENTRY_POINTS_IN_C         ) APPEND(ptr, end, " GA_ENTRY_POINTS_IN_C");
  add_pgm_cmt("%s", buf);

  if ( ah.attr & GA_PROCESS )
  {
    ea_t entry = get_segea(ah, segea, ah.classptr_seg) + ah.classptr_ofs;
    set_name(entry, "ProcessClass", SN_NOCHECK|SN_NOWARN);
    declare_class(entry, "ProcessClass");
//    inf_set_start_cs(get_segea(ah,segea,ah.classptr_seg) >> 4);
//    inf_set_start_ip (ah.classptr_ofs);
         entry = get_segea(ah, segea, ah.tokenres_seg) + ah.tokenres_item;
    set_name(entry, "ApplicationObject");
    add_pgm_cmt("ProcessClass: %d:%04X", ah.classptr_seg, ah.classptr_ofs);
    add_pgm_cmt("App object  : %d:%04X", ah.tokenres_seg, ah.tokenres_item);
  }
  if ( ah.attr & GA_LIBRARY && ah.initseg != 0 )
  {
    inf_set_start_cs(get_segea(ah, segea, ah.initseg) >> 4);
    inf_set_start_ip(ah.initofs);
    add_pgm_cmt("Library init: %d:%04X", ah.initseg, ah.initofs);
  }
  if ( ah.attr & GA_DRIVER && ah.startseg != 0 )
  {
    ea_t entry = get_segea(ah, segea, ah.startseg) + ah.startofs;
    set_name(entry, "DriverTable");
//    inf_set_start_cs(get_segea(ah, segea, ah.startseg) >> 4);
//    inf_set_start_ip (ah.startofs);
    add_pgm_cmt("Driver Table: %d:%04X", ah.startseg, ah.startofs);
//      add_jmplist(ah.startseg,ah.startofs,4,4);
                                  // Add entry point as "jmplist"
  }
}

//--------------------------------------------------------------------------
static void bad_lib_reloc(int i, uint16 off)
{
  ask_for_feedback("Strange library relocation at %d:%04X", i, off);
}

//--------------------------------------------------------------------------
static void create_fixup(ea_t ea, fixup_data_t &fd, ea_t target)
{
  segment_t *s = getseg(target);
  if ( s != NULL )
  {
    fd.sel = s->sel;
    fd.off = target - get_segm_base(s);
  }
  else
  {
    fd.sel = sel_t(target >> 4);
    fd.off = target & 0xF;
  }
  fd.displacement = 0;
  fd.set(ea);
  if ( fd.get_type() == FIXUP_PTR16 )
  {
    put_word(ea, fd.off);
    put_word(ea+2, fd.sel);
  }
  else if ( fd.get_type() == FIXUP_OFF16 )
  {
    put_word(ea, fd.off);
  }
  else              // SEG16
  {
    put_word(ea, fd.sel);
  }
}

//--------------------------------------------------------------------------
static void apply_relocations(
        linput_t *li,
        const GEOSappheader &ah,
        const netnode *modnode,
        const uint16 *seglen,
        const int32 *segpos,
        const uint16 *segfix,
        const uint32 *segea)
{
  // apply relocation information
  for ( int i=0; i < ah.numseg; i++ )
  {
    if ( segfix[i] == 0 )
      continue;
    GEOSfixup *fix = (GEOSfixup *)qalloc(segfix[i]);
    if ( fix == NULL )
      nomem("fix");
    qlseek(li, segpos[i]+((seglen[i]+0xF)&~0xF));
    lread(li, fix, segfix[i]);
    int n = segfix[i]/sizeof(GEOSfixup);
    sel_t oldsel = BADSEL;
    sel_t oldoff = BADSEL;
    ea_t oldea = BADADDR;
    for ( int j=0; j < n; j++ )
    {
      ea_t ea = get_segea(ah, segea, (uint16)i) + fix[j].ofs;
      int ftype = fix[j].type & 0xF0;
      if ( ftype != 0x10 && ftype != 0x20 )
        ask_for_feedback("Unknown fixup type %02X", ftype);
      netnode libnode = BADNODE;
      if ( ftype == 0x10 )
        libnode = get_node(ah, modnode, fix[j].type>>8);
      uint16 w1 = get_word(ea);
      ea_t target = BADADDR;
      fixup_data_t fd(FIXUP_SEG16);
      switch ( fix[j].type & 0x0F )
      {
        case 0x0: case 0x4:
          fd.set_type_and_flags(FIXUP_PTR16);
          if ( ftype == 0x20 )  // program
            target = get_segea(ah, segea, w1) + get_word(ea+2);
          else                  // library
          {
            target = node2ea(libnode.altval(w1+1));
            fd.set_extdef();
          }
          break;
        case 0x1:               // off
          if ( ftype == 0x20 )  // program
          {
            ask_for_feedback("Program offset relocation encountered");
            continue;
          }
          oldoff = w1;
          if ( oldsel != BADSEL )
          {
LIB_PTR:
            target = node2ea(libnode.altval(oldoff+1));
            if ( oldea == ea+2 )
            {
              fd.set_type_and_flags(FIXUP_PTR16, FIXUPF_EXTDEF);
            }
            else
            {
              fd.set_type_and_flags(FIXUP_SEG16, FIXUPF_EXTDEF);
              create_fixup(oldea, fd, target);
              fd.set_type_and_flags(FIXUP_OFF16, FIXUPF_EXTDEF);
            }
            oldsel = BADSEL;
            oldoff = BADSEL;
            oldea  = BADSEL;
            break;
          }
          oldea = ea;
          continue;
        case 0x2: case 0x3:
          if ( ftype == 0x20 )  // program
            target = get_segea(ah, segea, w1);
          else
          {
            oldsel = w1;
            if ( oldoff != BADSEL )
            {
              ea_t tmp = ea;
              ea = oldea;
              oldea = tmp;
              goto LIB_PTR;
            }
            oldea = ea;
            continue;
          }
          break;
        default:
          ask_for_feedback("Unknown relocation type %02X", fix[j].type);
      }
      create_fixup(ea, fd, target);
    }
    qfree(fix);
  }
}

//--------------------------------------------------------------------------
static void find_imports_in_relocations(
        linput_t *li,
        const GEOSappheader &ah,
        const netnode *modnode,
        const uint16 *seglen,
        const int32 *segpos,
        const uint16 *segfix)
{
  for ( int i=0; i < ah.numseg; i++ )
  {
    if ( segfix[i] == 0 )
      continue;
    GEOSfixup *fix = (GEOSfixup *)qalloc(segfix[i]);
    if ( fix == NULL )
      nomem("fix");
    qlseek(li, segpos[i]+((seglen[i]+0xF)&~0xF));
    lread(li, fix, segfix[i]);
// i don't understand why this should be done
// besides, if we uncomment it, the library fixups are
// not handled properly
//    if ( fix[0].ofs == 0 )
//      fix[0].ofs = 0xFFFF;
    int num = segfix[i]/sizeof(GEOSfixup);
    sel_t oldseg = BADSEL;
    sel_t oldoff = BADSEL;
    sel_t oldlib = BADSEL;
    for ( int j=0; j < num; j++ )
    {
      if ( fix[j].ofs == 0xFFFF )
        continue;
      if ( (fix[j].type & 0xF0) != 0x10 )
        continue;     // only library!
      int libn = fix[j].type>>8;
      if ( libn >= ah.numlib )
      {
        ask_for_feedback("Illegal library number in relocations");
        continue;
      }
      netnode n = modnode[libn];
      uint16 ofs = fix[j].ofs;
      qlseek(li, segpos[i]+ofs);
      uint16 w1;
      lread(li, &w1, sizeof(w1));
      switch ( fix[j].type & 0x0F )
      {
        case 0x0: case 0x4:                     // exported entry
          n.altset(w1+1, 1);
          oldseg = BADSEL;
          oldoff = BADSEL;
          oldlib = BADSEL;
          break;
        case 0x1:                               // off
          if ( oldseg != BADSEL )
          {
            if ( libn != oldlib || oldseg != w1 )
              bad_lib_reloc(i, ofs);
            n.altset(w1+1, 1);
            oldseg = BADSEL;
            break;
          }
          oldoff = w1;
          oldlib = libn;
          break;
        case 0x2: case 0x3:                     // seg #
          if ( oldoff != BADSEL )
          {
            if ( libn != oldlib || oldoff != w1 )
              bad_lib_reloc(i, ofs);
            n.altset(w1+1, 1);
            oldoff = BADSEL;
            break;
          }
          oldseg = w1;
          oldlib = libn;
          break;
        default:
          ask_for_feedback("Unknown relocation type %02X", fix[j].type);
      }
    }
    if ( oldseg != BADSEL && oldoff != BADSEL )
      ask_for_feedback("Some library relocations are strange");
    qfree(fix);
  }
}

//--------------------------------------------------------------------------
static void create_extern_segments(
        const GEOSappheader &ah,
        const GEOSliblist *lib,
        const netnode *modnode)
{
  inf_set_specsegs(inf_is_64bit() ? 8 : 4);
  for ( int i=0; i < ah.numlib; i++ )
  {
    char libname[8+1];
    qstrncpy(libname, lib[i].name, sizeof(libname));
    trim(libname);
    netnode n = modnode[i];
    uval_t x;
    int nimps = 0;
    for ( x=n.altfirst(); x != BADNODE; x=n.altnext(x) )
      nimps++;
    if ( nimps == 0 )
      continue;

    ea_t ea = free_chunk(inf_get_max_ea(), nimps*4, -15);
    ea_t end = ea + nimps*4;
    create_seg(ea>>4, ea, end, libname, "XTRN");
    for ( x=n.altfirst(); x != BADNODE; x=n.altnext(x),ea+=4 )
    {
      char buf[MAXSTR];
      qsnprintf(buf, sizeof(buf), "%s_%u", libname, uint16(x)-1);
      put_dword(ea, 0xCB);
      create_insn(ea);
      force_name(ea, buf, SN_IDBENC);
      nodeidx_t ndx = ea2node(ea);
      n.altset(x, ndx);
    }
    import_module(libname, NULL /*windir*/, n, NULL, "geos");
  }
}

//--------------------------------------------------------------------------
static void create_exports(
        const GEOSappheader &ah,
        const GEOSexplist *explist,
        const uint32 *segea,
        const char *modname)
{
  int i;
  netnode n;
  n.create();
  for ( i=0; i < ah.numexp; i++ )
  {
    ea_t ea = get_segea(ah, segea, explist[i].seg) + explist[i].ofs;
    add_extra_cmt(ea, true, "Exported entry %d", i);
    nodeidx_t ndx = ea2node(ea);
    n.altset(i+1, ndx);
  }
  import_module(modname, NULL /*windir*/, n, NULL, "geos");
  for ( i=0; i < ah.numexp; i++ )
  {
    ea_t ea = get_segea(ah, segea, explist[i].seg) + explist[i].ofs;
    qstring name;
    if ( get_name(&name, ea, GN_NOT_DUMMY) <= 0 )
      name.sprnt("%s_%d", modname, i);
    bool makecode = segtype(ea) == SEG_CODE;
    add_entry(i, ea, name.begin(), makecode, AEF_IDBENC);
    if ( !makecode )
      declare_class(ea, name.begin());
  }
}

//--------------------------------------------------------------------------
void load_application(linput_t *li, int32 fpos, int32 fdelta)
{
  GEOSappheader ah;

  qlseek(li, fpos);
  lread(li, &ah, sizeof(ah));

  // build our name
  char modname[sizeof(ah.name)+1];
  qstrncpy(modname, ah.name, sizeof(ah.name));
  trim(modname);

  // read in library information
  GEOSliblist *lib = NULL;
  netnode *modnode = NULL;
  validate_array_count(li, &ah.numlib, sizeof(GEOSliblist), "The library count");
  if ( ah.numlib != 0 )
  {
    lib = qalloc_array<GEOSliblist>(ah.numlib);
    if ( lib == NULL )
      nomem("libs");
    lread(li, lib, ah.numlib*sizeof(GEOSliblist));
    modnode = qalloc_array<netnode>(ah.numlib);
    if ( modnode == NULL )
      nomem("libnode");
    for ( int i=0; i < ah.numlib; i++ )
    {
      char libname[8+1];
      qstrncpy(libname, lib[i].name, sizeof(libname));
      trim(libname);
      char buf[20];
      qsnprintf(buf, sizeof(buf), "$lib %.8s", libname);
      modnode[i].create(buf);
    }
  }

  // read in export information
  GEOSexplist *explist = NULL;
  validate_array_count(li, &ah.numexp, sizeof(GEOSexplist), "Number of exports");
  if ( ah.numexp != 0 )
  {
    explist = qalloc_array<GEOSexplist>(ah.numexp);
    if ( explist == NULL )
      nomem("exp");
    lread(li, explist, ah.numexp*sizeof(GEOSexplist));
  }

  // read in segment information
  void *segd = NULL;
  uint16 *seglen = NULL;
  int32 *segpos = NULL;
  uint16 *segfix = NULL;
  uint16 *segflg;
  sel_t ds_sel = BADSEL;
  uint32 *segea = NULL;
  validate_array_count(li, &ah.numseg, 14, "Number of segments");
  if ( ah.numseg != 0 )
  {
    if ( !is_mul_ok<ushort>(ah.numseg, 14) )
NOMEM:
      nomem("geos_segments");
    segd = qalloc(ah.numseg*14);
    if ( segd == NULL )
      goto NOMEM;
    lread(li, segd, ah.numseg*10);
    seglen = (uint16 *)segd;
    segpos = (int32  *)(seglen + ah.numseg);
    segfix = (uint16 *)(segpos + ah.numseg);
    segflg = (uint16 *)(segfix + ah.numseg);
    segea  = (uint32 *)(segflg + ah.numseg);
    ea_t ea = to_ea(inf_get_baseaddr(), 0);
    for ( int i=0; i < ah.numseg; i++ )
    {
      uint16 f = segflg[i];
      segpos[i] += fdelta;

      segea[i] = uint32(BADADDR);
      if ( seglen[i] == 0 )
        continue;
      size_t bss_size = 0;
      // if this is the data segment, increase its size by stacksize.
      // i'm not aware of a reliable way to find it, so use heuristics
      bool found_data_segment = false;
      if ( ds_sel == BADSEL
        && (f & (HF_READ_ONLY|HF_SHARABLE|HF_CODE)) == 0
        && (f & HF_FIXED) != 0 )
      {
        found_data_segment = true;
        bss_size = ah.stacksize;
      }
      ea = free_chunk(ea, bss_size + seglen[i], -15);
      ea_t endea = ea + seglen[i] + bss_size;
      if ( (f & HF_ZERO_INIT) == 0 )
        file2base(li, segpos[i], ea, endea - bss_size, FILEREG_PATCHABLE);
      create_seg(ea>>4, ea, endea, NULL, (f & HF_CODE) ? "CODE" : "DATA");

      if ( found_data_segment )
        ds_sel = find_selector(ea>>4);

      char buf[MAXSTR];
      char *end = buf + sizeof(buf);
      char *ptr = buf + qsnprintf(buf, sizeof(buf), "Segm attrs  :");
      if ( f & HF_ZERO_INIT       ) APPEND(ptr, end, " ZEROINIT");
      if ( f & HF_LOCK            ) APPEND(ptr, end, " LOCK");
      if ( f & HF_NO_ERR          ) APPEND(ptr, end, " NO_ERR");
      if ( f & HF_UI              ) APPEND(ptr, end, " UI");
      if ( f & HF_READ_ONLY       ) APPEND(ptr, end, " RONLY");
      if ( f & HF_OBJECT_RESOURCE ) APPEND(ptr, end, " OBJ_RES");
      if ( f & HF_CODE            ) APPEND(ptr, end, " CODE");
      if ( f & HF_CONFORMING      ) APPEND(ptr, end, " CONFORMING");
      if ( f & HF_FIXED           ) APPEND(ptr, end, " FIXED");
      if ( f & HF_SHARABLE        ) APPEND(ptr, end, " SHARABLE");
      if ( f & HF_DISCARDABLE     ) APPEND(ptr, end, " DISCARDABLE");
      if ( f & HF_SWAPABLE        ) APPEND(ptr, end, " SWAPABLE");
      if ( f & HF_LMEM            ) APPEND(ptr, end, " LMEM");
      if ( f & HF_DEBUG           ) APPEND(ptr, end, " DEBUG");
      if ( f & HF_DISCARDED       ) APPEND(ptr, end, " DISCARDED");
      if ( f & HF_SWAPPED         ) APPEND(ptr, end, " SWAPPED");
      add_extra_cmt(ea, true, "%s", buf);

      segea[i] = (uint32)ea;
      ea = endea;
    }
  }

  find_imports_in_relocations(li, ah, modnode, seglen, segpos, segfix);
  create_extern_segments(ah, lib, modnode);
  set_default_dataseg(ds_sel);

  if ( !qgetenv("IDA_NORELOC") )
    apply_relocations(li, ah, modnode, seglen, segpos, segfix, segea);

  create_exports(ah, explist, segea, modname);

  describe_app(ah, segea);
  qfree(lib);
  qfree(modnode);
  qfree(explist);
  qfree(segd);
}

//--------------------------------------------------------------------------
static void show_geos1(GEOSheader &h)
{
  char buf[MAXSTR];
  add_pgm_cmt("Name        : %s", geos2ibm(buf, h.name, sizeof(h.name)));
  add_pgm_cmt("Token       : %s", token2str(buf, sizeof(buf), h.token));
  add_pgm_cmt("Creator     : %s", token2str(buf, sizeof(buf), h.appl));
  add_pgm_cmt("Release     : %u.%u.%u.%u",
                          h.release.versmaj,
                          h.release.versmin,
                          h.release.revmaj,
                          h.release.revmin);
  add_pgm_cmt("Protocol    : %u.%03u",
                          h.protocol.vers,
                          h.protocol.rev);
  add_pgm_cmt("Flags       : %04X", h.flags);
  add_pgm_cmt("User info   : %s", geos2ibm(buf, h.info, sizeof(h.info)));
  add_pgm_cmt("Copyright   : %s", geos2ibm(buf, h._copyright, sizeof(h._copyright)));
}

//--------------------------------------------------------------------------
static void show_geos2(GEOS2header &h)
{
  char buf[MAXSTR];
  add_pgm_cmt("Name        : %s", geos2ibm(buf, h.name, sizeof(h.name)));
  add_pgm_cmt("Token       : %s", token2str(buf, sizeof(buf), h.token));
  add_pgm_cmt("Creator     : %s", token2str(buf, sizeof(buf), h.appl));
  add_pgm_cmt("Release     : %u.%u.%u.%u",
                          h.release.versmaj,
                          h.release.versmin,
                          h.release.revmaj,
                          h.release.revmin);
  add_pgm_cmt("Protocol    : %u.%03u",
                          h.protocol.vers,
                          h.protocol.rev);
  add_pgm_cmt("Flags       : %04X", h.flags);
  add_pgm_cmt("Password    : %.*s", int(sizeof(h.password)), h.password);
  add_pgm_cmt("User info   : %s", geos2ibm(buf, h.info, sizeof(h.info)));
  add_pgm_cmt("Copyright   : %s", geos2ibm(buf, h._copyright, sizeof(h._copyright)));
}

//--------------------------------------------------------------------------
void idaapi load_file(linput_t *li, uint16 /*neflag*/, const char * /*fileformatname*/)
{
  set_processor_type("metapc", SETPROC_LOADER);

  union
  {
    GEOSheader h1;
    GEOS2header h2;
  } h;
  qlseek(li, 0);
  lread(li, &h, sizeof(h));

  int32 apppos;
  int32 fdelta;
  if ( h.h1.ID == GEOS_ID )
  {
    apppos = 0xC8;
    fdelta = 0;
  }
  else
  {
    apppos = sizeof(GEOS2header);
    fdelta = apppos;
  }

  load_application(li, apppos, fdelta);

  create_filename_cmt();
  if ( h.h1.ID == GEOS_ID )
    show_geos1(h.h1);
  else
    show_geos2(h.h2);

  inf_set_cc_cm(inf_get_cc_cm() | C_PC_LARGE);
  add_til("geos", ADDTIL_DEFAULT);
}

//--------------------------------------------------------------------------
loader_t LDSC =
{
  IDP_INTERFACE_VERSION,
  0,                            // loader flags
//
//      check input file format. if recognized, then return 1
//      and fill 'fileformatname'.
//      otherwise return 0
//
  accept_file,
//
//      load file into the database.
//
  load_file,
//
//      create output file from the database.
//      this function may be absent.
//
  NULL,
//      take care of a moved segment (fix up relocations, for example)
  NULL,
  NULL,
};