/* ------------------------------------------------------------------------- */
/*   "asm" : The Inform assembler                                            */
/*                                                                           */
/*   Part of Inform release 5                                                */
/* ------------------------------------------------------------------------- */

#include "header.h"

int in_routine_flag, no_stubbed;

int ignoring_routine;

int return_flag;
static int stub_flags[32];

static int lower_strings_flag=0;

static int ifdef_stack[MAX_IFDEF_DEPTH];
static int ifdef_sp=0;
static int started_ignoring=0;

#ifndef ALLOCATE_BIG_ARRAYS
  static long int pa_forwards[MAX_FORWARD_REFS];
#else
  static long int *pa_forwards;
#endif

extern void asm_allocate_arrays(void)
{
#ifdef ALLOCATE_BIG_ARRAYS
    pa_forwards = (long int *) my_calloc(sizeof(long int),   MAX_FORWARD_REFS,
                  "forward references");
#endif
}

extern void asm_free_arrays(void)
{   
#ifdef ALLOCATE_BIG_ARRAYS
    my_free(&pa_forwards, "forward references");
#endif
}

/* ------------------------------------------------------------------------- */
/*   Decode arguments as constants and variables                             */
/*   (Gratuitous Space:1999 reference by Mr Dilip Sequeira of Edinburgh      */
/*   University)                                                             */
/* ------------------------------------------------------------------------- */

static int constant_was_string;

extern int32 constant_value(char *b)
{   int32 i, j, k, action_flag=0, rv, base=10, moon, alpha, victor=0, eagle;

    constant_was_string=0;
    if (b[0]=='#') b++;

    if (b[0]=='\'')
    {   if ((b[2]=='\'') && (b[3]==0)) return(translate_to_ascii(b[1]));
        i=strlen(b);
        if ((i>=4)&&(b[i-1]=='\''))
        {   b[i-1]=0; rv=dictionary_add(b+1,0x80,0,0); return(rv);
        }
    }
    if (b[0]=='#')
    {   i=find_symbol(b+1);
        if ((i>=0)&&(stypes[i]==18)) return(svals[i]);
        if (strlen(b)>60)
        {   error_named("Action name over 60 characters long:",b);
            return(0);
        }
        sprintf(b+strlen(b),"Sub");
        action_flag=1; b++; goto actionfound;

    }
    if (b[0]=='\"') goto stringfound;

    if (*b=='$')
    {   if (*++b=='$') { b++; base=2; }
        else base=16;
    }
    else if (*b=='-')  { b++; victor=1; }
    else if (b[1]=='$') goto dollarform;
    else for (i=0; b[i]; i++) if (!isdigit(b[i])) goto nonumber;

    for(moon=0;*b;b++) 
    {  alpha=isalpha(*b)?(tolower(*b)-'a'+10):*b-'0';
       if(alpha>=base || alpha<0) break; else moon=moon*base+alpha;
    }
    if (victor==0) return(moon);
    eagle=((int32) 0x10000L)-moon;
    return(eagle);

  dollarform:
    switch(b[0])
    {   case 'a':
            obsolete_warning("'#a$Action' is now superceded by '##Action'");
            b+=2; action_flag=1; goto actionfound;
        case 'w':
            obsolete_warning("'#w$word' is now superceded by ''word''");
            k=dictionary_find(b+2,2);
            rv=dictionary_offset+7+((version_number==3)?7:9)*(k-1);
            if ((k==0)&&(pass_number==2))
                error_named("Dictionary word not found for constant",b);
            return(rv);
        case 'n':
            if (strlen(b)>3)
                obsolete_warning("'#n$word' is now superceded by ''word''");
            rv=dictionary_add(b+2,0x80,0,0); return(rv);
        case 'r':
            i=find_symbol(b+2);
            if ((i<0)||(stypes[i]!=1))
            {   if (pass_number==2)
                    error_named("No such routine as",b);
                return(256);
            }
            rv=svals[i]; goto constantfound;
    }
    error_named("There is no such # constant form as",b);
    return(0);

  nonumber:

    for (j=0,i=0; b[i]; i++) if (b[i]=='_') j=1;

    if (j==1)
    {   if (strcmp(b,"adjectives_table")==0) return(adjectives_offset);
        if (strcmp(b,"preactions_table")==0) return(preactions_offset);
        if (strcmp(b,"actions_table")==0) return(actions_offset);
        if (strcmp(b,"version_number")==0) return(actual_version);
        if (strcmp(b,"largest_object")==0) return(256+max_no_objects-1);
        if (strcmp(b,"strings_offset")==0) return(strings_offset/scale_factor);
        if (strcmp(b,"code_offset")==0) return(code_offset/scale_factor);
        if (strcmp(b,"dict_par1")==0) return((version_number==3)?4:6);
        if (strcmp(b,"dict_par2")==0) return((version_number==3)?5:7);
        if (strcmp(b,"dict_par3")==0) return((version_number==3)?6:8);
    }

  actionfound:
    i=find_symbol(b);
    if (i<0)
    {   if (pass_number==2)
        {   if (action_flag==1)
                error_named("No such action routine as",b);
            else
                error_named("No such constant as",b);
        }
        return(0);
    }
    rv=svals[i];

  constantfound:
    switch(stypes[i])
    {   case 1: rv=(rv+code_offset)/scale_factor;
                break;
        case 2:
        case 3: error_named("Not a constant:",b); return(0);
        case 4:
        case 10: error_named("Reserved word as constant:",b); return(0);
    }
    if (action_flag==0) return(rv);
    j=find_action(svals[i]);
    return(j);

  stringfound:

    dequote_text(b);
    constant_was_string=1;

    if (lower_strings_flag==1)
    {   j=subtract_pointers(low_strings_p,low_strings);
        low_strings_p=translate_text(low_strings_p,b);
        i= subtract_pointers(low_strings_p,low_strings);
        if (i>MAX_LOW_STRINGS)
            memoryerror("MAX_LOW_STRINGS", MAX_LOW_STRINGS);
        return(0x21+(j/2));
    }

    j= subtract_pointers(strings_p,strings);

#ifdef USE_TEMPORARY_FILES
    {   zip *c;
        c=translate_text(strings,b);
        i=subtract_pointers(c,strings);
        strings_p+=i;
        if (pass_number==2)
            for (c=strings; c<strings+i; c++)
            {   fputc(*c,Temp1_fp); add_to_checksum((void *) c);
            }
    }
#else
    strings_p=translate_text(strings_p,b);
    i=subtract_pointers(strings_p,strings);
    if (i>MAX_STATIC_STRINGS)
        memoryerror("MAX_STATIC_STRINGS",MAX_STATIC_STRINGS);
#endif

    while ((i%scale_factor)!=0)
    {   i+=2;
#ifdef USE_TEMPORARY_FILES
        strings_p+=2;
        if (pass_number==2) { fputc(0,Temp1_fp); fputc(0,Temp1_fp); }
#else
        *(strings_p++)=0; *(strings_p++)=0;
#endif
    }

    return((strings_offset+j)/scale_factor);
}

