urasm: fixup table writer

[urasm.git] / src / urasm.c

// URASM Z80 assembler
// coded by Ketmar // Vamprile Avalon
// GPLv3 or later
//
#include <ctype.h>
#include <getopt.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include "liburasm/liburasm.h"

#include "ursna48.c"


#define VERSION_HI  0
#define VERSION_MID 1
#define VERSION_LO  0


#define MAYBE_UNUSED __attribute__((unused))

///////////////////////////////////////////////////////////////////////////////
// global variables
//
static char *sysIncludeDir = NULL;

#define MAX_LINE_SIZE  16384
static char curLine[MAX_LINE_SIZE]; /* current processing line; can be freely modified */


///////////////////////////////////////////////////////////////////////////////
// init dirs
//
static void initInclideDir (void) {
  const char *id = getenv("URASM_INCLUDE_DIR");
  if (id && id[0]) {
    sysIncludeDir = strdup(id);
  } else {
    char myDir[4096];
    memset(myDir, 0, sizeof(myDir));
    if (readlink("/proc/self/exe", myDir, sizeof(myDir)-1) < 0) strcpy(myDir, ".");
    else {
      char *p = (char *)strrchr(myDir, '/');
      if (!p) strcpy(myDir, "."); else *p = '\0';
    }
    strcat(myDir, "/libs");
    sysIncludeDir = strdup(myDir);
  }
  while (sysIncludeDir[0] && sysIncludeDir[strlen(sysIncludeDir)-1] == '/') sysIncludeDir[strlen(sysIncludeDir)-1] = '\0';
  if (!sysIncludeDir[0]) strcpy(sysIncludeDir, ".");
}


///////////////////////////////////////////////////////////////////////////////
// string utilities
//
/* trim trailing spaces and comments */
static void normalizeStr (char *s) {
  char *p, inQ = 0;
  //
  // now skip all shit
  for (p = s; *p; ++p) {
    if (inQ) {
      // inside the string
      if (*p == '\\') {
        switch (*(++p)) {
          case 'x': case 'X': // hex code
            ++p; // skip 'x'
            for (int f = 0; f < 2; ++f, ++p) if (!isxdigit(*p)) break;
            --p; // last digit will be skiped by 'for'
            break;
          case '0': // octal code
            for (int f = 0; f < 4; ++f, ++p) if (!isdigit(*p) || *p > '7') break;
            --p; // last digit will be skiped by 'for'
            break;
          case '1' ... '9': // decimal code
            for (int f = 0; f < 3; ++f, ++p) if (!isdigit(*p)) break;
            --p; // last digit will be skiped by 'for'
            break;
          default: ; // other escapes, do nothing
        }
      } else {
        if (*p == inQ) inQ = 0;
      }
      continue;
    }
    // outside the string
    switch (*p) {
      case '"': case '\'': // string catched
        inQ = *p;
        break;
      case ';': // end of line, comment follows
        *p-- = '\0'; // strip it and quit
        break;
      case ':': // reduce colons
        while (p > s && isspace(p[-1])) --p;
        *p = ':';
        //fprintf(stderr, ":[%s]\n", p);
        if (p[1] && (p[1] == ':' || isspace(p[1]))) {
          char *e, *t;
          //
          for (e = p+2; *e && (*e == ':' || isspace(*e)); ++e) ;
          t = p+1;
          while ((*t++ = *e++)) ;
          //fprintf(stderr, "::[%s]\n", p);
        }
        break;
      default: ; // do nothing
    }
  }
  // trim right
  for (p = s+strlen(s)-1; p >= s && (isspace(*p) || *p == ':'); --p) ;
  p[1] = '\0';
}


/* returns NULL or pointer to args */
/* skips spaces after command if any */
static char *strIsCommand (const char *command, char *str) {
  for (int cnt = 1; cnt > 0; --cnt) {
    while (*str && isspace(*str)) ++str; // skip spaces
    for (; *command && *str; ++command, ++str) {
      if (toupper(*command) != toupper(*str)) return NULL; // alas
    }
    if (*command) return NULL; // alas
    if (*str && isalnum(*str)) return NULL; // alas
    while (*str && isspace(*str)) ++str; // skip spaces
    if (*str && *str == ':') break; // try again if we have a colon
    return str; // found
  }
  return NULL;
}


/* don't free() result */
/* skips trailing spaces */
static char *parseStr (char **str, char endQ, int *lenp) {
  static char buf[MAX_LINE_SIZE];
  int len = 0, n, f, base;
  char *a = *str;
  //
  int xDigit (char ch, int base) {
    if (ch < '0') return -1;
    if (base <= 10) {
      if (ch >= '0'+base) return -1;
      return ch-'0';
    }
    ch = toupper(ch);
    if (ch <= '9') return ch-'0';
    if (ch < 'A' || ch > 'A'+base-10) return -1;
    ch -= 'A'-10;
    return (ch < base ? ch : -1);
  }
  //
  memset(buf, 0, sizeof(buf));
  if (lenp) *lenp = 0;
  for (; *a; ++a) {
    if (*a == '\\') {
      if (!a[1]) break;
      switch (*(++a)) {
        case 'a': buf[len++] = '\a'; break;
        case 'b': buf[len++] = '\b'; break;
        case 'e': buf[len++] = '\x1b'; break;
        case 'f': buf[len++] = '\f'; break;
        case 'n': buf[len++] = '\n'; break;
        case 'r': buf[len++] = '\r'; break;
        case 't': buf[len++] = '\t'; break;
        case 'v': buf[len++] = '\v'; break;
        case 'z': buf[len++] = '\0'; break;
        case 'x': case 'X': // hex
          ++a; // skip 'x'
          base = 16; f = 2;
donum:    for (n = 0; f > 0; --f) {
            char ch = xDigit(*a++, base);
            //
            if (ch < 0) { --a; break; }
            n *= base;
            n += ch;
          }
          buf[len++] = n;
          --a; // return to the last digit, 'for' will skip it
          break;
        case '0': // octal
          base = 8; f = 4;
          goto donum;
        case '1' ... '9': // decimal
          base = 10; f = 3;
          goto donum;
        default: buf[len++] = a[0]; break; // others
      }
    } else {
      if (*a == endQ) { ++a; break; }
      buf[len++] = *a;
    }
  }
  while (*a && isspace(*a)) ++a; // skip trailing spaces
  *str = a;
  buf[len] = '\0';
  if (lenp) *lenp = len;
  return buf;
}


///////////////////////////////////////////////////////////////////////////////
// source file stack, reader, etc
//
typedef struct SourceLine {
  struct SourceLine *next;
  char *line;
  char *fname;
  int lineNo;
} SourceLine;

static SourceLine *asmText = NULL;
static SourceLine *asmTextLast = NULL;
static SourceLine *curSrcLine = NULL;


typedef struct MacroDef {
  struct MacroDef *next;
  char *name;
  SourceLine *lines;
  int argc;
  char *argdef[32]; // default values
  char *argnames[32]; // argument names
} MacroDef;

typedef struct {
  MacroDef *mac;
  char *argvals[32]; // argument values
} CurMacroDef;

static MacroDef *maclist = NULL;
static CurMacroDef *curmacro = NULL; // !NULL if we are not inserting macro
static int curmacronum;


static void asmTextClear (void) {
  while (asmText) {
    SourceLine *l = asmText;
    //
    asmText = asmText->next;
    free(l->line);
    free(l->fname);
    free(l);
  }
  asmTextLast = curSrcLine = NULL;
}


static void normIncName (char *dest, const char *fn, int system) {
  struct stat st;
  //
  if (system) sprintf(dest, "%s/%s", sysIncludeDir, fn); else sprintf(dest, "%s", fn);
  if (stat(dest, &st)) return;
  if (S_ISDIR(st.st_mode)) strcat(dest, "/zzmain.zas");
}


static int asmTextLoad (const char *fname) {
  FILE *fl;
  int lineNo = 0;
  char *args;
  SourceLine *s;
  static int includeCount = 0;
  //
  if (!(fl = fopen(fname, "r"))) {
    fprintf(stderr, "ERROR: can't open file: %s\n", fname);
    return -1;
  }
  printf("loading: %s\n", fname);
  // read file
  while (fgets(curLine, sizeof(curLine)-1, fl)) {
    ++lineNo;
    curLine[sizeof(curLine)-1] = '\0';
    normalizeStr(curLine);
    //fprintf(stderr, "*[%s]\n", curLine);
    if (!curLine[0]) continue; // don't store empty lines
    // find specials, if any
    if (isspace(curLine[0])) {
      if ((args = strIsCommand("INCLUDE", curLine)) != NULL) {
        // process 'INCLUDE'
        int system = 0;
        char qCh = 0, *fn;
        //
        if (!args[0]) {
          fclose(fl);
          fprintf(stderr, "ERROR: file %s, line %d: invalid INCLUDE!\n", fname, lineNo);
          return -1;
        }
        if (args[0] == '"' || args[0] == '\'') qCh = *args++;
        else if (args[0] == '<') { qCh = '>'; ++args; system = 1; }
        //
        fn = parseStr(&args, qCh, NULL); // i don't care about string length here
        if (!fn[0]) {
          fclose(fl);
          fprintf(stderr, "ERROR: file %s, line %d: can't INCLUDE nothing!\n", fname, lineNo);
          return -1;
        }
        if (args[0]) {
          fclose(fl);
          fprintf(stderr, "ERROR: file %s, line %d: extra args after INCLUDE filename!\n", fname, lineNo);
          return -1;
        }
        if (includeCount > 256) {
          fclose(fl);
          fprintf(stderr, "ERROR: file %s, line %d: too many nested INCLUDEs!\n", fname, lineNo);
          return -1;
        }
        normIncName(curLine, fn, system);
        //if (system) sprintf(curLine, "%s/%s", sysIncludeDir, fn); else sprintf(curLine, "%s", fn);
        if ((fn = strdup(curLine)) == NULL) abort();
        ++includeCount;
        system = asmTextLoad(fn);
        --includeCount;
        free(fn);
        if (system) { fclose(fl); return system; }
        continue;
      }
    }
    // add current line
    if ((s = calloc(1, sizeof(SourceLine))) == NULL) abort();
    s->lineNo = lineNo;
    if ((s->line = strdup(curLine)) == NULL) abort();
    if ((s->fname = strdup(fname)) == NULL) abort();
    if (asmTextLast) asmTextLast->next = s; else asmText = s;
    asmTextLast = s;
  }
  fclose(fl);
  return 0;
}


static inline void loadCurSrcLine (void) { if (curSrcLine) strcpy(curLine, (curSrcLine != NULL ? curSrcLine->line : "")); }
static inline SourceLine *setCurSrcLine (SourceLine *l) { curSrcLine = l; loadCurSrcLine(); return l; }
static inline SourceLine *nextSrcLine (void) { return (curSrcLine != NULL ? setCurSrcLine(curSrcLine->next) : NULL); }


///////////////////////////////////////////////////////////////////////////////
// prototypes
//
static void processCurrentLine (void); // only one, will skip to next one


///////////////////////////////////////////////////////////////////////////////
// error raisers, etc
//
static jmp_buf errJP;


static void errorWriteFile (void) {
  if (curSrcLine) {
    fprintf(stderr, "at file %s, line %d\n%s\n*", curSrcLine->fname, curSrcLine->lineNo, curSrcLine->line);
  } else {
    fprintf(stderr, "somewhere in time: ");
  }
}

static void errorMsgV (const char *fmt, va_list ap) {
  errorWriteFile();
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fputc('\n', stderr);
  fflush(stderr);
}


static void __attribute__((format(printf, 1, 2))) warningMsg (const char *fmt, ...) {
  va_list ap;
  fprintf(stderr, "WARNING ");
  va_start(ap, fmt);
  errorMsgV(fmt, ap);
}


static void __attribute__((format(printf, 1, 2))) errorMsg (const char *fmt, ...) {
  va_list ap;
  fprintf(stderr, "FATAL ");
  va_start(ap, fmt);
  errorMsgV(fmt, ap);
}


static void __attribute__((noreturn)) __attribute__((format(printf, 1, 2))) fatal (const char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  errorMsgV(fmt, ap);
  longjmp(errJP, 666);
}


static void __attribute__((noreturn)) fatalUrLib (int errcode) {
  errorMsg("%s", urErrorMessage(errcode));
  longjmp(errJP, 666);
}


//////////////////////////////////////////////////////////////////////////////
// operator management
//
typedef int (*UrAsmOpFn) (void);

typedef struct UrAsmOp {
  char *name;
  UrAsmOpFn fn;
  struct UrAsmOp *next;
} UrAsmOp;

static UrAsmOp *oplist = NULL;


static UrAsmOp *urAddOp (const char *name, UrAsmOpFn fn) {
  UrAsmOp *res = calloc(1, sizeof(UrAsmOp));
  if (!res) abort();
  res->name = strdup(name);
  res->fn = fn;
  res->next = oplist;
  oplist = res;
  return res;
}


static UrAsmOp *urFindOp (const char *name) {
  UrAsmOp *res;
  for (res = oplist; res; res = res->next) if (!strcasecmp(name, res->name)) break;
  return res;
}


static void urClearOps (void) {
  while (oplist) {
    UrAsmOp *c = oplist;
    //
    oplist = oplist->next;
    free(c->name);
    free(c);
  }
}


///////////////////////////////////////////////////////////////////////////////
// label management
//
typedef struct UrLabelInfo {
  char *name;
  int32_t value;
  int type; /* -1: uknown (forward reference); 0: =; 1: equ; 2: code */
  int known; /* !0: label value already known */
  int refLine; /* first referenced line */
  int fixuptype; /* UR_FIXUP_XXX */
  char *refFile;
  struct UrLabelInfo *next;
} UrLabelInfo;

static UrLabelInfo *labels = NULL;


static void urClearLabels (void) {
  UrLabelInfo *c;
  //
  while ((c = labels) != NULL) {
    labels = c->next;
    if (c->name) free(c->name);
    if (c->refFile) free(c->refFile);
    free(c);
  }
}


static UrLabelInfo *urFindLabel (const char *name) {
  for (UrLabelInfo *c = labels; c; c = c->next) if (strcmp(name, c->name) == 0) return c;
  return NULL;
}


static UrLabelInfo *urAddLabel (const char *name) {
  UrLabelInfo *c = urFindLabel(name);
  //
  if (c == NULL) {
    UrLabelInfo *p;
    //
    for (p = NULL, c = labels; c; p = c, c = c->next) ;
    c = calloc(1, sizeof(UrLabelInfo));
    if (!c) abort();
    c->name = strdup(name);
    c->type = -1;
    c->fixuptype = UR_FIXUP_NONE;
    if (p) p->next = c; else labels = c;
    c->next = NULL;
  }
  return c;
}


///////////////////////////////////////////////////////////////////////////////
// module list management
//
typedef struct ModuleInfo {
  char *name;
  char *fname; // opened in this file
  int seen; // !0: module already seen, skip other definitions from the same file
  struct ModuleInfo *next;
} ModuleInfo;

static ModuleInfo *modules = NULL;
static ModuleInfo *curModule = NULL;


static void modulesClear (void) {
  curModule = NULL;
  while (modules) {
    ModuleInfo *c = modules;
    //
    modules = modules->next;
    free(c->name);
    free(c->fname);
    free(c);
  }
}


static void modulesResetSeen (void) {
  for (ModuleInfo *c = modules; c; c = c->next) c->seen = 0;
}


static ModuleInfo *moduleFind (const char *name) {
  if (!name || !name[0]) return NULL;
  for (ModuleInfo *c = modules; c; c = c->next) if (!strcmp(c->name, name)) return c;
  return NULL;
}


static ModuleInfo *moduleAdd (const char *name, const char *fname) {
  ModuleInfo *c;
  //
  if (!name || !fname || !name[0] || !fname[0]) abort();
  if ((c = calloc(1, sizeof(ModuleInfo))) == NULL) abort();
  if ((c->name = strdup(name)) == NULL) abort();
  if ((c->fname = strdup(fname)) == NULL) abort();
  c->next = modules;
  return (modules = c);
}


///////////////////////////////////////////////////////////////////////////////
// fixup management
typedef struct FixupItem {
  struct FixupItem *next;
  uint16_t opdestaddr;
  uint16_t opaddr;
  int fixuptype;
  int size;
} FixupItem;
static FixupItem *fixlisthead = NULL, *fixlisttail = NULL;


static void clearFixups (void) {
  FixupItem *c;
  //
  while ((c = fixlisthead) != NULL) {
    fixlisthead = c->next;
    free(c);
  }
}


static void addFixup (uint16_t opdestaddr, uint16_t opaddr, int fixuptype, int size) {
  FixupItem *fx = calloc(1, sizeof(FixupItem));
  //
  fx->opdestaddr = opdestaddr;
  fx->opaddr = opaddr;
  fx->fixuptype = fixuptype;
  fx->size = size;
  //
  if (fixlisttail != NULL) fixlisttail->next = fx; else fixlisthead = fx;
  fx->next = NULL;
  fixlisttail = fx;
}


///////////////////////////////////////////////////////////////////////////////
// destination memory management
//
static uint8_t memory[65536];
static char memused[65536];
static char memresv[65536];
static uint16_t pc = 0; /* current position to write */
static uint16_t disp = 0; /* current 'virtual PC' */
static uint16_t ent = 0; /* starting address */
static uint16_t clrAddr = 24999; /* address for CLEAR for cargador */
static int pass = 0; /* 0: collect labels; 1: compiling; 2: compiling and fixing labels */
static int inTapeBlock = 0;
static uint8_t tapeXorB = 0;


static inline uint8_t getByte (uint16_t addr) {
  return memory[addr];
}


/*
static inline __attribute__((unused)) uint16_t getWord (uint16_t addr) {
  return ((uint16_t)memory[addr])|(((uint16_t)memory[addr+1])<<8);
}
*/


static inline void putByte (uint16_t addr, uint8_t b) {
  if (inTapeBlock) tapeXorB ^= b;
  memory[addr] = b;
  memused[addr] = 1;
}


static inline MAYBE_UNUSED void putWord (uint16_t addr, uint16_t w) {
  putByte(addr, w&0xFFU);
  putByte(addr+1, (w>>8)&0xFFU);
}


static inline void emitByte (uint8_t b) {
  putByte(pc, b);
  ++pc;
  ++disp;
}


static inline void emitWord (uint16_t w) {
  emitByte(w&0xFFU);
  emitByte((w>>8)&0xFFU);
}


static inline void emitRWord (uint16_t w) {
  emitByte((w>>8)&0xFFU);
  emitByte(w&0xFFU);
}


static void prepareMemory (void) {
  memset(memory, 0, sizeof(memory));
  memset(memused, 0, sizeof(memused));
  memset(memresv, 0, sizeof(memresv));
}


///////////////////////////////////////////////////////////////////////////////
// label getter and utilities
//
static char *lastSeenGlobalLabel = NULL; /* global */


static char *fixLocalLabel (const char *name) {
  static char newname[MAX_LINE_SIZE*2+1024];
  //
  memset(newname, 0, sizeof(newname));
  if (!name || !name[0]) {
    newname[0] = '\0';
  } else if (!lastSeenGlobalLabel || name[0] != '.') {
    strcpy(newname, name);
  } else {
    if (name[0] == '.' && name[1] == '.') {
      // this is macro label
      if (curmacro == NULL) fatal("macro label outside of macro: '%s'", name);
      sprintf(newname, "{#MAC%d:%s:%s}", curmacronum, curmacro->mac->name, name);
    } else {
      // this is local label, let's rename it
      sprintf(newname, "{%s%s}", lastSeenGlobalLabel, name);
    }
  }
  return newname;
}


static char *fixGlobalLabel (const char *name) {
  static char newname[MAX_LINE_SIZE*2+1024];
  //
  memset(newname, 0, sizeof(newname));
  if (!name || !name[0]) {
    newname[0] = '\0';
  } else if (!curModule || name[0] == '.' || name[0] == '{' || name[0] == '@' || strchr(name, '.')) {
    if (name[0] == '@' && name[1]) ++name;
    strcpy(newname, name);
  } else {
    // this is global unqualified label and we have a module; let's rename it
    sprintf(newname, "%s.%s", curModule->name, name);
  }
  //printf("%s --> %s\n", name, newname);
  return newname;
}


static int lblOptMakeU2 = 0;

static int32_t findLabelCB (const char *name, uint16_t addr, int *defined, int *found, int *fixuptype) {
  UrLabelInfo *lbl;
  char *ln, *nn;
  //
  nn = fixGlobalLabel((ln = fixLocalLabel(name)));
  lbl = urFindLabel(nn);
  if (!lbl) {
    // try non-module label
    lbl = urFindLabel(ln);
  }
  if (!lbl) {
    if (pass != 0) {
      errorMsg("using undefined label %s", ln);
      *found = 0;
      *defined = 0;
      return 0;
    }
    lbl = urAddLabel(nn);
    lbl->type = (lblOptMakeU2 ? -42 : -1);
    lbl->known = 0;
    lbl->refLine = curSrcLine->lineNo;
    lbl->refFile = strdup(curSrcLine->fname);
    //printf("new label: [%s]\n", lbl->name);
  } else {
    //printf("label reference: [%s]\n", lbl->name);
  }
  if (lbl) {
    *found = 1;
    *defined = lbl->known!=0;
    *fixuptype = lbl->fixuptype;
    return lbl->value;
  }
  *found = 0;
  *defined = 0;
  return 0;
}


// qtypes
enum {
  UR_QTYPE_DEFINED,
  UR_QTYPE_KNOWN
};

static int isLabelDefinedOrKnown (const char *name, uint16_t addr, int qtype) {
  UrLabelInfo *lbl;
  char *ln, *nn;
  //
  nn = fixGlobalLabel((ln = fixLocalLabel(name)));
  lbl = urFindLabel(nn);
  if (!lbl) {
    // try non-module label
    lbl = urFindLabel(ln);
  }
  switch (qtype) {
    case UR_QTYPE_DEFINED: return lbl ? lbl->known!=0 : 0;
    case UR_QTYPE_KNOWN: return lbl!=NULL;
    default: ;
  }
  return 0;
}


static void fixupOperandCB (const URAOperand *op, uint16_t opdestaddr, uint16_t opaddr, int fixuptype, int size) {
  if (pass == 1) {
    //static const char *n[4] = {"none", "word", "low", "high"};
    //fprintf(stderr, "%d: fixupOperandCB: destaddr=#%04x; addr=#%04x; pc=#%04X; fixuptype=%s\n", size, opdestaddr, opaddr, pc, n[fixuptype]);
    addFixup(opdestaddr, opaddr, fixuptype, size);
  }
}


static int checkLabels (void) {
  int wasError = 0;
  //
  for (UrLabelInfo *c = labels; c; c = c->next) {
    if (c->type == -1) {
      fprintf(stderr, "ERROR at file %s, line %d: referencing undefined label: %s\n", c->refFile, c->refLine, c->name);
      wasError = 1;
    }
    if (c->type == 0) c->known = -1;
  }
  //if (wasError) longjmp(errJP, 667);
  return wasError;
}


///////////////////////////////////////////////////////////////////////////////
// expression utils
//
static inline char *strSkipSpaces (const char *s) {
  while (*s && isspace(*s)) ++s;
  return (char *)s;
}