/* ------------------------------------------------------------------------- */
/*   parse_argument returns: 1000+n   Constant value n                       */
/*                                    long_form_flag set if long form vital  */
/*                                n   Variable n                             */
/* ------------------------------------------------------------------------- */

static char known_unknowns[MAX_IDENTIFIER_LENGTH*16];
static int  no_knowns;

static long int pa_id;
static int pa_ref;
static int max_pa_ref;
static int long_form_flag;

static char one_letter_locals[16];

extern void args_begin_pass(void)
{   if (pass_number==2) max_pa_ref=pa_ref;
    pa_ref=0; pa_id=0;
}

static int32 parse_argument(char *b)
{   int i, j, flag=0;
    long_form_flag=0;
    i=b[0];
    if (b[1]==0)
    {   for (j=0;j<16;j++)
            if (i==one_letter_locals[j])
            {   used_local_variable[j]=1;
                return(j+1);
            }
        if (i=='0') return(1000);
        if (i=='1') return(1001);
        if (i=='2') return(1002);
        if (i=='3') return(1003);
        if (i=='4') return(1004);
        if (i=='5') return(1005);
        if (i=='6') return(1006);
        if (i=='7') return(1007);
        if (i=='8') return(1008);
        if (i=='9') return(1009);
    }
    if ((i=='#')||(i=='-')||(i=='$')||(i=='\"')||(i=='\''))
        return(1000+constant_value(b));
    for (i=0; b[i]!=0; i++)
        if (isdigit(b[i])==0) { flag=1; break; }
    if (flag==0) return(1000+constant_value(b));
    if (in_routine_flag==1)
    {   i=local_find_symbol(b);
        if (i>=0) return(1+svals[i]);
    }
    pa_id++;

    i=find_symbol(b);
    if (i>=0)
    {   switch(stypes[i])
        {   case 1: return(1000+svals[i]);
            case 2: return(16+svals[i]);
            case 4: if (svals[i]==0) return(0);
            case 7:
            case 12:
            case 13:
            case 18:
            case 8:
            case 11:
            case 9: if (pass_number==2)
                    {   while ((pa_ref<max_pa_ref)
                           &&(pa_id>pa_forwards[pa_ref])) pa_ref++;
                        if ((pa_ref<max_pa_ref)
                            &&(pa_id==pa_forwards[pa_ref]))
                        {  long_form_flag=1;
/*  printf("'%s' ref %d id %d seems forward\n",b,pa_ref, pa_id); */
                        }
                    }
                    return(1000+constant_value(b));
            default: error_named("Type mismatch in argument",b);
              return(0);
        }
    }

    if (pass_number==1)
    {   if (pa_ref==MAX_FORWARD_REFS)
            memoryerror("MAX_FORWARD_REFS", MAX_FORWARD_REFS);
        pa_forwards[pa_ref++]=pa_id;
/*  printf("'%s' ref %d id %d is forward\n",b,pa_ref, pa_id); */
        return(1256);
    }

    for (i=0; i<no_knowns; i++)
        if (strcmp(known_unknowns+i*MAX_IDENTIFIER_LENGTH,b)==0)
            return(0);
    if (no_knowns<16)
        strcpy(known_unknowns+(no_knowns++)*MAX_IDENTIFIER_LENGTH,b);
    error_named("No such variable as",b); return(0);
}