static inline char *strSkipSpacesColons (char *s) {
  while (*s && (isspace(*s) || *s == ':')) ++s;
  return s;
}


static inline void skipSpaces (void) {
  char *e = strSkipSpaces(curLine);
  //
  if (e != curLine) memmove(curLine, e, strlen(e)+1);
}


static char *skipArg (char *str) {
  for (;;) {
    str = strSkipSpaces(str);
    if (!str[0] || str[0] == ',' || str[0] == ':') return str;
    if (str[0] == '"' || str[0] == '\'') {
      char qch = *str++;
      //
      while (*str && *str != qch) {
        if (*str++ == '\\') {
          switch (*str++) {
            case 'x': case 'X':
              for (int f = 0; f < 2; ++f, ++str) if (!isxdigit(*str)) break;
              break;
            case '0':
              for (int f = 0; f < 4; ++f, ++str) if (*str < '0' || *str > '7') break;
              break;
            case '1' ... '9':
              for (int f = 0; f < 3; ++f, ++str) if (!isdigit(*str)) break;
              break;
          }
        }
      }
      continue;
    }
    ++str;
  }
}


static int32_t getExprArg (int *defined, int *addr) {
  int error = 0;
  char *a = strSkipSpaces(curLine);
  const char *ee;
  int32_t res;
  //
  if (!a[0]) fatal("expression expected");
  ee = urExpression(&res, a, disp, defined, addr, &error);
  if (error) fatalUrLib(error);
  if (*ee) {
    if (ee[0] != ',' && ee[0] != ':') fatal("bad expression");
    memmove(curLine, ee, strlen(ee)+1);
  } else {
    curLine[0] = '\0';
  }
  return res;
}


static int32_t getOneExprArg (int *defined, int *addr) {
  int32_t res = getExprArg(defined, addr);
  //
  if (curLine[0] && curLine[0] != ':') fatal("too many expressions");
  return res;
}


static inline int isStrArg (void) { return (curLine[0] == '"' || curLine[0] == '\''); }


static char *getStrArg (int *lenp) {
  char *res, qCh;
  char *a = strSkipSpaces(curLine);
  //
  qCh = *a++;
  if (qCh != '"' && qCh != '\'') fatal("string expected");
  res = parseStr(&a, qCh, lenp);
  if (*a) {
    if (a[0] != ',' && a[0] != ':') fatal("bad string expression");
    memmove(curLine, a, strlen(a)+1);
  } else {
    curLine[0] = '\0';
  }
  return res;
}


static MAYBE_UNUSED char *getOneStrArg (int *lenp) {
  char *res = getStrArg(lenp);
  //
  if (curLine[0] && curLine[0] != ':') fatal("too many expressions");
  return res;
}


static char *getLabelArg (int checkdelim) {
  static char res[MAX_LINE_SIZE+128], *p;
  char *a = strSkipSpaces(curLine);
  //
  memset(res, 0, sizeof(res));
  if (!a[0]) fatal("label expected");
  for (p = res; *a && *a != ',' && *a != ':' && *a != '=' && !isspace(*a); ++a, ++p) *p = *a;
  for (; p > res && isspace(p[-1]); --p) ;
  *p = '\0';
  if (p-res > 120) fatal("label name too long: %s", res);
  while (*a && isspace(*a)) ++a;
  if (*a) {
    if (checkdelim && a[0] != ',' && a[0] != ':') fatal("bad label expression");
    memmove(curLine, a, strlen(a)+1);
  } else {
    curLine[0] = '\0';
  }
  return res;
}


static char *getOneLabelArg (void) {
  char *res = getLabelArg(1);
  //
  if (curLine[0] && curLine[0] != ':') fatal("too many expressions");
  return res;
}


/* res == 0: end of expression */
static int skipComma (void) {
  char *a = strSkipSpaces(curLine);
  //
  if (!a[0]) { curLine[0] = '\0'; return 0; }
  if (a[0] == ':') {
    while (a[0] && (a[0] == ':' || isspace(a[0]))) ++a;
    if (!a[0]) { curLine[0] = '\0'; return 0; }
    memmove(curLine, a, strlen(a)+1);
    return -1;
  }
  if (a[0] != ',') fatal("invalid expression: ',' expected");
  for (++a; *a && isspace(*a); ++a) ;
  if (!a[0]) { curLine[0] = '\0'; return 0; }
  memmove(curLine, a, strlen(a)+1);
  return 1;
}


// ???
static void skipInstruction (void) {
  char *str = curLine;
  //
  for (int cnt = 1; cnt > 0; --cnt) {
    while (*str && isspace(*str)) ++str; // skip spaces
    while (*str && !isspace(*str)) ++str; // skip non-spaces
    while (*str && isspace(*str)) ++str; // skip spaces
    if (!str[0] || *str != ':') break;
    // try again if we have a colon
  }
  memmove(curLine, str, strlen(str)+1);
}


///////////////////////////////////////////////////////////////////////////////
// label processor
//
static MAYBE_UNUSED void removeSpacesAndColons (void) {
  char *ep = strSkipSpacesColons(curLine);
  //
  memmove(curLine, ep, strlen(ep)+1);
}


static void checkExprEnd (void) {
  char *ep = strSkipSpaces(curLine);
  //
  memmove(curLine, ep, strlen(ep)+1);
  if (curLine[0] && curLine[0] != ':') fatal("end of expression expected");
}


/* remove label from curLine */
static void removeLabel (void) {
  char *ep = curLine;
  //
  if (ep[0] && !isspace(ep[0])) for (ep = curLine; *ep && !isspace(*ep) && *ep != ':'; ++ep) ; // skip text
  // skip spaces and colons
  ep = strSkipSpacesColons(ep);
  memmove(curLine, ep, strlen(ep)+1);
}


static void processLabel (void) {
  char *argstart;
  char *ep, *ln, *nn;
  static char n2[256];
  UrLabelInfo *lbl;
  int noLocAff = 0, doEQU = 0;
  //
  memset(n2, 0, sizeof(n2));
  if (!curLine[0] || isspace(curLine[0]) || curLine[0] == ':') { removeLabel(); return; } // removeLabel() removes any spaces, etc
  // collect label
  for (ep = curLine; *ep && !isspace(*ep) && *ep != ':'; ++ep) ;
  if (ep-curLine > 120) fatal("label too long");
  // copy label
  memset(n2, 0, sizeof(n2));
  memmove(n2, curLine, ep-curLine);
  if (!urIsValidLabelName(n2)) return; // this is not a valid label, get out of here
  // check if this can be instruction
  ep = strSkipSpaces(ep);
  if (*ep != ':' && urFindOp(n2)) return; // this must be and instruction, process it
  // ok, we got a good label
  removeLabel();
  if (n2[0] == '@' && n2[1]) { noLocAff = 1; memmove(n2, n2+1, strlen(n2)); }
  nn = fixGlobalLabel((ln = fixLocalLabel(n2)));
  lbl = urAddLabel(nn);
  if (!lbl->refFile) {
    lbl->refLine = curSrcLine->lineNo;
    lbl->refFile = strdup(curSrcLine->fname);
  }
  //printf("new: [%s]\n", lbl->name);
  // get command name
  if (curLine[0] == '=') {
    doEQU = 0;
    argstart = curLine+1;
  } else {
    doEQU = 1;
    argstart = strIsCommand("EQU", curLine);
  }
  if (!argstart || doEQU) {
    if (pass == 0 && lbl->type != -1) fatal("duplicate label %s", lbl->name);
  }
  if (argstart) {
    // do '=' or 'EQU'
    memmove(curLine, argstart, strlen(argstart)+1);
    if (!doEQU) {
      if (lbl->type != -1 && lbl->type != 0) fatal("duplicate label %s", lbl->name);
    }
    //
    int defined = 1, addr = UR_FIXUP_NONE;
    int32_t res = getOneExprArg(&defined, &addr);
    //
    lbl->type = doEQU;
    if (addr != UR_FIXUP_NONE) lbl->fixuptype = addr;
    if (defined) {
      lbl->value = res;
      lbl->known = 1;
    } else {
      if (pass != 0) fatal("can't calculate label %s", lbl->name);
    }
    curLine[0] = '\0';
    return;
  }
  // code label
  if (lbl->name[0] != '{' && !noLocAff) {
    if (lastSeenGlobalLabel) free(lastSeenGlobalLabel);
    lastSeenGlobalLabel = strdup(lbl->name);
  }
  lbl->type = 2;
  lbl->value = disp;
  lbl->known = 1;
  lbl->fixuptype = UR_FIXUP_WORD;
}


///////////////////////////////////////////////////////////////////////////////
// instruction finder (in source)
//
/* array ends with NULL */
/* returns line or NULL */
/* iidx will be set to found instruction number */
static __attribute__((sentinel)) SourceLine *findNextInstructionFromList (int *iidx, ...) {
  if (iidx) *iidx = -1;
  for (SourceLine *cur = curSrcLine; cur; cur = cur->next) {
    va_list ap;
    //
    //if (!isspace(cur->line[0])) continue; // fuck labeled strings
    va_start(ap, iidx);
    for (int f = 0; ;++f) {
      const char *name = va_arg(ap, const char *);
      //
      if (!name) break;
      if (strIsCommand(name, cur->line)) {
        va_end(ap);
        if (iidx) *iidx = f;
        return cur;
      }
    }
    va_end(ap);
  }
  return NULL;
}


static MAYBE_UNUSED SourceLine *findNextInstruction (const char *name) {
  return findNextInstructionFromList(NULL, name, NULL);
}


///////////////////////////////////////////////////////////////////////////////
// writers
//
static int optWriteFixups = 0;
static int optRunTape = 1;
static int optRunDMB = 1;
static int optTapExt = 0; /* set '.tap' extension (but don't write tape; this for inline tape blocks) */
static int optSNA48 = 1;


///////////////////////////////////////////////////////////////////////////////
static void writeFixups (void) {
  FILE *fo = fopen("zfixuptable.txt", "w");
  //
  if (fo == NULL) fatal("can't write fixup file");
  fprintf(fo, "; addr dadr sz\n");
  for (const FixupItem *fx = fixlisthead; fx != NULL; fx = fx->next) {
    static const char type[4] = "NWLH";
    fprintf(fo, "%c #%04x #%04x %d\n", type[fx->fixuptype], fx->opaddr, fx->opdestaddr, fx->size);
  }
  fclose(fo);
}


///////////////////////////////////////////////////////////////////////////////
/* return 'found' flag */
static int findChunkFrom (int addr, int *start, int *len) {
  if (addr < 0) addr = 0;
  for (; addr <= 65535 && !memused[addr]; ++addr) ;
  if (addr > 65535) return 0;
  *start = addr;
  for (; addr <= 65535 && memused[addr]; ++addr) ;
  *len = addr-(*start);
  return 1;
}


static void rleUnpack (uint16_t addr, const uint8_t *buf, int buflen) {
  for (; buflen >= 2; buflen -= 2) {
    int cnt = *buf++;
    uint8_t byte = *buf++;
    //
    if (cnt == 0) {
      // copy
      for (cnt = byte; cnt >= 0; --cnt, ++addr, --buflen, ++buf) {
        if (!memused[addr]) putByte(addr, *buf);
        if (addr == 0xffff) return;
      }
    } else {
      // fill
      for (; cnt > 0; --cnt, ++addr) {
        if (!memused[addr]) putByte(addr, byte);
        if (addr == 0xffff) return;
      }
    }
  }
}


static int fWriteByte (FILE *fo, uint8_t b, uint8_t *bxor) {
  if (fwrite(&b, 1, 1, fo) != 1) return -1;
  if (bxor) *bxor = (*bxor)^b;
  return 0;
}