/* ------------------------------------------------------------------------- */
/*   Assembler of individual lines                                           */
/* ------------------------------------------------------------------------- */

static void byteout(int32 i)
{   *zcode_p=(unsigned char) i; zcode_p++;
#ifdef USE_TEMPORARY_FILES
    utf_zcode_p++;
#endif
    if (subtract_pointers(zcode_p,zcode) >= MAX_ZCODE_SIZE)
    {   memoryerror("MAX_ZCODE_SIZE",MAX_ZCODE_SIZE);
    }
}

static void write_operand(operand_t op)
{   int32 j;
    j=op.value;
    if (op.type!=0) byteout(j);
    else { byteout(j/256); byteout(j%256); }
}

static operand_t parse_operand(int32 number, opcode opco, char *b)
{   int32 j; int opt, type=opco.type1; operand_t oper;

    word(b,number+2);

    if (((type==CALL)||(type==NCALL))&&(number==0))
    {   if (pass_number==2)
        {   
            j=find_symbol(b);
            if (j==-1) no_such_label(b);
            else if (stypes[j]!=1) error_named("Not a label:",b);
            else oper.value=(code_offset+svals[j])/scale_factor;
            oper.type=0;
        }
        else
        {   oper.value=0x1000; oper.type=0;
        }
        return(oper);
    }

         if ((b[0]=='s')&&(b[1]=='p')&&(b[2]==0)) j=0;
    else j=parse_argument(b);

    if (j>=1256) { opt=0; j=j-1000; }
    else if (j>=1000) { opt=1; j=j-1000; }
    else opt=2;

    if ((opt==1) && (long_form_flag==1)) opt=0;

    if ((opco.type2==VAR)&&(opt==2)&&(number==0)) opt=1;

    oper.value=j; oper.type=opt;
    return(oper);
}

int a_from_one=0;
int line_done_flag = 0;

extern int assemble_opcode(char *b, int32 offset, int internal_number)
{
    zip *opc, *opcname, *ac;
    int32 j, topbits, addr, cargs, ccode, ccode2, oldccode, oldccode2,
          multi, mask, flag, longf, branchword, offset_here;
    operand_t oper1, oper2;
    opcode opco;

    opco = opcs(internal_number);

    if (opco.type1==INVALID)
    {   if (version_number==3)
            warning_named("Ignoring Advanced-game opcode",b);
        else
            warning_named("Ignoring Standard-game opcode",b);
        return(1);
    }
    return_flag=0;
    if ((opco.type1==RETURN) || (opco.type1==JUMP)) return_flag=1;
    if (opco.type1==INDIR)
    {   byteout(0xE0); byteout(0xBF); byteout(0);  byteout(0);
        goto Line_Done;
    }
    opcname=opco.name;
    switch(opco.no)
    {   case MANY:
        case VARI: topbits=0xc0; break;
        case ZERO: topbits=0xb0; break;
        case ONE:  topbits=0x80; break;
        case TWO:  topbits=0x00; break;
    }

    opc=zcode_p;

    if (opco.no!=EXTD)
    {   byteout(topbits+opco.code);
    }
    else
    {   byteout(0xbe); byteout(opco.code); opco.no=VARI;
    }

    if (opco.type1==JUMP)
    {   word(b,2);
        if (pass_number==1) addr=0;
        else
        {   j=find_symbol(b);
            if (j<0) { no_such_label(b); return(1); }
            if ((stypes[j]!=6)&&(stypes[j]!=20))
            { error_named("Not a label:",b); return(1); }
            addr=svals[j]-offset-1;
            if (addr<0) addr+=(int32) 0x10000L;
        }
        byteout(addr/256); byteout(addr%256);
        goto Line_Done;
    }

    if (opco.type2==TEXT)
    {   zip *tmp;
        if (a_from_one==1) textword(b,1); else textword(b,2);
        tmp=zcode_p; zcode_p=translate_text(zcode_p,b);
        j=subtract_pointers(zcode_p,tmp);
#ifdef USE_TEMPORARY_FILES
        utf_zcode_p+=j;  
#endif
        goto Line_Done;
    }

    switch(opco.no)
    {   case VARI:
            ac=zcode_p; byteout(0);
            cargs= -1; ccode=0xff;
            while (word(b,(++cargs)+2),(b[0]!=0))
            {   if (b[0]=='?') { branchword=cargs+2; break; }
                switch(cargs)
                {   case 0: multi=0x40; mask=0xc0; break;
                    case 1: multi=0x10; mask=0x30; break;
                    case 2: multi=0x04; mask=0x0c; break;
                    case 3: multi=0x01; mask=0x03; break;
                    case 4: multi=0;
                            if ((opco.type1!=CALL)&&(opco.type1!=STORE))
                                error("Too many arguments");
                            break;
                    default: error("Too many arguments"); break;
                }

                oper1=parse_operand(cargs, opco, b);

                write_operand(oper1);
                oldccode=ccode; ccode = (ccode & (~mask)) + oper1.type*multi;
            }
            if ((opco.type1==CALL)||(opco.type1==STORE))
            {   if (oper1.type!=2)
                { error("Can't store to that (no such variable)"); }
                *ac=oldccode;
            }
            else *ac=ccode;
            break;
        case MANY:
            ac=zcode_p; byteout(0); byteout(0);
            cargs= -1; ccode=0xff; ccode2=0xff;
            while (word(b,(++cargs)+2),(b[0]!=0))
            {   if (b[0]=='?') { branchword=cargs+2; break; }
                switch(cargs)
                {   case 0: case 4: multi=0x40; mask=0xc0; break;
                    case 1: case 5: multi=0x10; mask=0x30; break;
                    case 2: case 6: multi=0x04; mask=0x0c; break;
                    case 3: case 7: multi=0x01; mask=0x03; break;
                    case 8: multi=0;
                            if ((opco.type1!=CALL)&&(opco.type1!=STORE))
                                error("Too many arguments");
                            break;
                    default: error("Too many arguments"); break;
                }

                oper1=parse_operand(cargs, opco, b);

                write_operand(oper1);
                oldccode=ccode; oldccode2=ccode2;
                if (cargs<4)
                    ccode = (ccode & (~mask)) + oper1.type*multi;
                else
                    ccode2 = (ccode2 & (~mask)) + oper1.type*multi;
            }
            if ((opco.type1==CALL)||(opco.type1==STORE))
            {   if (oper1.type!=2)
                { error("Can't store to that (no such variable)"); }
                *ac=oldccode; *(ac+1)=oldccode2;
            }
            else { *ac=ccode; *(ac+1)=ccode2; }
            break;
        case ONE:
            oper1=parse_operand(0,opco,b);
            *opc=(*opc) + oper1.type*0x10;
            write_operand(oper1);
            break;
        case TWO:
            oper1=parse_operand(0,opco,b);
            oper2=parse_operand(1,opco,b);

            if ((oper1.type==0)||(oper2.type==0))
            {   *opc=(*opc) + 0xc0;
                byteout(oper1.type*0x40 + oper2.type*0x10 + 0x0f);
            }
            else
            {   if (oper1.type==2) *opc=(*opc) + 0x40;
                if (oper2.type==2) *opc=(*opc) + 0x20;
            }
            write_operand(oper1);
            write_operand(oper2);
            break;                    
        case ZERO:
            break;
    }

    if ((opco.no==ONE) || (opco.no==TWO))
    {   if ((opco.type1==STORE)||(opco.type1==CALL))
        {   if (opco.no==ONE) oper1=parse_operand(1,opco,b);
            if (opco.no==TWO) oper1=parse_operand(2,opco,b);
            if (oper1.type!=2)
            { error("Can't store to that (no such variable)"); }
            byteout(oper1.value);
        }
    }

    if ((opco.type1==BRANCH)||(opco.type2==OBJECT))
    {   int o=0; int32 pca;
        pca= subtract_pointers(zcode_p,opc) -1;
        switch(opco.no)
        {   case ZERO: word(b,2); break;
            case ONE:  if (opco.type2!=OBJECT) { word(b,3); break; }
            case TWO:  word(b,4); break;
            case VARI: word(b,branchword); break;
        }
        if (b[0]=='?') { longf=1; o++; }
        else
        {   int o2=0;
            if (b[0]=='~') o2=1;
            if (pass_number==1)
            {   j=find_symbol(b+o2);
                if (j<0) longf=0;
                else longf=1;
            }
            else
            {   j=find_symbol(b+o2);
                if (j<0) longf=0;
                else
                {   if (offset-svals[j]>0) longf=1;
                    else longf=0;
                    if ((svals[j]-offset-pca)>30)
                    { error("Branch too far forward: use '?'"); return(1); }
                }
            }
        }
        /* printf("Branch at %04x has longf=%d\n",offset,longf);  */
        if (pass_number==1) { byteout(0); if (longf==1) byteout(0); }
        else
        {   if (b[o]=='~') { flag=0; o++; } else flag=1;
            j=find_symbol(b+o);
            if (j<0) { no_such_label(b+o); return(1); }
            switch(stypes[j])
            {   case 4:
                  switch(svals[j])
                  {   case 1: addr=1; longf=0; break;
                      case 2: addr=0x20; longf=0; break;
                      default: error("No such return condition for branch");
                               return(1);
                  }
                  break;
                case 1: error("Can't branch to a routine, only to a label");
                        return(1);
                case 6:
                case 20:
                  if (longf==1) pca++;
                  addr=svals[j]-offset-pca;
                  if (addr<0) addr+=(int32) 0x10000L; break;
                default: error_named("Not a label:",b+o); return(1);
            }
            addr=addr&0x3fff;
            if (longf==1)
            {   byteout(flag*0x80 + addr/256); byteout(addr%256); }
            else
                byteout(flag*0x80+ 0x40 + (addr&0x3f));
        }
    }

    Line_Done:

    if (trace_mode==1)
    {   printf("%04d %05lx  %-14s  ", current_source_line(),
            ((long int) offset)+((long int) code_offset),opcname);
        for (j=0;opc<zcode_p; j++, opc++)
        {   printf("%02x ", *opc);
            if (j%16==15) printf("\n                           ");
        }
        printf("\n");
    }

    if ((debugging_file==1)&&(pass_number==2)
        &&(line_done_flag==0))
    {   debug_pass=2; line_done_flag=1;
        write_debug_byte(10); write_debug_linenum();
        offset_here = offset+code_offset;
        write_debug_byte((int)((offset_here/256)/256));
        write_debug_byte((int)((offset_here/256)%256));
        write_debug_byte((int)(offset_here%256));
        debug_pass=1;
    }

#ifdef USE_TEMPORARY_FILES
      {
        zip *c;
        int32 i;
        i= subtract_pointers(zcode_p,zcode);
        if (pass_number==2)
        {   for (c=zcode; c<zcode+i; c++)
            {   fputc(*c,Temp2_fp);
                add_to_checksum((void *) c);
            }
        }
        zcode_p=zcode;
      }
#endif

    return(1);
}