static int fWriteWord (FILE *fo, uint16_t w, uint8_t *bxor) {
  if (fWriteByte(fo, w&0xFFU, bxor)) return -1;
  if (fWriteByte(fo, (w>>8)&0xFFU, bxor)) return -1;
  return 0;
}


///////////////////////////////////////////////////////////////////////////////
// .sna
//
static int saveSna (const char *fname, int as48) {
  char *fn = malloc(strlen(fname)+16);
  uint8_t regs[27];
  FILE *fo;
  char abuf[32];
  //
  sprintf(fn, "%s.sna", fname);
  fo = fopen(fn, "wb");
  free(fn);
  if (!fo) { fprintf(stderr, "ERROR: can't write SNA file: %s.sna\n", fname); return -1; }
  printf("out: %s.sna\n", fname);
  memmove(regs, ursna48, 27);
#if 0
  if (optRunSNA) {
    /* push new address */
    uint16_t sp = (uint16_t)regs[23]+(((uint16_t)regs[24])<<8);
    sp -= 2;
    putByte(sp, ent&0xFFU);
    putByte(sp+1, (ent>>8)&0xFFU);
    regs[23] = sp&0xFFU;
    regs[24] = (sp>>8)&0xFFU;
  }
  fwrite(regs, 27, 1, fo);
  rleUnpack(16384, ursna48+27, sizeof(ursna48)-27);
  fwrite(memory+16384, 49152, 1, fo);
#endif
  //
  uint16_t sp = (uint16_t)regs[23]+(((uint16_t)regs[24])<<8);
  //
  //fprintf(stderr, "SP: #%04X #%02X%02X\n", sp, memory[sp+1], memory[sp]);
  //fprintf(stderr, "%d\n", memused[sp]);
  if (memused[sp] || memused[(sp+1)&0xffff]) {
    fprintf(stderr, "FATAL: can't save snapshot!\n");
    goto error;
  }
  //
  if (fwrite(ursna48, 27, 1, fo) != 1) goto error;
  rleUnpack(16384, (const uint8_t *)ursna48+27, sizeof(ursna48)-27);
  //for (int f = 0; f < 49152; ++f) if (!memused[f+16384]) memory[f+16384] = ursna48[f+27];
  //
  sprintf(abuf, "%05d", clrAddr);
  memcpy(memory+23762, abuf, 5);
  sprintf(abuf, "%05d", ent);
  memcpy(memory+23773, abuf, 5);
  //
  if (fwrite(memory+16384, 49152, 1, fo) != 1) goto error;
  //
  if (!as48) {
    int addr = memory[sp]+256*memory[(sp+1)&0xffff];
    //
    if (fWriteWord(fo, addr, NULL) != 0) goto error; // PC
    if (fWriteByte(fo, 0x10, NULL) != 0) goto error; // 7FFD
    if (fWriteByte(fo, 0, NULL) != 0) goto error; // TR-DOS inactive
    // write pages
    memset(memory, 0, 16384);
    for (int f = 1; f < 8; ++f) {
      if (f != 2 && f != 5) {
        if (fwrite(memory, 16384, 1, fo) != 1) goto error;
      }
    }
  }
  //
  fclose(fo);
  return 0;
error:
  fclose(fo);
  unlink(fname);
  return -1;
}


///////////////////////////////////////////////////////////////////////////////
// bin chunks
//
static void saveRaw (const char *basename) {
  char *fname = malloc(strlen(basename)+16);
  int start = 0, len;
  FILE *fo;
  //
  while (findChunkFrom(start, &start, &len)) {
    sprintf(fname, "%s_%04X.%s", basename, start, optTapExt?"tap":"bin");
    fo = fopen(fname, "wb");
    if (!fo) {
      fprintf(stderr, "ERROR: can't write file %s!\n", fname);
    } else {
      printf("out: %s\n", fname);
      if (fwrite(memory+start, len, 1, fo) != 1) {
        fprintf(stderr, "ERROR: error writing file %s!\n", fname);
        fclose(fo);
        unlink(fname);
      } else {
        fclose(fo);
      }
    }
    start += len;
  }
  free(fname);
}


///////////////////////////////////////////////////////////////////////////////
// HoBeta files
//
typedef struct __attribute__((packed)) __attribute__((gcc_struct)) {
  char name[8];
  char type;
  uint16_t start;
  uint16_t len;
  uint8_t zero; // always zero
  uint8_t secLen; // length in sectors
  uint16_t checksum;
} HOBHeader;


static uint16_t calcHobSum (const void *hdr) {
  const uint8_t *buf = (const uint8_t *)hdr;
  uint16_t res = 0;
  //
  for (unsigned int f = 0; f < 15; ++f) res += ((uint16_t)buf[f])*257+f;
  return res;
}


static void saveHob (const char *basename) {
  char *fname = malloc(strlen(basename)+16);
  int start = 0, len;
  HOBHeader hdr;
  FILE *fo;
  //
  while (findChunkFrom(start, &start, &len)) {
    sprintf(fname, "%s_%04X.%s", basename, start, "$C");
    fo = fopen(fname, "wb");
    if (!fo) {
      fprintf(stderr, "ERROR: can't write file %s!\n", fname);
      start += len;
    } else {
      printf("out: %s\n", fname);
      memset(&hdr, 0, sizeof(hdr));
      memset(&hdr.name, 32, 8);
      sprintf(hdr.name, "%c%04X", basename[0], start);
      hdr.name[strlen(hdr.name)] = 32;
      hdr.type = 'C';
      hdr.start = start;
      hdr.len = len;
      hdr.secLen = (len+255)/256;
      hdr.checksum = calcHobSum(&hdr);
      if (fwrite(&hdr, sizeof(hdr), 1, fo) != 1) {
        fprintf(stderr, "ERROR: error writing file %s!\n", fname);
        fclose(fo);
        unlink(fname);
        goto quit;
      }
      if (fwrite(memory+start, len, 1, fo) != 1) {
        fprintf(stderr, "ERROR: error writing file %s!\n", fname);
        fclose(fo);
        unlink(fname);
        goto quit;
      }
      start += len;
      while (len%256) {
        if (fwrite(&hdr.zero, 1, 1, fo) != 1) {
          fprintf(stderr, "ERROR: error writing file %s!\n", fname);
          fclose(fo);
          unlink(fname);
          goto quit;
        }
        ++len;
        //fprintf(stderr, ":%d\n", len%256);
      }
      fclose(fo);
    }
  }
quit:
  free(fname);
}


///////////////////////////////////////////////////////////////////////////////
// .dmb
//
static int saveDMB (const char *fname) {
  char *fn = malloc(strlen(fname)+16);
  int start = 0, len;
  uint16_t pcnt = 0;
  FILE *fo;
  //
  sprintf(fn, "%s.dmb", fname);
  fo = fopen(fn, "wb");
  free(fn);
  if (!fo) { fprintf(stderr, "ERROR: can't write DMB file: %s.dmb\n", fname); return -1; }
  //
  while (findChunkFrom(start, &start, &len)) { ++pcnt; start += len; }
  //
  printf("out: %s.dmb\n", fname);
  if (fwrite("DMB1", 4, 1, fo) != 1) goto error;
  if (fWriteWord(fo, (optRunDMB ? ent : 0), NULL) != 0) goto error;
  if (fWriteWord(fo, clrAddr, NULL) != 0) goto error;
  if (fWriteWord(fo, pcnt, NULL) != 0) goto error;
  //
  start = 0;
  while (findChunkFrom(start, &start, &len)) {
    if (fWriteWord(fo, len, NULL) != 0) goto error;
    if (fWriteWord(fo, start, NULL) != 0) goto error;
    if (fwrite(memory+start, len, 1, fo) != 1) goto error;
    start += len;
  }
  fclose(fo);
  return 0;
error:
  fclose(fo);
  unlink(fname);
  fprintf(stderr, "ERROR: error writing file %s.dmb!\n", fname);
  return -1;
}


///////////////////////////////////////////////////////////////////////////////
// .tap
//
static char tapeLoaderName[16];


static void saveTapCargador (FILE *fo) {
  // count blocks
  static uint8_t cargador[16384]; // should be enough for everyone
  int start = 0, len, pos, f;
  uint8_t bxor;
  //

  void putStr (const char *s) {
    for (; *s; ++s) cargador[pos++] = *s;
  }

  void putNum (int num) {
    char buf[64];
    sprintf(buf, "%d", num);
    putStr(buf);
  }

  //
  pos = 4;
  // number
  cargador[0] = 0; cargador[1] = 10;
  // size (will be fixed later)
  putStr("\xfd\xb0\""); putNum(clrAddr); putStr("\""); // CLEAR VAL "xxx"
  // load blocks
  while (findChunkFrom(start, &start, &len)) {
    // :LOAD "" CODE
    putStr(":\xef\"\"\xaf");
    start += len;
  }
  // and run
  // :RANDOMIZE USR VAL "xxx"
  putStr(":\xf9\xc0\xb0\""); putNum(ent); putStr("\"\r");
  // patch len
  cargador[2] = (pos-4)&0xff;
  cargador[3] = ((pos-4)>>8)&0xff;
  // write header
  fWriteWord(fo, 19, NULL); // length of header
  bxor = 0;
  fWriteByte(fo, 0, &bxor); // header block
  fWriteByte(fo, 0, &bxor); // 'basic' flag
  if (tapeLoaderName[0]) {
    for (int f = 0; f < 10; ++f) fWriteByte(fo, tapeLoaderName[f], &bxor);
  } else {
    fWriteByte(fo, 'c', &bxor);
    fWriteByte(fo, 'a', &bxor);
    fWriteByte(fo, 'r', &bxor);
    fWriteByte(fo, 'g', &bxor);
    fWriteByte(fo, 'a', &bxor);
    fWriteByte(fo, 'd', &bxor);
    fWriteByte(fo, 'o', &bxor);
    fWriteByte(fo, 'r', &bxor);
    fWriteByte(fo, ' ', &bxor);
    fWriteByte(fo, ' ', &bxor);
  }
  fWriteWord(fo, pos, &bxor); // length
  fWriteWord(fo, 10, &bxor); // start
  fWriteWord(fo, pos, &bxor); // length2
  fWriteByte(fo, bxor, NULL);
  // write data
  fWriteWord(fo, pos+2, NULL); // plus type and checkbyte
  bxor = 0;
  fWriteByte(fo, 0xFFU, &bxor); // data block
  for (f = 0; f < pos; ++f) fWriteByte(fo, cargador[f], &bxor);
  fWriteByte(fo, bxor, NULL);
}


static void saveTap (const char *basename) {
  char *fname = malloc(strlen(basename)+16);
  char blkname[128];
  int start = 0, len, f;
  uint8_t bxor;
  FILE *fo;
  //
  sprintf(fname, "%s.tap", basename);
  fo = fopen(fname, "wb");
  free(fname);
  if (!fo) { fprintf(stderr, "ERROR: can't write file %s.tap!\n", basename); return; }
  printf("out: %s.tap\n", basename);
  if (optRunTape) saveTapCargador(fo);
  while (findChunkFrom(start, &start, &len)) {
    // write header
    if (tapeLoaderName[0]) {
      //for (int f = 0; f < 10; ++f) fWriteByte(fo, tapeLoaderName[f], &bxor);
      memcpy(blkname, tapeLoaderName, 10);
    } else {
      sprintf(blkname, "c%04X:%04X", start, len);
    }
    //printf(" block: %s\n", blkname);
    fWriteWord(fo, 19, NULL); // length of header
    bxor = 0;
    fWriteByte(fo, 0, &bxor); // header block
    fWriteByte(fo, 3, &bxor); // 'code' flag
    for (f = 0; f < 10; ++f) fWriteByte(fo, blkname[f], &bxor);
    fWriteWord(fo, len, &bxor);
    fWriteWord(fo, start, &bxor);
    fWriteWord(fo, 32768, &bxor);
    fWriteByte(fo, bxor, NULL);
    // write data
    fWriteWord(fo, len+2, NULL); // plus type and checkbyte
    bxor = 0;
    fWriteByte(fo, 0xFFU, &bxor); // data block
    for (f = 0; f < len; ++f) fWriteByte(fo, memory[start+f], &bxor);
    fWriteByte(fo, bxor, NULL);
    start += len;
  }
  fclose(fo);
}