/* ------------------------------------------------------------------------- */
/*   Making attributes and properties (incorporating "alias" code suggested  */
/*   by Art Dyer)                                                            */
/* ------------------------------------------------------------------------- */

static void trace_s(char *name, int32 code, int f)
{   if (debugging_file==1)
    {   write_debug_byte(5+f); write_debug_byte((int)code);
        write_debug_string(name);
    }
    if ((printprops_mode==0)||(pass_number==2)) return;
    printf("%s  %02ld  ",(f==0)?"Attr":"Prop",(long int) code);
    if (f==0) printf("  ");
    else      printf("%s%s",(prop_longflag[code]==1)?"L":" ",
                            (prop_additive[code]==1)?"A":" ");
    printf("  %s\n",name);
}

static void make_attribute(char *b)
{   int i;

    word(b,3);
    if (strcmp(b,"alias")==0)
    {   
        word(b,4);
        if (b[0]==0)
        {   error("Expected an attribute name after 'alias'");
            return;
        }
        if (((i=find_symbol(b))==-1)||(stypes[i]!=7))
        {   error_named("'alias' refers to undefined attribute",b);
            return;
        }
        word(b,2);
        trace_s(b,svals[i],0);
        new_symbol(b,svals[i],7);
        return;
    }
    InV3
    {   if (no_attributes==32)
        {   error("All 32 attributes already declared (compile as Advanced \
game to get an extra 16)"); return; }
    }
    InV5
    {   if (no_attributes==48)
        {   error("All 48 attributes already declared"); return; }
    }
    word(b,2);
    trace_s(b,no_attributes,0);
    new_symbol(b,no_attributes++,7);
    return;
}

static void make_property(char *b)
{   int32 def=0;
    int i, fl, addflag=0;

    fl=2;
    do
    {   word(b,fl++);
        if (strcmp(b,"long")==0)
            obsolete_warning("all properties are now automatically 'long'");
        else if (strcmp(b,"additive")==0) addflag=1;
        else break;
    } while (1==1);

    word(b,fl);
    if (strcmp(b,"alias")==0)
    {   if (addflag)
        {   error("'alias' incompatible with 'additive'"); return; }
        word(b,4);
        if (b[0]==0)
        {   error("Expected a property name after 'alias'"); return; }
        i=find_symbol(b);
        if (((i=find_symbol(b))==-1)||(stypes[i]!=12))
        {   error_named("'alias' refers to undefined property",b);
            return;
        }
        word(b,2);
        trace_s(b,svals[i],1);
        new_symbol(b,svals[i],12);
        return;
    }
    InV3
    {   if (no_properties==32)
        { error("All 30 properties already declared (compile as Advanced \
game to get an extra 32)"); return; }
    }
    InV5
    {   if (no_properties==64)
        { error("All 62 properties already declared"); return; }
    }
    if (b[0]!=0) def=constant_value(b);
    word(b,fl-1);
    prop_defaults[no_properties]=def;
    InV3 { prop_longflag[no_properties]=1; }
    InV5 { prop_longflag[no_properties]=1; }
    prop_additive[no_properties]=addflag;
    trace_s(b,no_properties,1);
    new_symbol(b,no_properties++,12);
    return;
}

static void make_fake_action(char *b)
{   int i;
    i=256+no_fake_actions++;
    word(b,2);
    new_symbol(b,i,18);
    new_action(b,i);
    if (debugging_file==1)
    {   write_debug_byte(7); write_debug_byte(i);
        write_debug_string(b);
    }
    return;
}

/* ------------------------------------------------------------------------- */
/*   Assembler directives: for diagnosis, and making the non-code part of    */
/*     the file                                                              */
/* ------------------------------------------------------------------------- */

static int lmoved_flag=0;

extern void assemble_label(int32 offset, char *b)
{   int i;
    if (pass_number==1) new_symbol(b,offset,6);
    else
    {   i=find_symbol(b);
        if ((stypes[i]==6)&&(svals[i]!=offset))
            if (lmoved_flag==0)
            {   lmoved_flag=1;
                if (no_errors==0)
    error("An error has occurred just before this point \
with what Inform thought was a constant.  Perhaps it was a global \
variable used before its definition in the code.");
            }
    }
    if (trace_mode==1) printf(".%s\n",b);
    return_flag=0;
}