///////////////////////////////////////////////////////////////////////////////
// pseudoinstructions
//
// note that processCurrentLine() will NOT skip to the next line before
// calling pseudoinstruction handler!
// note that processCurrentLine() will skip current line after calling
// pseudoinstruction handler!
//
static int wasOrg = 0;
static int wasClr = 0;


///////////////////////////////////////////////////////////////////////////////
// user warnings
//
static int piDISPLAYX (int passNo, int asHex) {
  for (;;) {
    if (isStrArg()) {
      int len = 0;
      char *res = getStrArg(&len);
      //
      if (passNo < 0 || pass == passNo) printf("%s", res);
    } else {
      int defined = 1;
      int32_t v = getExprArg(&defined, NULL);
      //
      if (passNo < 0 || pass == passNo) {
        if (asHex) printf("%04X", (unsigned int)v);
        else printf("%d", v);
      }
    }
    if (!skipComma()) break;
  }
  return 0;
}


static int piDISPLAY (void) { return piDISPLAYX(1, 0); }
static int piDISPLAY0 (void) { return piDISPLAYX(0, 0); }
static int piDISPLAYA (void) { return piDISPLAYX(-1, 0); }
static int piDISPHEX (void) { return piDISPLAYX(1, 1); }
static int piDISPHEX0 (void) { return piDISPLAYX(0, 1); }
static int piDISPHEXA (void) { return piDISPLAYX(-1, 1); }


///////////////////////////////////////////////////////////////////////////////
// ORG, DISP, etc.
//
static int piORG (void) {
  int defined = 1;
  int32_t res = getOneExprArg(&defined, NULL);
  //
  if (!defined) fatal("sorry, ORG operand value must be known here");
  if (res < 0 || res > 65535) fatal("invalid ORG operand value: %d", res);
  if (inTapeBlock) fatal("sorry, no ORGs in TAPEDATA allowed");
  pc = disp = res;
  if (!wasOrg) {
    wasOrg = 1;
    ent = res;
    if (!wasClr && res > 0) clrAddr = res-1;
  }
  return 0;
}


static int piDISP (void) {
  int defined = 1;
  int32_t res = getOneExprArg(&defined, NULL);
  //
  if (!defined) fatal("sorry, DISP operand value must be known here");
  if (res < 0 || res > 65535) fatal("invalid DISP operand value: %d", res);
  //printf("DISP=%d\n", res);
  disp = res;
  return 0;
}


static int piENDDISP (void) {
  if (inTapeBlock) fatal("sorry, no ENDDISPs in TAPEDATA allowed");
  checkExprEnd();
  disp = pc;
  return 0;
}


static int piENT (void) {
  int defined = 1;
  int32_t res = getOneExprArg(&defined, NULL);
  //
  //if (!defined) fatal("sorry, ENT operand value must be known here");
  if (res < 0 || res > 65535) fatal("invalid ENT operand value: %d", res);
  ent = res;
  return 0;
}


static int piCLR (void) {
  int defined = 1;
  int32_t res = getOneExprArg(&defined, NULL);
  //
  //if (!defined) fatal("sorry, CLR operand value must be known here");
  if (res < 0 || res > 65535) fatal("invalid CLR operand value: %d", res);
  clrAddr = res;
  wasClr = 1;
  return 0;
}


static int piRESERVE (void) {
/*
  int defined = 1, start;
  int32_t res = getExprArg(&defined, NULL);
  if (!defined) fatal("sorry, RESERVE operand values must be known here");
  if (res < 0 || res > 65535) fatal("invalid RESERVE operand value: %d", res);
  start = res;
  if (!skipComma()) fatal("RESERVE needs 2 args");
  res = getOneExprArg(&defined, NULL);
  if (!defined) fatal("sorry, RESERVE operand values must be known here");
  if (res < 0 || res > 65535) fatal("invalid RESERVE operand value: %d", res);
  for (; len > 0; --len, start = (start+1)&0xffff) memresv[start] = 1;
*/
  fatal("RESERVE: not yet!");
  return 0;
}


static int piALIGN (void) {
  int defined = 1;
  int32_t res;
  //
  if (inTapeBlock) fatal("sorry, no ALIGNs in TAPEDATA allowed");
  res = getOneExprArg(&defined, NULL);
  if (!defined) fatal("sorry, ALIGN operand value must be known here");
  if (res < 0 || res > 65535) fatal("invalid ALIGN operand value: %d", res);
  if (pc != disp) fatal("sorry, no ALIGNs in desynced blocks allowed");
  if (res > 0 && pc%res != 0) {
    pc /= res;
    pc *= res;
    pc += res;
    disp = pc;
  }
  return 0;
}


static int piDISPALIGN (void) {
  int defined = 1;
  int32_t res = getOneExprArg(&defined, NULL);
  //
  if (!defined) fatal("sorry, DISPALIGN operand value must be known here");
  if (res < 0 || res > 65535) fatal("invalid DISPALIGN operand value: %d", res);
  if (res > 0 && disp%res != 0) {
    disp /= res;
    disp *= res;
    disp += res;
  }
  return 0;
}


///////////////////////////////////////////////////////////////////////////////
// DEFx
//
static int defIncr = 0;


static int piDEFINCR (void) {
  int defined = 1;
  int32_t cnt = getOneExprArg(&defined, NULL);
  //
  if (!defined) fatal("DEFINCR: increment must be defined");
  defIncr = cnt;
  return 0;
}


static int piDEFBW (int isWord) {
  for (;;) {
    int defined = 0, fixuptype = UR_FIXUP_NONE;
    //
    if (isStrArg()) {
      int f, len = 0;
      char *res = getStrArg(&len);
      //
      for (f = 0; f < len; ++f) {
        int32_t b = (uint8_t)res[f];
        b += defIncr;
        if (b < -128 || b > 255) fatal("invalid operand value: %d", b);
        if (b < 0) b += 256;
        emitByte(b);
      }
    } else {
      int32_t res = getExprArg(&defined, &fixuptype);
      //
      if (pass > 0 && !defined) fatal("undefined operand");
      res += defIncr;
      if (isWord) {
        if (res < -32768 || res > 65535) fatal("invalid operand value: %d", res);
        if (res < 0) res += 65536;
        if (fixuptype != UR_FIXUP_NONE) urAsmFixupOperandFn(NULL, pc, disp, fixuptype, 2);
        if (isWord == 1) emitWord(res); else emitRWord(res);
      } else {
        if (res < -128 || res > 255) fatal("invalid operand value: %d", res);
        if (fixuptype != UR_FIXUP_NONE) {
          if (fixuptype == UR_FIXUP_WORD) fatal("invalid fixup for operand");
          urAsmFixupOperandFn(NULL, pc, disp, fixuptype, 1);
        }
        if (res < 0) res += 256;
        emitByte(res);
      }
    }
    if (!skipComma()) break;
  }
  return 0;
}

static int piDEFB (void) { return piDEFBW(0); }
static int piDEFW (void) { return piDEFBW(1); }
static int piDEFR (void) { return piDEFBW(2); }


static int piDEFS (void) {
  for (;;) {
    int32_t bt, f;
    int defined = 0, fixuptype = UR_FIXUP_NONE;
    int32_t res = getExprArg(&defined, &fixuptype);
    //
    if (pass > 0 && !defined) fatal("undefined operand");
    if (res < 1 || res > 65535) fatal("invalid number of repetitions: %d", res);
    if (*curLine && curLine[0] == ',') {
      skipComma();
      bt = getExprArg(&defined, NULL);
      if (pass > 0 && !defined) fatal("undefined operand");
      bt += defIncr;
      if (bt < -128 || bt > 255) fatal("invalid operand value: %d", res);
      if (bt < 0) bt += 256;
      if (fixuptype != UR_FIXUP_NONE) {
        if (fixuptype == UR_FIXUP_WORD) fatal("invalid fixup for operand");
      }
      for (f = 0; f < res; ++f) {
        if (fixuptype != UR_FIXUP_NONE) urAsmFixupOperandFn(NULL, pc, disp, fixuptype, 1);
        emitByte(bt);
      }
    } else {
      pc += res; disp += res;
    }
    if (!skipComma()) break;
  }
  return 0;
}


/* bit 0: put '\0' */
/* bit 1: set bit 7 of last byte */
/* bit 2: put length */
static int piDEFSTR (int type) {
  for (;;) {
    if (isStrArg()) {
      int f, len = 0;
      char *res = getStrArg(&len);
      //
      if (type&0x04) {
        if (len > 255) fatal("string too long");
        emitByte(len);
      }
      for (f = 0; f < len; ++f) {
        uint8_t b = (uint8_t)res[f];
        //
        if ((type&0x02) && f == len-1) b |= 0x80;
        emitByte(b);
      }
      if (type&0x01) emitByte(0);
    } else {
      int defined = 1;
      int32_t v = getExprArg(&defined, NULL);
      //
      if (pass > 0 && !defined) fatal("undefined expression");
      if (!defined) v = 0; else v += defIncr;
      if (v < -128 || v > 255) fatal("invalid operand value: %d", v);
      if (v < 0) v += 256;
      emitByte(v);
    }
    if (!skipComma()) break;
  }
  return 0;
}


static int piDEFM (void) { return piDEFSTR(0x00); }
static int piDEFZ (void) { return piDEFSTR(0x01); }
static int piDEFX (void) { return piDEFSTR(0x02); }
static int piDEFC (void) { return piDEFSTR(0x04); }


///////////////////////////////////////////////////////////////////////////////
// INCBIN
//
/* INCBIN "name"[,maxlen] */
static int piINCBIN (void) {
  int system = 0;
  char *fn, qCh;
  uint8_t bt;
  FILE *fl;
  int maxlen = 65536;
  char *args = curLine;
  //
  if (!curLine[0]) fatal("INCBIN without file name");
  if (isStrArg()) {
    qCh = *args++;
    system = 0;
  } else if (curLine[0] == '<') {
    qCh = '<'; ++args;
    system = 1;
  } else {
    qCh = 0;
    system = 0;
  }
  fn = parseStr(&args, qCh, NULL); // i don't care about string length here
  if (!fn[0]) fatal("INCBIN: empty file name");
  memmove(curLine, args, strlen(args)+1);
  // maxlen
  if (curLine[0] == ',') {
    int defined = 1;
    //
    skipComma();
    maxlen = getOneExprArg(&defined, NULL);
    if (!defined) fatal("INCBIN: undefined maxlen");
    if (maxlen < 1) return 1; // nothing to do
  }
  // now fix name
  if (system) {
    sprintf(curLine, "%s/%s", sysIncludeDir, fn);
  } else {
    sprintf(curLine, "%s", fn);
  }
  //
  fl = fopen(curLine, "rb");
  if (!fl) fatal("INCBIN: file not found: %s", curLine);
  while (maxlen-- > 0) {
    int res = fread(&bt, 1, 1, fl);
    //
    if (!res) break;
    if (res != 1) { fclose(fl); fatal("INCBIN: error reading file: %s", curLine); }
    emitByte(bt);
  }
  fclose(fl);
  return 1;
}


///////////////////////////////////////////////////////////////////////////////
// MODULE, ENDMODULE
//
static int piENDMODULE (void) {
  if (!curModule) fatal("ENDMODULE without MODULE");
  if (curLine[0]) {
    char *mn = getOneLabelArg();
    //
    if (strcmp(mn, curModule->name)) fatal("invalid module name in ENDMODULE: %s", mn);
  }
  curModule = NULL;
  return 0;
}


static int piMODULE (void) {
  ModuleInfo *mi;
  char *mn;
  SourceLine *ol = curSrcLine;
  int inum;
  //
  if (curModule) fatal("no nested modules allowed");
  mn = getOneLabelArg();
  if (!urIsValidLabelName(mn)) fatal("invalid module name: %s", mn);
  mi = moduleFind(mn);
  //printf("[%s] %p\n", mn, mi);
  if (mi) {
    if (mi->seen) {
      if (strcmp(mi->fname, curSrcLine->fname)) fatal("duplicate module definition; previous was in %s", mi->fname);
      /* skip module */
      nextSrcLine(); // skip ourself
      if (!setCurSrcLine(findNextInstructionFromList(&inum, "MODULE", "ENDMODULE", NULL))) {
        setCurSrcLine(ol);
        fatal("no ENDMODULE");
      }
      if (inum == 0) fatal("no nested modules allowed");
      curModule = mi;
      skipInstruction();
      piENDMODULE();
      return 0;
    }
  } else {
    mi = moduleAdd(mn, curSrcLine->fname);
  }
  mi->seen = 1;
  curModule = mi;
  return 0;
}


///////////////////////////////////////////////////////////////////////////////
// DUP, EDUP
//
static int piEDUP (void) {
  fatal("EDUP without DUP");
  checkExprEnd();
  return 1;
}


static int piDUP (void) {
  int defined = 1, dupCnt = 1, inum;
  SourceLine *stline, *eline = NULL;
  int32_t cnt = getOneExprArg(&defined, NULL);
  //
  if (!defined) fatal("DUP: counter must be defined");
  if (cnt > 65535) fatal("DUP: counter too big: %d", cnt);
  if (cnt < 0) warningMsg("DUP: counter too small: %d", cnt);
  // now find corresponding EDUP
  // note that we should skip nested DUPs
  nextSrcLine(); // skip ourself
  stline = curSrcLine;
  while (curSrcLine) {
    if (!setCurSrcLine(findNextInstructionFromList(&inum, "DUP", "EDUP", NULL))) break;
    // ok, we found something; what is it?
    if (inum == 0) {
      // new DUP, skip it
      ++dupCnt;
      nextSrcLine(); // skip DUP
    } else {
      // EDUP
      if (--dupCnt == 0) {
        // gotcha!
        eline = curSrcLine;
        break;
      }
      nextSrcLine(); // skip EDUP
    }
  }
  if (!eline) { setCurSrcLine(stline); fatal("no EDUP"); }
  // now repeat that lines
  while (cnt-- > 0) {
    setCurSrcLine(stline);
    while (curSrcLine != eline) processCurrentLine();
  }
  return 1;
}


///////////////////////////////////////////////////////////////////////////////
// IF, ENDIF
//
static int ifCount = 0;


static int ifSkipToEndIfOrElse (int wholeBody) {
  int inum, wasElse = 0;
  SourceLine *oline;
  //
  while (curSrcLine) {
    if (!setCurSrcLine(findNextInstructionFromList(&inum, "IF", "ELSE", "ENDIF", "ELSEIF", "MACRO", "ENDM", "IFX", "ELSEIFX", NULL))) break;
    switch (inum) {
      case 0: /* if */
      case 6: /* ifx */
        nextSrcLine(); // skip IF
        ifSkipToEndIfOrElse(1); // and recurse
        nextSrcLine(); // skip ENDIF
        break;
      case 1: /* else */
        if (wasElse) fatal("duplicate ELSE");
        if (!wholeBody) return 1;
        wasElse = 1;
        nextSrcLine(); // skip ELSE
        break; // and continue
      case 2: /* endif */
        return 0; // and exit
      case 3: /* elif */
      case 7: /* elifx */
        if (wasElse) fatal("ELSEIF in ELSE");
        if (!wholeBody) return 2;
        nextSrcLine(); // skip ELSEIF
        break; // and continue
      case 4: /* macro */
        // skip it as a whole
        nextSrcLine(); // skip MACRO
        for (;;) {
          oline = curSrcLine;
          if (!setCurSrcLine(findNextInstructionFromList(&inum, "MACRO", "ENDM", NULL))) { setCurSrcLine(oline); fatal("invalid MACRO"); }
          if (inum == 1) break;
          fatal("invalid nested MACRO");
        }
        nextSrcLine(); // skip ENDM
        break;
      case 5: /* endm */
        fatal("unexpected ENDM");
    }
  }
  fatal("IF without ENDIF");
  return -1;
}


static int piENDIF (void) {
  if (--ifCount < 0) fatal("ENDIF without IF");
  checkExprEnd();
  return 1;
}


static int piELSE (void) {
  if (--ifCount < 0) fatal("ELSE without IF");
  nextSrcLine(); // skip ELSE
  ifSkipToEndIfOrElse(1);
  return 1;
}


static int piELSEIF (void) {
  if (--ifCount < 0) fatal("ELSEIF without IF");
  nextSrcLine(); // skip ELSEIF
  ifSkipToEndIfOrElse(1);
  return 1;
}


static int piIFAll (int isIfX) {
  int defined = 1;
  int ooo = lblOptMakeU2;
  lblOptMakeU2 = isIfX ? 1 : 0;
  int32_t cond = getOneExprArg(&defined, NULL);
  lblOptMakeU2 = ooo;
  //
  if (!defined) {
    if (!isIfX) fatal("IF: condition must be defined");
    cond = 0; // for IFX: 0 is there is any undefined label
  }
  if (cond) {
    // ok, do it until ELSE/ELSEIF/ENDIF
    ++ifCount;
    return 1;
  }
  for (;;) {
    int r;
    char *args;
    //
    nextSrcLine(); // skip last instruction
    // skip until ELSE/ELSEIF/ENDIF
    r = ifSkipToEndIfOrElse(0);
    if (r == 0) break; // ENDIF
    if (r == 1) { ++ifCount; break; } // ELSE
    // ELSEIF, do condition
    if ((args = strIsCommand("ELSEIF", curLine)) == NULL) fatal("internal error in conditionals"); // the thing that should not be
    memmove(curLine, args, strlen(args)+1);
    cond = getOneExprArg(&defined, NULL);
    if (!defined) fatal("ELSEIF: condition must be defined");
    if (cond) { ++ifCount; break; } // condition is true
  }
  return 1;
}


static int piIF (void) { return piIFAll(0); }
static int piIFX (void) { return piIFAll(1); }


///////////////////////////////////////////////////////////////////////////////
// macro processor
/*
 * what i did with MACRO is the brain-damaged cheating all the way.
 * first, i will collect the MACRO body and remember it.
 * second, when the macro is used, i will:
 *   * create unique labels for all supplied macro args, each with
 *     number (so IFARG/IFNARG can check the existance)
 *   * insert the whole macro body in place, fixing argument refs
 *   * let the asm play with it
 * another tricky part is 'local labels': i have to change all
 *   '..lbl' references -- generate new label name for it and
 *   replace all refs. and be careful to not touch the strings.
 * this is not the best scheme, but it is fairly simple and it works.
 */
// will be called when parser encounters term starting with '=' or '*'
// first term char will not be skipped
// must return pointer to the first char after expression end
static const char *getValueCB (URExprValue *res, const char *expr, uint16_t addr, int donteval, int *defined, int *error) {
  char name[257], *p = name;
  //
  if (curmacro == NULL) fatal("'=' outside of macro");
  if (*expr++ != '=') fatal("'=' expected!");
  //fprintf(stderr, "GV: [%s]\n", expr);
  //
  expr = strSkipSpaces(expr);
  while (*expr) {
    if (isalnum(*expr) || *expr == '_') {
      if (p-name > 250) fatal("id too long");
      *p++ = *expr++;
      continue;
    }
    break;
  }
  *p = 0;
  expr = strSkipSpaces(expr);
  for (int f = 0; f < curmacro->mac->argc; ++f) {
    if (strcasecmp(name, curmacro->mac->argnames[f]) == 0) {
      if (*expr == '[') {
        URExprValue v;
        int l = strlen(curmacro->argvals[f]);
        //
        ++expr;
        urInitExprValue(&v);
        expr = urExpressionEx(&v, expr, addr, &donteval, defined, error);
        if (*error) return expr;
        if (expr == NULL || *expr != ']' || v.str != NULL) { *error = UR_EXPRERR_FUNC; return expr; }
        ++expr;
        if (v.val < 0) v.val += l;
        if (v.val < 0 || v.val >= l) {
          res->val = '?';
        } else {
          res->val = (unsigned char)(curmacro->argvals[f][v.val]);
        }
        return expr;
      } else {
        urExpressionEx(res, curmacro->argvals[f], addr, &donteval, defined, error);
        //fprintf(stderr, "GV: [%s] [%s] [%d]\n", name, curmacro->argvals[f], res->val);
        return expr;
      }
    }
  }
  fatal("unknown macro variable: '%s'", name);
}


//!0: error; oprlen is opr size (w/o ending 0), it's 255 for now
static int expandCB (char *opr, int oprlen) {
  char name[257], *p = name, *op = opr;
  //
  if (curmacro == NULL) fatal("'=' outside of macro");
  if (*op++ != '=') fatal("'=' expected!");
  //fprintf(stderr, "expand: [%s]\n", opr);
  //fatal("!!!");
  op = strSkipSpaces(op);
  while (*op) {
    if (isalnum(*op) || *op == '_') {
      if (p-name > 250) fatal("id too long");
      *p++ = *op++;
      continue;
    }
    break;
  }
  *p = 0;
  op = strSkipSpaces(op);
  for (int f = 0; f < curmacro->mac->argc; ++f) {
    if (strcasecmp(name, curmacro->mac->argnames[f]) == 0) {
      if (*op == '[') {
        URExprValue v;
        int l = strlen(curmacro->argvals[f]), error = 0, defined = 1, donteval = 0;
        //
        ++op;
        urInitExprValue(&v);
        op = (char *)urExpressionEx(&v, op, pc, &donteval, &defined, &error);
        if (error) return -1;
        if (op == NULL || *op != ']' || v.str != NULL) return -1;
        op = strSkipSpaces(op+1);
        if (*op) return -1;
        if (v.val < 0) v.val += l;
        if (v.val < 0 || v.val >= l) {
          strcpy(opr, "?");
        } else {
          opr[0] = curmacro->argvals[f][v.val];
          opr[1] = 0;
        }
        return 0;
      }
      //
      strncpy(opr, curmacro->argvals[f], oprlen);
      opr[oprlen-1] = 0;
      return (*op ? -1 : 0);
    }
  }
  fatal("unknown macro variable: '%s'", name);
}