static void stack_sline(char *s1, char *b)
{   char rw[100];
    sprintf(rw,s1,b); stack_line(rw);
}

static int constant_made_flag = 0;

extern void assemble_directive(char *b, int32 offset, int32 code)
{   int i, j, condition=0, debugged_routine; int32 k;

  switch(code)
  { 
    case IFDEF_CODE:
        word(b,2);
        if ((b[0]=='V')&&(b[1]=='N')&&(b[2]=='_')&&(strlen(b)==7))
        {   i=atoi(b+3); if (VNUMBER>=i) condition=1;
            goto generic_if;
        }
        i=find_symbol(b);
        if (i>=0) condition=1;
        goto generic_if;
    case IFNDEF_CODE:
        word(b,2);
        if ((b[0]=='V')&&(b[1]=='N')&&(b[2]=='_')&&(strlen(b)==7))
        {   i=atoi(b+3); if (VNUMBER<i) condition=1;
            goto generic_if;
        }
        i=find_symbol(b);
        if (i==-1) condition=1;
        goto generic_if;
    case IFV3_CODE:
        if (version_number==3) condition=1; goto generic_if;
    case IFV5_CODE:
        if (version_number==5) condition=1; goto generic_if;

    generic_if:

        if (ifdef_sp==MAX_IFDEF_DEPTH)
        { error("'#IF' nested too deeply: increase #define MAX_IFDEF_DEPTH");
          return;
        }
        ifdef_stack[ifdef_sp++]=ignoring_mode;
        if (ignoring_mode==0)
        {   ignoring_mode=1-condition;
            started_ignoring=ifdef_sp;
        }
        return;

    case ENDIF_CODE:
        if (ifdef_sp==0)
        { error("'#ENDIF' without matching '#IF'"); return; }
        ignoring_mode=(ifdef_stack[--ifdef_sp])%2;
        return;

    case IFNOT_CODE:
        if (ifdef_sp==0)
        { error("'#IFNOT' without matching '#IF'"); return; }
        if (ifdef_stack[ifdef_sp-1]>=2)
        { error("Two '#IFNOT's in the same '#IF'"); return; }
        ifdef_stack[ifdef_sp-1]+=2;
        if (ignoring_mode==1)
        {   if (ifdef_sp==started_ignoring)
                ignoring_mode=0;
        }
        else
        {   ignoring_mode=1;
        }
        return;

    case END_CODE:
        endofpass_flag=1;
        if (trace_mode==1) printf("<end>\n");

        if (ifdef_sp>0)
        { error("End of file reached inside '#IF...'"); }
        break;

    case OPENBLOCK_CODE:
        if (is_systemfile()==1)
        {   strcpy(b,"Rep__");
            word(b+5,2);
            i=find_symbol(b);
            if (i!=-1)
            {   ignoring_routine=1; /* printf("Ignoring %s\n",b+5); */ break; }
        }
        word(b,2);
        ignoring_routine=0; debugged_routine=0;
        while ((offset%scale_factor)!=0) { byteout(0); offset++; }
        new_symbol(b,offset,1);
        if (trace_mode==1) printf("<Routine %d, '%s' begins at %04x; ",
          no_routines,b,offset);

        if (debugging_file==1)
        {   debug_pass=2;
            write_debug_byte(11);
            write_debug_byte(no_routines/256);
            write_debug_byte(no_routines%256);
            write_routine_linenum(); write_debug_string(b);
        }

        lose_local_symbols();

        no_locals= -1; no_knowns=0;
        for (i=0;i<16;i++) one_letter_locals[i]='\'';
        routine_starts_line=current_source_line();
        no_routines++;
        if (no_routines>=MAX_ROUTINES)
            memoryerror("MAX_ROUTINES", MAX_ROUTINES);
        in_routine_flag=1; return_flag=0;
        word(b,3); if (strcmp(b,"*")==0) debugged_routine=1;
        while (word(b,(++no_locals)+3+debugged_routine),(b[0]!=0))
        {   if ( ((b[0]==',')&&(b[1]==0)) || ((b[0]==':')&&(b[1]==0)))
            {   error("Expected local variable but found ',' or ':' \
(probably the ';' after the '[ ...' line was forgotten)");
                break;
            }
            if ((b[0]=='s')&&(b[1]=='p')&&(b[2]==0))
            {   error("'sp' means the stack pointer, and can't be used \
as the name of a local variable"); break;
            }
            if (b[1]==0) one_letter_locals[no_locals]=b[0];
            new_symbol(b,no_locals,3);
            if (debugging_file==1) write_debug_string(b);
        }

        if (debugging_file==1) { write_debug_byte(0); debug_pass=1; }
        byteout(no_locals);

        if (actual_version<5)
        {   for (i=0; i<no_locals; i++) { byteout(0); byteout(0); }
        }
        if (trace_mode==1) printf("%d locals>\n",no_locals);
        if (no_locals>15) error("Routine has more than 15 local variables");
        if ((no_routines==1)&&(pass_number==1))
        {   word(b,2); make_lower_case(b);
            if (strcmp(b,"main")!=0)
            {
warning_named("Since it is defined before inclusion of the library, game-play \
will begin not at 'Main' but at the routine",b);
            }
            if (no_locals!=0)
 error("The earliest-defined routine is not allowed to have local variables");
        }
        if (nowarnings_mode==0)
            for (i=0; i<16; i++) used_local_variable[i]=0;

        if ((withdebug_mode==1) || (debugged_routine==1))
        {   word(b,2); sprintf(sub_buffer,"print \"[%s\"",b);
            for (i=0; (i<no_locals)&&(i<3); i++)
            {   word(b, 3+i+debugged_routine);
               sprintf(sub_buffer+strlen(sub_buffer), ", \", %s=\", %s", b, b);
            }
            sprintf(sub_buffer+strlen(sub_buffer), ", \"]^\"");
            stack_line(sub_buffer);
        }
        break;

    case CLOSEBLOCK_CODE:

        word(b,2);
        if (b[0]!=0)
        {   if ((resobj_flag==0) || (strcmp(b,",")!=0))
            {
                if (resobj_flag>0)
                error_named(
                    "Expected ',' or ';' after ']' but found",
                    parse_buffer);
                else
                error_named(
                    "Expected ';' after ']' but found",
                    parse_buffer);
            }
        }

        if (trace_mode==1)  printf("<Routine ends>\n");
        if (debugging_file==1)
        {   debug_pass=2;
            write_debug_byte(14);
            write_debug_byte((no_routines-1)/256);
            write_debug_byte((no_routines-1)%256);
            write_re_linenum(); debug_pass=1;
        }

        if (return_flag==0)
        {   if (resobj_flag==0) stack_line("@rtrue");
                           else stack_line("@rfalse");
        }
        if (resobj_flag==1) resobj_flag=3;

        if (brace_sp>0)
        {   error("Brace mismatch in previous routine");
            brace_sp=0;
        }
        in_routine_flag=0;
        if ((nowarnings_mode==0)&&(pass_number==1))
        {   for (i=0; i<no_locals; i++)
            {   if (used_local_variable[i]==0)
                {   override_error_line = routine_starts_line;
                    warning_named("Local variable unused:",
                      (char *) (local_varname[i]));
                }
            }
        }
        break;

    case ABBREVIATE_CODE:
        i=2;
        while (1>0)
        {  word(b,i); if (b[0]==0) break; textword(b,i);
           if (pass_number==1)
           {   if (no_abbrevs==MAX_ABBREVS)
               {   error("Too many abbreviations declared"); break; }
               if (almade_flag==1) 
               {   error("All abbreviations must be declared together");
                   break;
               }
               if (strlen(b)<2)
               {   error_named("It's not worth abbreviating",b); break; }
           }
           strcpy((char *)abbreviations_at+no_abbrevs*MAX_ABBREV_LENGTH, b);
           word(b,i++);
           abbrev_mode=0; lower_strings_flag=1;
           abbrev_values[no_abbrevs]=constant_value(b);
           abbrev_quality[no_abbrevs++]=trans_length-2;
           abbrev_mode=1; lower_strings_flag=0;
        }
        break;

    case ATTRIBUTE_CODE:
        make_attribute(b); break;

    case CONSTANT_CODE:
        constant_made_flag=1;
        word(b,3); k=constant_value(b);
        word(b,2);
        IfPass2
        {   i=find_symbol(b); svals[i]=k; }
        else
        {   if (constant_was_string==1) new_symbol(b,k,11);
            else new_symbol(b,k,8);
        }
        break;

    case LOWSTRING_CODE:
        word(b,3);
        lower_strings_flag=1;
        k=constant_value(b);
        lower_strings_flag=0;
        word(b,2);
        IfPass2
        {   i=find_symbol(b);
        }
        else
        {   if (constant_was_string==1) new_symbol(b,k,11);
            else new_symbol(b,i,8);
        }
        break;

    case DEFAULT_CODE:
        word(b,3);
        IfPass2
        {
        }
        else
        {   i=constant_value(b);
            word(b,2);
            if (find_symbol(b)==-1)
            {   if (constant_was_string==1)
                { error("Defaulted constants can't be strings"); return; }
                new_symbol(b,i,8);
            }
        }
        break;

    case STUB_CODE:
        i=0;
        IfPass2 { if (stub_flags[no_stubbed++]==1) i=1; }
        else
        {   word(b,2); if (find_symbol(b)==-1) i=1;
            stub_flags[no_stubbed++]=i;
        }
        if (i==1)
        {
            word(b,3); i=constant_value(b); word(b,2);
            switch(i)
            {   case 0: stack_sline("[ %s",b); stack_line("rfalse");
                        stack_line("]"); break;
                case 1: stack_sline("[ %s x1",b); stack_line("@store x1 0");
                        stack_line("rfalse"); stack_line("]"); break;
                case 2: stack_sline("[ %s x1 x2",b); stack_line("@store x1 0");
                        stack_line("@store x2 0");
                        stack_line("rfalse"); stack_line("]"); break;
                case 3: stack_sline("[ %s x1 x2 x3",b);
                        stack_line("@store x1 0"); stack_line("@store x2 0");
                        stack_line("@store x3 0");
                        stack_line("rfalse"); stack_line("]"); break;
                default:
                    error("Must specify 0 to 3 variables in 'stub' routine");
                        return;
            }
        }
        break;

    case DICTIONARY_CODE:
        obsolete_warning("use 'word' as a constant dictionary address");
        textword(b,3); i=dictionary_add(b,4,0,0);
        word(b,2);
        IfPass2
        { j=find_symbol(b); svals[j]=i; } else new_symbol(b,i,8);
        break;

    case FAKE_ACTION_CODE:
        make_fake_action(b); break;

    case GLOBAL_CODE: make_global(b,0); break;

    case ARRAY_CODE: make_global(b,1); break;

    case INCLUDE_CODE:
        word(b,3);
        if (b[0]!=0)
            error_named("Expected ';' after 'include <file>' but found",b);
        word(b,2);
        textword(b,2);
        if (b[0]!='>') load_sourcefile(b,0);
        else load_sourcefile(b+1,1);
        break;

    case NEARBY_CODE: make_object(b,1); break;

    case OBJECT_CODE: make_object(b,0); break;

    case CLASS_CODE: make_class(b); break;

    case PROPERTY_CODE: make_property(b); break;

    case RELEASE_CODE:
        word(b,2); release_number=constant_value(b); break;
        
    case SWITCHES_CODE:
        if (ignoreswitches_mode==0)
        {   if ((pass_number==1)&&(constant_made_flag==1))
                error("A 'switches' directive must \
must come before constant definitions");
            word(b,2); switches(b,0);
        }
        break;

    case STATUSLINE_CODE:
        word(b,2);
        On_("score") { statusline_flag=0; break; }
        On_("time")  { statusline_flag=1; break; }
        error_named("Expected 'score' or 'time' after 'statusline' but found",
            b); break;

    case SERIAL_CODE:
        textword(b,2);
        if (strlen(b)!=6)
        {   error("The serial number must be a 6-digit date in double-quotes");
            break; }
        for (i=0; i<6; i++)
          if (isdigit(b[i])==0)
          { error("The serial number must be a 6-digit date in double-quotes");
            break; }
        strcpy(time_given,b); time_set=1; break;

    case SYSTEM_CODE: 
        declare_systemfile(); break;

    case REPLACE_CODE:
        if (replace_sf(b)==1) break;
        sprintf(b, "Rep__");
        word(b+5, 2);
        new_symbol(b, 0, 19);
        break;

    case VERB_CODE: make_verb(b); break;

    case EXTEND_CODE: extend_verb(b); break;

    case VERSION_CODE:
        if (override_version) break;
        word(b,2); actual_version=constant_value(b);
        if (actual_version==3) version_number=3; else version_number=5;
        if (version_number==3) scale_factor=2; else scale_factor=4;
        if ((actual_version==6)||(actual_version==8)) scale_factor=8;
        if (actual_version==7) extend_memory_map=1;
        if ((actual_version>=3)&&(actual_version<=8)) break;
        error("The version number must be in the range 3 to 8"); break;

    case TRACE_CODE:     IfPass2 trace_mode=1;  break;
    case NOTRACE_CODE:   IfPass2 trace_mode=tracing_mode;  break;
    case ETRACE_CODE:
        IfPass2
        {   word(b,2); if (b[0]==0) { etrace_mode=2; break; }
            if (strcmp(b,"full")==0) { etrace_mode=1; break; }
        error_named("Expected 'full' or nothing after 'etrace' but found", b);
            break;
        }
    case NOETRACE_CODE:  IfPass2 etrace_mode=0; break; 
    case BTRACE_CODE:            trace_mode=1;  break; 
    case NOBTRACE_CODE:          trace_mode=0;  break; 
    case LTRACE_CODE:    IfPass2 ltrace_mode=1; break; 
    case NOLTRACE_CODE:  IfPass2 ltrace_mode=listing_mode; break; 
    case ATRACE_CODE:    IfPass2 ltrace_mode=2; break; 
    case NOATRACE_CODE:  IfPass2 ltrace_mode=listing_mode; break; 

    case LISTSYMBOLS_CODE:  IfPass2 list_symbols();     break;
    case LISTOBJECTS_CODE:  IfPass2 list_object_tree(); break;
    case LISTVERBS_CODE:    IfPass2 list_verb_table();  break;
    case LISTDICT_CODE:     IfPass2 show_dictionary();  break;

    default: error("Internal error - unknown directive code");
  }
    return;
}

extern void init_asm_vars(void)
{
    lower_strings_flag = 0;
    ifdef_sp = 0;
    started_ignoring = 0;
    a_from_one = 0;
    line_done_flag = 0;
    lmoved_flag = 0;
    constant_made_flag = 0;

#ifdef ALLOCATE_BIG_ARRAYS
    pa_forwards = NULL;
#endif
}