static void processMacro (MacroDef *mc) {
  SourceLine *oldcurline = curSrcLine;
  CurMacroDef cm;
  //
  //fprintf(stderr, "processMacro: [%s]\n", mc->name);
  //for (SourceLine *l = mc->lines; l != NULL; l = l->next) fprintf(stderr, "*[%s]\n", l->line);
  //
  //parse macro arguments
  //
  cm.mac = mc;
  for (int f = 0; f < mc->argc; ++f) {
    char *e, ech;
    //
    skipSpaces();
    //
    if (!curLine[0]) {
      for (int c = f; c < mc->argc; ++c) {
        if (mc->argdef[c] == NULL) fatal("macro '%s' has no default value for argument '%s'", mc->name, mc->argnames[c]);
        cm.argvals[c] = strdup(mc->argdef[c]);
      }
      break;
    }
    //
    if (curLine[0] == ',') {
      if (mc->argdef[f] == NULL) fatal("macro '%s' has no default value for argument '%s'", mc->name, mc->argnames[f]);
      cm.argvals[f] = strdup(mc->argdef[f]);
      memmove(curLine, curLine+1, strlen(curLine));
      continue;
    }
    //
    e = skipArg(curLine);
    //fprintf(stderr, "*[%s]\n*[%s]\n", curLine, e);
    if ((ech = *e) != 0) {
      if (f == mc->argc-1 || ech != ',') fatal("invalid macro invocation");
    }
    *e = 0;
    cm.argvals[f] = strdup(curLine);
    if (ech) {
      *e = ech;
      memmove(curLine, e+1, strlen(e));
    } else {
      curLine[0] = 0;
    }
  }
  //
  skipSpaces();
  if (curLine[0]) fatal("invalid macro invocation");
  //
  //for (int f = 0; f < mc->argc; ++f) fprintf(stderr, "%d: [%s]\n", f, cm.argvals[f]);
  //
  setCurSrcLine(mc->lines);
  curmacro = &cm;
  ++curmacronum;
  //
  while (curSrcLine != NULL) {
    //fprintf(stderr, "*[%s]\n", curSrcLine->line);
    processCurrentLine();
  }
  //
  setCurSrcLine(oldcurline);
  curmacro = NULL;
  nextSrcLine();
  //fatal("!!!");
  //return 1;
}


static MacroDef *findMacro (const char *name) {
  for (MacroDef *mc = maclist; mc != NULL; mc = mc->next) if (strcasecmp(name, mc->name) == 0) return mc;
  return NULL;
}


static int piMACRO (void) {
  char *name;
  int argc = 0;
  char *argdef[32];
  char *argnames[32];
  SourceLine *stline, *eline = NULL;
  MacroDef *mc;
  //
  name = strdup(getLabelArg(0));
  //fprintf(stderr, "[%s]\n", name);
  if (findMacro(name) != NULL) fatal("duplicate MACRO definition: '%s'", name);
  if (curLine[0] == ',') memmove(curLine, curLine+1, strlen(curLine));
  skipSpaces();
  //
  while (curLine[0]) {
    if (argc >= 31) fatal("too many arguments in MACRO");
    if (!isalpha(curLine[0])) fatal("invalid MACRO definition");
    //
    argnames[argc] = strdup(getLabelArg(0));
    if (curLine[0] == '=') {
      // default value
      char *e = strchr(curLine, ','), tch;
      //
      if (e == NULL) e = curLine+strlen(curLine);
      tch = *e;
      *e = 0;
      argdef[argc] = strdup(curLine+1);
      *e = tch;
      memmove(curLine, e, strlen(e)+1);
    } else {
      argdef[argc] = NULL;
    }
    skipSpaces();
    if (curLine[0] == ',') {
      memmove(curLine, curLine+1, strlen(curLine));
      skipSpaces();
    }
    //fprintf(stderr, "%d: [%s] [%s]\n", argc, argnames[argc], argdef[argc]);
    ++argc;
  }
  //
  // now find corresponding ENDM
  // note that we should skip nested DUPs
  stline = curSrcLine;
  nextSrcLine(); // skip ourself
  while (curSrcLine) {
    int inum;
    //
    if (!setCurSrcLine(findNextInstructionFromList(&inum, "MACRO", "ENDM", NULL))) break;
    // ok, we found something; what is it?
    if (inum == 0) {
      // new MACRO
      fatal("no nested MACROs yet");
    } else {
      // ENDM, gotcha!
      eline = curSrcLine;
      // kill ENDM
      eline->line[0] = 0;
      nextSrcLine(); // skip ENDM
      break;
    }
  }
  if (!eline) { setCurSrcLine(stline); fatal("no ENDM"); }
  //
  if ((mc = calloc(1, sizeof(*mc))) == NULL) fatal("out of memory");
  mc->name = name;
  mc->argc = argc;
  for (int f = 0; f < argc; ++f) { mc->argdef[f] = argdef[f]; mc->argnames[f] = argnames[f]; }
  //
  /*
  if ((tline = calloc(1, sizeof(*tline))) == NULL) fatal("out of memory");
  tline->next = stline->next;
  tline->line = strdup(stline->line);
  tline->fname = strdup(stline->fname);
  tline->lineNo = stline->lineNo;
  */
  eline->next = NULL;
  mc->lines = stline->next;
  stline->next = curSrcLine;
  stline->line[0] = 0;
  //
  mc->next = maclist;
  maclist = mc;
  //fatal("sorry, no MACRO yet");
  return 1;
}


static int piENDM (void) {
  fatal("ENDM without MACRO");
  return 1;
}


///////////////////////////////////////////////////////////////////////////////
// line processor
static int optWriteType = 't';
static int optWTChanged = 0;


static void piTapParseLoaderName (void) {
  if (skipComma()) {
    int len;
    char *fn;
    //
    if (!isStrArg()) fatal("loader name expected");
    fn = getStrArg(&len);
    if (len > 10) fatal("loader name too long");
    memset(tapeLoaderName, ' ', 10);
    for (int f = 0; f < len; ++f) tapeLoaderName[f] = fn[f];
  }
}


static int piDEFFMT (void) {
  char *name;
  //
  if (isStrArg()) {
    int len = 0;
    //
    name = getStrArg(&len);
  } else {
    name = getLabelArg(1);
  }
  if (optWTChanged) return 1;
  if (!strcasecmp(name, "SNA") || !strcasecmp(name, "RUNSNA")) {
    optRunTape = 0;
    //optRunSNA = (toupper(name[0]) == 'R');
    optWriteType = 's';
    if (curLine[0]) fatal("too many expressions");
    return 1;
  }
  if (!strcasecmp(name, "TAP") || !strcasecmp(name, "TAPE")) {
    optRunTape = 0;
    //optRunSNA = 0;
    optWriteType = 't';
    piTapParseLoaderName();
    return 1;
  }
  if (!strcasecmp(name, "RUNTAP") || !strcasecmp(name, "RUNTAPE")) {
    optRunTape = 1;
    //optRunSNA = 0;
    optWriteType = 't';
    piTapParseLoaderName();
    return 1;
  }
  if (!strcasecmp(name, "BIN") || !strcasecmp(name, "RAW")) {
    optRunTape = 0;
    //optRunSNA = 0;
    optWriteType = 'r';
    if (curLine[0]) fatal("too many expressions");
    return 1;
  }
  if (!strcasecmp(name, "DMB") || !strcasecmp(name, "RUNDMB")) {
    optRunTape = 0;
    //optRunSNA = 0;
    optRunDMB = (toupper(name[0]) == 'R');
    optWriteType = 'd';
    if (curLine[0]) fatal("too many expressions");
    return 1;
  }
  if (!strcasecmp(name, "NONE") || !strcasecmp(name, "NOTHING")) {
    optRunTape = 0;
    //optRunSNA = 0;
    optWriteType = 'n';
    if (curLine[0]) fatal("too many expressions");
    return 1;
  }
  fatal("invalid default output type: %s", name);
}


///////////////////////////////////////////////////////////////////////////////
// line processor
//
static void processCurrentLine (void) {
  if (!curSrcLine) return; // do nothing
  loadCurSrcLine();
  processLabel();
  for (;;) {
    char *str, *ee, name[66];
    UrAsmOp *op;
    int len;
    const char *errpos;
    //
    removeSpacesAndColons();
    // skip spaces and ':'
    if (!curLine[0]) { nextSrcLine(); break; }
    // try to find and process command
    str = curLine; //while (*str && isspace(*str)) ++str; // skip spaces
    // find command end
    for (ee = str; *ee && !isspace(*ee) && *ee != '"' && *ee != '\''; ++ee) ;
    // get command, if any
    if (ee != str && ee-str <= 64) {
      MacroDef *mc;
      //
      memset(name, 0, sizeof(name));
      memmove(name, str, ee-str);
      // known command?
      op = urFindOp(name);
      if (op) {
        // ok, do it
        str = ee; while (*str && isspace(*str)) ++str; // skip spaces
        memmove(curLine, str, strlen(str)+1);
        if (op->fn()) {
          nextSrcLine(); // skip it
          break;
        }
        continue;
      }
      if ((mc = findMacro(name)) != NULL) {
        // ok, do it
        str = ee; while (*str && isspace(*str)) ++str; // skip spaces
        memmove(curLine, str, strlen(str)+1);
        //
        processMacro(mc);
        //FIXME: allow ':' here?
        break;
      }
    }
    //
    len = urAssembleOne(curLine, pc, disp, &errpos);
    if (len < 0) fatalUrLib(len);
    pc += len; disp += len;
    if (len >= 0 && errpos) {
      memmove(curLine, errpos+1, strlen(errpos));
    } else {
      nextSrcLine(); // skip it
      break;
    }
  }
}


///////////////////////////////////////////////////////////////////////////////
// setup instructions
//
static void registerInstructions (void) {
  urAddOp("DISPLAY", piDISPLAY);
  urAddOp("DISPLAY0", piDISPLAY0);
  urAddOp("DISPLAYA", piDISPLAYA);
  urAddOp("DISPHEX", piDISPHEX);
  urAddOp("DISPHEX0", piDISPHEX0);
  urAddOp("DISPHEXA", piDISPHEXA);
  //
  urAddOp("DEFFMT", piDEFFMT);
  //
  urAddOp("MACRO", piMACRO);
  urAddOp("ENDM", piENDM);
  //
  urAddOp("ORG", piORG);
  urAddOp("DISP", piDISP);
  urAddOp("ENDDISP", piENDDISP);
  urAddOp("PHASE", piDISP);
  urAddOp("DEPHASE", piENDDISP);
  urAddOp("UNPHASE", piENDDISP);
  urAddOp("ALIGN", piALIGN);
  urAddOp("DISPALIGN", piDISPALIGN);
  urAddOp("PHASEALIGN", piDISPALIGN);
  urAddOp("ENT", piENT);
  urAddOp("CLR", piCLR);
  urAddOp("RESERVE", piRESERVE);
  //
  urAddOp("INCBIN", piINCBIN);
  //
  urAddOp("MODULE", piMODULE);
  urAddOp("ENDMODULE", piENDMODULE);
  //
  urAddOp("DUP", piDUP);
  urAddOp("EDUP", piEDUP);
  //
  urAddOp("IF", piIF);
  urAddOp("IFX", piIFX);
  urAddOp("ELSE", piELSE);
  urAddOp("ELSEIF", piELSEIF);
  urAddOp("ELSEIFX", piELSEIF);
  urAddOp("ENDIF", piENDIF);
  //
  urAddOp("DEFINCR", piDEFINCR);
  urAddOp("DEFB", piDEFB); urAddOp("DB", piDEFB);
  urAddOp("DEFW", piDEFW); urAddOp("DW", piDEFW);
  urAddOp("DEFR", piDEFR); urAddOp("DR", piDEFR);
  urAddOp("DEFS", piDEFS); urAddOp("DS", piDEFS);
  urAddOp("DEFM", piDEFM); urAddOp("DM", piDEFM);
  urAddOp("DEFZ", piDEFZ); urAddOp("DZ", piDEFZ);
  urAddOp("DEFX", piDEFX); urAddOp("DX", piDEFX);
  urAddOp("DEFC", piDEFC); urAddOp("DC", piDEFC);
}


///////////////////////////////////////////////////////////////////////////////
// !0: invalid label
/*
static inline void fnSkipSpaces (const char *expr) {
  while (*expr && isspace(*expr)) ++expr;
  return expr;
}
*/


static inline char fnNextChar (const char *expr) {
  while (*expr && isspace(*expr)) ++expr;
  return *expr;
}


#define FN_CHECK_END  do { \
  while (*expr && isspace(*expr)) ++expr; \
  if (expr[0] != ')') { *error = UR_EXPRERR_FUNC; return expr; } \
  ++expr; \
} while (0)


#define FN_CHECK_COMMA  do { \
  while (*expr && isspace(*expr)) ++expr; \
  if (expr[0] != ',') { *error = UR_EXPRERR_FUNC; return expr; } \
  ++expr; \
} while (0)


static const char *readLabelName (char *buf, const char *expr) {
  int pos = 0;
  //
  while (*expr && isspace(*expr)) ++expr;
  for (;;) {
    char ch = *expr++;
    //
    if (pos >= 128) return NULL;
    if (!ch) break;
    if (isalnum(ch) || ch == '$' || ch == '.' || ch == '_' || ch == '@') {
      buf[pos++] = ch;
    } else {
      break;
    }
  }
  if (pos < 1) return NULL;
  buf[pos] = '\0';
  if (!urIsValidLabelName(buf)) return NULL;
  return expr;
}


static const char *fnDefKn (URExprValue *res, const char *expr, uint16_t addr, int donteval, int *defined, int *error, int qtype) {
  char lbl[130];
  //
  if ((expr = readLabelName(lbl, expr)) == NULL) { *error = UR_EXPRERR_LABEL; return NULL; }
  FN_CHECK_END;
  if (!donteval) res->val = (isLabelDefinedOrKnown(lbl, addr, qtype) != 0);
  return expr;
}

static const char *fnDefined (URExprValue *res, const char *expr, uint16_t addr, int donteval, int *defined, int *error) { return fnDefKn(res, expr, addr, donteval, defined, error, UR_QTYPE_DEFINED); }
static const char *fnKnown (URExprValue *res, const char *expr, uint16_t addr, int donteval, int *defined, int *error) { return fnDefKn(res, expr, addr, donteval, defined, error, UR_QTYPE_KNOWN); }


static const char *fnAligned256 (URExprValue *res, const char *expr, uint16_t addr, int donteval, int *defined, int *error) {
  expr = urExpressionEx(res, expr, addr, &donteval, defined, error);
  FN_CHECK_END;
  if (!donteval) res->val = (res->val%256 ? 0 : 1);
  return expr;
}


static const char *fnSameSeg (URExprValue *res, const char *expr, uint16_t addr, int donteval, int *defined, int *error) {
  URExprValue v0, v1;
  //
  urInitExprValue(&v0);
  urInitExprValue(&v1);
  expr = urExpressionEx(&v0, expr, addr, &donteval, defined, error);
  if (*error) return expr;
  FN_CHECK_COMMA;
  expr = urExpressionEx(&v1, expr, addr, &donteval, defined, error);
  if (*error) return expr;
  FN_CHECK_END;
  if (!donteval) res->val = (v0.val/256 == v1.val/256);
  return expr;
}


static const char *fnAlign (URExprValue *res, const char *expr, uint16_t addr, int donteval, int *defined, int *error) {
  URExprValue v0, v1;
  //
  urInitExprValue(&v0);
  urInitExprValue(&v1);
  expr = urExpressionEx(&v0, expr, addr, &donteval, defined, error);
  if (*error) return expr;
  if (fnNextChar(expr) == ',') {
    FN_CHECK_COMMA;
    expr = urExpressionEx(&v1, expr, addr, &donteval, defined, error);
    if (*error) return expr;
  } else {
    v1.val = 256;
  }
  FN_CHECK_END;
  if (!donteval) {
    if (v1.val < 1) { *error = UR_EXPRERR_FUNC; return NULL; }
    res->val = (v0.val+v1.val-1)/v1.val*v1.val;
  }
  return expr;
}


static const char *fnLow (URExprValue *res, const char *expr, uint16_t addr, int donteval, int *defined, int *error) {
  const char *ee = expr;
  //
  expr = urExpressionEx(res, expr, addr, &donteval, defined, error);
  FN_CHECK_END;
  if (!donteval) {
    if (res->fixuptype == UR_FIXUP_HIBYTE) {
      *error = UR_EXPRERR_FUNC; return ee;
    }
    res->fixuptype = UR_FIXUP_LOBYTE;
    res->val &= 0xff;
  }
  return expr;
}


static const char *fnHigh (URExprValue *res, const char *expr, uint16_t addr, int donteval, int *defined, int *error) {
  const char *ee = expr;
  //
  expr = urExpressionEx(res, expr, addr, &donteval, defined, error);
  FN_CHECK_END;
  if (!donteval) {
    if (res->fixuptype == UR_FIXUP_LOBYTE) {
      *error = UR_EXPRERR_FUNC; return ee;
    }
    res->fixuptype = UR_FIXUP_HIBYTE;
    res->val = (res->val>>8)&0xff;
  }
  return expr;
}


static void registerFunctions (void) {
  urExpressionRegisterFunction("defined", fnDefined);
  urExpressionRegisterFunction("known", fnKnown);
  urExpressionRegisterFunction("aligned256", fnAligned256);
  urExpressionRegisterFunction("align", fnAlign);
  urExpressionRegisterFunction("sameseg", fnSameSeg);
  urExpressionRegisterFunction("low", fnLow);
  urExpressionRegisterFunction("high", fnHigh);
}


///////////////////////////////////////////////////////////////////////////////
// preparing another pass
//
static void initPass (void) {
  curSrcLine = asmText;
  curModule = NULL;
  pc = disp = ent = 0x100; // viva CP/M!
  inTapeBlock = 0;
  tapeXorB = 0;
  wasOrg = 0;
  wasClr = 0;
  ifCount = 0;
  defIncr = 0;
  lblOptMakeU2 = 0;
  curmacronum = 0;
  lastSeenGlobalLabel = strdup(" [MAIN] ");
  modulesResetSeen();
  prepareMemory();
}


static int posstPass (void) {
  if (lastSeenGlobalLabel) free(lastSeenGlobalLabel); lastSeenGlobalLabel = NULL;
  if (checkLabels()) return -1;
  if (ifCount != 0) fatal("unbalanced IFs");
  return 0;
}


///////////////////////////////////////////////////////////////////////////////
// options
//
static struct option longOpts[] = {
  {"sna", 0, NULL, 's'},
  {"sna128", 0, NULL, 'S'},
  {"tap", 0, NULL, 't'},
  {"autotap", 0, NULL, 'T'},
  /*{"rawtap", 0, NULL, 'T'},*/
  {"raw", 0, NULL, 'r'},
  {"autodmb", 0, NULL, 'B'},
  {"dmb", 0, NULL, 'b'},
  {"none", 0, NULL, 'n'},
  {"help", 0, NULL, 'h'},
  {"hob", 0, NULL, 'H'},
  {"fixups", 0, NULL, 'H'},
  {NULL, 0, NULL, 0}
};


static const char *defInFiles[] = {"main.zas", "main.a80", "main.asm", NULL};


static void usage (const char *pname) {
  printf(
    "usage: %s [options] infile\n"
    "default infiles:", pname);
  for (int f = 0; defInFiles[f]; ++f) printf(" %s", defInFiles[f]);
  printf("\n"
    "options:\n"
    " -s --sna      write 48K .SNA file with autostart\n"
    " -S --sna128   write 148K .SNA file with autostart\n"
    " -t --tap      write .tap file\n"
    " -T --autotap  write .tap file with basic loader (CLR to set CLEAR)\n"
    " -r --raw      write raw file(s)\n"
    " -b --dmb      write DMB file\n"
    " -B --autodmb  write DMB file with autostart\n"
    " -H --hob      write HoBeta code file(s)\n"
    " -n --none     write nothing\n"
    " -F --fixups   write fixup file 'zfixuptable.txt'\n"
    " -h --help     this help\n");
}


///////////////////////////////////////////////////////////////////////////////
// main
//
int main (int argc, char *argv[]) {
  int res = 0, c;
  const char *pname = argv[0];
  char *inFile = NULL;
  initInclideDir();
  //
  urGetByteFn = getByte;
  urPutByteFn = putByte;
  urFindLabelByNameFn = findLabelCB;
  urGetValueFn = getValueCB;
  urExpandFn = expandCB;
  //urIsLabelDefinedOrKnownFn = isLabelDefinedOrKnown;
  urAsmFixupOperandFn = fixupOperandCB;
  //
  //strcpy(tapeLoaderName, "cargador  ");
  tapeLoaderName[0] = 0;
  //
  printf("urasm v%d.%d.%d, compile date: %s %s\n", VERSION_HI, VERSION_MID, VERSION_LO, __DATE__, __TIME__);
  while ((c = getopt_long(argc, argv, "sStTbBrnhHF", longOpts, NULL)) >= 0) {
    switch (c) {
      case 'S': /*optRunSNA = 1;*/ optSNA48 = 0; optWriteType = 's'; optWTChanged = 1; break;
      case 's': /*optRunSNA = 0;*/ optSNA48 = 1; optWriteType = 's'; optWTChanged = 1; break;
      case 'T': optRunTape = 1; optWriteType = 't'; optWTChanged = 1; break;
      case 't': optRunTape = 0; optWriteType = 't'; optWTChanged = 1; break;
      case 'b': optRunTape = 0; optRunDMB = 0; optWriteType = 'd'; optWTChanged = 1; break;
      case 'B': optRunTape = 0; optRunDMB = 1; optWriteType = 'd'; optWTChanged = 1; break;
      case 'H': optWriteType = 'H'; optWTChanged = 1; break;
      case 'r': case 'n': optWriteType = c; optWTChanged = 1; break;
      case 'h': usage(pname); res = 0; goto earlyerrquit;
      case 'F': optWriteFixups = 1; break;
      case '?': return 1;
    }
  }
  if (optind >= argc) {
    // try to find default input file
    int f;
    for (f = 0; defInFiles[f]; ++f) {
      if (!access(defInFiles[f], R_OK)) {
        inFile = strdup(defInFiles[f]);
        break;
      }
    }
  } else {
    inFile = strdup(argv[optind]);
  }
  if (!inFile || !inFile[0]) {
    res = 1;
    fprintf(stderr, "ERROR: no input file!\n");
    goto earlyerrquit;
  }
  //
  registerInstructions();
  registerFunctions();
  //
  res = asmTextLoad(inFile);
  if (!res) {
/*
    printf("dumping...\n");
    FILE *fo = fopen("z000.out", "w");
    if (fo) {
      SourceLine *c;
      for (c = asmText; c; c = c->next) fprintf(fo, "%s  ; %s: %d\n", c->line, c->fname, c->lineNo);
      fclose(fo);
    }
*/
    for (pass = 0; pass <= 1; ++pass) {
      initPass();
      printf("pass %d\n", pass);
      setCurSrcLine(asmText);
      if (setjmp(errJP)) { res = 1; break; }
      while (curSrcLine) processCurrentLine();
      if (posstPass()) { res = 1; break; }
    }
    // write result
    if (res == 0) {
      char *oc = strdup(inFile);
      char *pd = strrchr(oc, '.');
      if (pd && !strchr(oc, '/')) *pd = '\0';
      switch (optWriteType) {
        case 's': saveSna(oc, optSNA48); break;
        case 't': saveTap(oc); break;
        case 'r': saveRaw(oc); break;
        case 'd': saveDMB(oc); break;
        case 'H': saveHob(oc); break;
      }
      free(oc);
      if (optWriteFixups) writeFixups();
    }
  } else {
    fprintf(stderr, "ERROR: loading error!\n");
  }
  //
  if (lastSeenGlobalLabel) free(lastSeenGlobalLabel);
  clearFixups();
  urClearLabels();
  modulesClear();
  asmTextClear();
  urClearOps();
earlyerrquit:
  if (inFile) free(inFile);
  if (sysIncludeDir) free(sysIncludeDir);
  return res?1:0;
}