CLexFile *LexFilePush(CCmpCtrl *cc)
{//#include file push.
  CLexFile *res=CAlloc(sizeof(CLexFile));
  if (res->next=cc->lex_include_stk)
    res->depth=res->next->depth+1;
  else
    res->depth=-1; //Include depth starts with -1.
  return cc->lex_include_stk=res;
}

CLexFile *LexFilePop(CCmpCtrl *cc)
{//#include file pop.
  CLexFile *tmpf;
  if (tmpf=cc->lex_include_stk)
  {
    if ((cc->lex_include_stk=tmpf->next) || !(cc->flags & CCF_DONT_FREE_BUF))
    {
      if (tmpf->flags & LFSF_DOC)
      {
        if (tmpf->doc)
          DocDel(tmpf->doc);
      }
      else
        Free(tmpf->buf);;
    }
    Free(tmpf->full_name);
    Free(tmpf);
  }
  return cc->lex_include_stk;
}

CCmpCtrl *CmpCtrlNew(U8 *buf=NULL,I64 flags=0,U8 *filename=NULL)
{//MAlloc and Init CCmpCtrl.
//Frees buf in CmpCtrlDel unless CCF_DONT_FREE_BUF flag is set.
  //FileName is for error reporting.  If files are #included,
  //new names are used.  See Psalmody CmpCtrlNew.
  CCmpCtrl *cc=CAlloc(sizeof(CCmpCtrl));
  CLexFile *tmpf;
  QueInit(cc);
  cc->flags=flags;
  cc->opts=1<<OPTf_WARN_UNUSED_VAR|1<<OPTf_WARN_HEADER_MISMATCH;
  cc->htc.hash_mask=HTG_TYPE_MASK-HTT_IMPORT_SYS_SYM;
  cc->htc.define_hash_table=cc->htc.hash_table_lst=
          cc->htc.glbl_hash_table=cc->htc.local_hash_table=Fs->hash_table;
  if (flags&CCF_KEEP_AT_SIGN)
    cc->char_bmp_alpha_numeric=char_bmp_alpha_numeric_no_at;
  else
    cc->char_bmp_alpha_numeric=char_bmp_alpha_numeric;
  tmpf=LexFilePush(cc);
  QueInit(&cc->next_stream_blk);
  if (filename)
    tmpf->full_name=FileNameAbs(filename);
  else
    tmpf->full_name=StrNew(blkdev.tmp_filename);
  if (flags & CCF_PMT)
    buf=CAlloc(8);
  tmpf->buf=tmpf->buf_ptr=tmpf->line_start=cc->cur_buf_ptr=buf;
  tmpf->line_num=1;
  return cc;
}

U0 CmpCtrlDel(CCmpCtrl *cc)
{//Free CCmpCtrl.
  while (LexFilePop(cc));
  LinkedLstDel(cc->lex_prs_stk);
  LinkedLstDel(cc->htc.next);
  Free(cc->ps);
  Free(cc->cur_str);
  Free(cc->cur_help_idx);
  Free(cc->dollar_buf);
  Free(cc);
}

I64 CmpCtrlSize(CCmpCtrl *cc)
{//Mem size of CCmpCtrl and its members.
  CLexFile *tmpf=cc->lex_include_stk;
  I64 res=0;
  while (tmpf)
  {
    if (tmpf->next || !(cc->flags & CCF_DONT_FREE_BUF))
    {
      if (tmpf->flags & LFSF_DOC)
      {
        if (tmpf->doc)
          res+=DocSize(tmpf->doc);
      }
      else
        res+=MSize2(tmpf->buf);
    }
    res+=MSize2(tmpf->full_name);
    res+=MSize2(tmpf);
    tmpf=tmpf->next;
  }
  res+=MSize2(cc->cur_str);
  res+=MSize2(cc);
  return res;
}

U32 lex_zeros=0;

Bool LexDollar(CCmpCtrl *cc,CDoc *doc,CDocEntry *doc_e)
{
  U8 *st;
  if (cc->flags&CCF_IN_QUOTES)
  {
    Free(cc->dollar_buf);
    st=Doc2PlainText(doc,doc_e);
    cc->dollar_buf=MStrPrint("$%$Q$",st);
    cc->dollar_cnt=2;
    Free(st);
    return TRUE;
  }
  else
    return FALSE;
}

I64 LexGetChar(CCmpCtrl *cc)
{//Get one char from stream. Allow put-back one.
  U8 *ptr,*src;
  CLexFile *tmpf;
  CDoc *doc;
  CDocEntry *doc_e;
  if (!Btr(&cc->flags,CCf_USE_LAST_U16))
  {
lgc_start1:
    if (!(src=cc->cur_buf_ptr++))
    {
      cc->cur_buf_ptr=NULL;
      goto lgc_here;
    }
    switch [cc->last_U16=*src++]
    {
    case 0:
lgc_here:
      tmpf=cc->lex_include_stk;
      if (tmpf->flags & LFSF_DOC)
      {
        doc=tmpf->doc;
        doc_e=tmpf->cur_entry;
        doc_e=doc_e->next;
lgc_start2:
        if (doc_e!=doc)
        {
          tmpf->cur_entry=doc_e;
          switch [doc_e->type_u8]
          {
          case DOCT_TEXT:
            if (doc_e->de_flags & ~(DOCEF_TAG|DOCEF_DEFINE|DOCEF_TAG_CB|
                    DOCG_BL_IV_UL|DOCEF_WORD_WRAP|DOCEF_HIGHLIGHT|
                    DOCEF_SKIP|DOCEF_FILTER_SKIP) &&
                LexDollar(cc,doc,doc_e) && *(src=cc->dollar_buf))
            {
              tmpf->line_num=doc_e->y+1;
              tmpf->buf_ptr=cc->cur_buf_ptr=src;
            }
            else if (*(src=doc_e->tag))
              tmpf->buf_ptr=cc->cur_buf_ptr=src;
            else
            {
              doc_e=doc_e->next;
              goto lgc_start2;
            }
            break;
          case DOCT_NEW_LINE:
            tmpf->buf_ptr=cc->cur_buf_ptr=&lex_zeros;
            tmpf->line_start=doc_e->next;
            tmpf->line_num=doc_e->y+2;//+1 because NEW_LINE is on prev line
//+1 because doc y starts at zero
            cmp.compiled_lines++;
            cc->last_U16='\n';
            goto lgc_done;
          case DOCT_TAB:
            tmpf->buf_ptr=cc->cur_buf_ptr=&lex_zeros;
            tmpf->line_num=doc_e->y+1;
            cc->last_U16='\t';
            goto lgc_done;
          case DOCT_INS_BIN:
            tmpf->buf_ptr=cc->cur_buf_ptr=&lex_zeros;
            tmpf->line_num=doc_e->y+1;
            Free(cc->cur_str);
            cc->cur_str=NULL;
            cc->cur_str_len=0;
            if (doc_e->bin_data)
            {
              ptr=MAlloc(doc_e->bin_data->size);
              if (doc_e->bin_data->data)
                MemCpy(ptr,doc_e->bin_data->data,doc_e->bin_data->size);
              cc->cur_str=ptr;
              cc->cur_str_len=doc_e->bin_data->size;
            }
            cc->last_U16=TK_INS_BIN;
            goto lgc_done;
          case DOCT_INS_BIN_SIZE:
            tmpf->buf_ptr=cc->cur_buf_ptr=&lex_zeros;
            if (doc_e->bin_data)
              cc->cur_i64=doc_e->bin_data->size;
            else
              cc->cur_i64=0;
            tmpf->line_num=doc_e->y+1;
            cc->last_U16=TK_INS_BIN_SIZE;
            goto lgc_done;
          case DOCT_SHIFTED_Y:
            if (LexDollar(cc,doc,doc_e) && *(src=cc->dollar_buf))
            {
              tmpf->line_num=doc_e->y+1;
              tmpf->buf_ptr=cc->cur_buf_ptr=src;
            }
            else
            {
              tmpf->buf_ptr=cc->cur_buf_ptr=&lex_zeros;
              tmpf->line_num=doc_e->y+1;
              if (doc_e->attr<0)
                cc->last_U16=TK_SUPERSCRIPT;
              else if (doc_e->attr>0)
                cc->last_U16=TK_SUBSCRIPT;
              else
                cc->last_U16=TK_NORMALSCRIPT;
              goto lgc_done;
            }
            break;
          case DOCT_MARKER:
          case DOCT_CURSOR:
            doc_e=doc_e->next;
            goto lgc_start2;
          case 0xFF: //nobound switch
          default:
            if (LexDollar(cc,doc,doc_e) && *(src=cc->dollar_buf))
            {
              tmpf->line_num=doc_e->y+1;
              tmpf->buf_ptr=cc->cur_buf_ptr=src;
            }
            else
            {
              doc_e=doc_e->next;
              goto lgc_start2;
            }
          }
        }
        if (doc_e!=doc)
          goto lgc_start1;
        tmpf->cur_entry=doc->head.last; //When take next, will still be end.
      }
      tmpf=cc->lex_include_stk;
      if (tmpf->next)
      {
        tmpf=LexFilePop(cc);
        cc->cur_buf_ptr=tmpf->buf_ptr;
        cc->flags&=~CCF_USE_LAST_U16;
        if (!(cc->last_U16=tmpf->last_U16))
          goto lgc_start1;
      }
      else
      {
        if (cc->flags & CCF_PMT)
        {
          Free(tmpf->buf);
          ptr=CmdLinePmt;
          if (StrCmp(ptr,"\n") && !cc->pmt_line++ && !StrCmp(ptr,"?\n") &&
              cc->flags & CCF_QUESTION_HELP)
          {
            Free(ptr);
            ptr=StrNew("Help;;\n");
          }
          tmpf->buf=tmpf->buf_ptr=tmpf->line_start=cc->cur_buf_ptr=ptr;
          goto lgc_start1;
        }
        else
        {
          if (src)
            cc->cur_buf_ptr=src-1;
          cc->last_U16=TK_EOF;
        }
      }
      break;
    case CH_CURSOR:
      goto lgc_start1;
    case '\n':
      tmpf=cc->lex_include_stk;
      if (!(tmpf->flags & LFSF_DOC))
      {
        tmpf->line_num++;
        cmp.compiled_lines++;
        tmpf->line_start=src;
      }
      break;
    case 0xFF: //nobound switch
    }
lgc_done:
    if (cc->last_U16==CH_SHIFT_SPACE)
      cc->last_U16=CH_SPACE;
    if (cc->opts & OPTF_ECHO &&
        cc->last_U16<256 && Bt(char_bmp_printable,cc->last_U16))
      '' cc->last_U16;
  }
  return cc->last_U16;
}

U0 LexSkipEol(CCmpCtrl *cc)
{//LexGetChar to NULL until end-of-line.
  I64 ch;
  do ch=LexGetChar(cc);
  while (Bt(char_bmp_non_eol,ch));
}

U8 *LexFirstRem(CCmpCtrl *cc,U8 *marker,I64 _len=NULL)
{//LexGetChar() chars making str until marker.
  U8 *res,*ptr;
  CQueVectU8 *tmpv=QueVectU8New;
  I64 i,len=0;
  while (TRUE)
  {
    i=LexGetChar(cc);
    if (!i||StrOcc(marker,i))
      break;
    QueVectU8Put(tmpv,len++,i);
  }
  if (i)
    Bts(&cc->flags,CCf_USE_LAST_U16);
  res=ptr=MAlloc(len+1);
  for (i=0; i<len; i++)
    *ptr++=QueVectU8Get(tmpv,i);
  *ptr=0;
  QueVectU8Del(tmpv);
  if (_len) *_len=len;
  return res;
}

U0 LexIncludeStr(CCmpCtrl *cc,U8 *abs_filename,U8 *src,Bool actual_file)
{
  LexBackupLastChar(cc);
  CLexFile *tmpf=LexFilePush(cc);
  if (actual_file)
    tmpf->full_name=StrNew(abs_filename);
  else
    tmpf->full_name=StrNew(blkdev.tmp_filename);
  tmpf->line_num=1;
  tmpf->buf=tmpf->buf_ptr=tmpf->line_start=cc->cur_buf_ptr=src;
}

CDoc *LexDocRead(U8 *abs_filename,I64 flags)
{
  CDoc *doc=DocNew(abs_filename);
  U8 *src;
  I64 size=0;
  doc->flags|=flags;
  src=FileRead(abs_filename,&size);
  if (!src || !size)
  {
    Free(src);
    src=CAlloc(1);
    size=0;
  }
  DocLoad(doc,src,size);
  Free(src);
  return doc;
}

I64 cmp_type_flags_src_code[(DOCT_TYPES_NUM+63)/64]=
{
  1<<DOCT_TEXT|1<<DOCT_TAB|1<<DOCT_INS_BIN|1<<DOCT_INS_BIN_SIZE
};

U0 LexAttachDoc(CCmpCtrl *cc,CLexFile *tmpf=NULL,
    CDoc *doc=NULL,U8 *abs_filename=NULL,CDocEntry *doc_e=NULL,I64 col=0)
{//Start lexing doc. Give either doc or abs_filename.
  if (!doc)
    doc=LexDocRead(abs_filename,DOCF_DBL_DOLLARS);
  if (!tmpf)
  {
    LexBackupLastChar(cc);
    tmpf=LexFilePush(cc);
  }
  if (!doc_e)
    doc_e=doc->head.next;
  tmpf->full_name=StrNew(doc->filename.name);
  tmpf->doc=doc;
  while (doc_e!=doc)
  {
    if (Bt(cmp_type_flags_src_code,doc_e->type_u8))
      break;
    doc_e=doc_e->next;
    col=doc_e->min_col;
  }
  if (doc_e!=doc)
  {
    col=ClampI64(col,doc_e->min_col,doc_e->max_col);
    tmpf->line_start=doc_e;
    tmpf->buf=NULL;
    tmpf->line_num=doc_e->y+1;
    if (doc_e->type_u8==DOCT_TEXT)
    {
      tmpf->cur_entry=doc_e;
      tmpf->buf_ptr=doc_e->tag;
    }
    else
    {
      tmpf->cur_entry=doc_e->last; //TODO: might be problem at begin of file
      tmpf->buf_ptr=&lex_zeros;
    }
    tmpf->flags=LFSF_DOC;
  }
  else //TODO: DocDel(doc)?
  {
    col=0;
    tmpf->buf=tmpf->buf_ptr=tmpf->line_start=CAlloc(1);
    tmpf->line_num=1;
    tmpf->flags=0;
  }
  cc->cur_buf_ptr=tmpf->buf_ptr+col;
  tmpf->last_U16=0;
}

I64 LexInStr(CCmpCtrl *cc,U8 *buf,I64 size,Bool *done)
{
  I64 i=0,j,k,ch;
  *done=TRUE;
  while (i<size-1)
  {
    ch=LexGetChar(cc);
    if (!ch || ch=='"')
    {
      buf[i++]=0;
      return i;
    }
    else if (ch=='\\')
    {
      switch (ch=LexGetChar(cc))
      {
      case '0':
        buf[i++]=0;
        break;
      case '\'':
        buf[i++]='\'';
        break;
      case '\`':
        buf[i++]='\`';
        break;
      case '\\':
        buf[i++]='\\';
        break;
      case '"':
        buf[i++]='"';
        break;
      case 'd':
        buf[i++]='$';
        break;
      case 'n':
        buf[i++]='\n';
        break;
      case 'r':
        buf[i++]='\r';
        break;
      case 't':
        buf[i++]='\t';
        break;
      case 'x':
      case 'X':
        j=0;
        for (k=0; k<2; k++)
        {
          ch=ToUpper(LexGetChar(cc));
          if (Bt(char_bmp_hex_numeric,ch))
          {
            if (ch<='9')
              j=j<<4+ch-'0';
            else
              j=j<<4+ch-'A'+10;
          }
          else
          {
            cc->flags|=CCF_USE_LAST_U16;
            break;
          }
        }
        buf[i++]=j;
        break;
      default:
        cc->flags|=CCF_USE_LAST_U16;
        buf[i++]='\\';
      }
    }
    else if (ch=='$')
    {
      buf[i++]='$';
      if (cc->dollar_cnt)
        cc->dollar_cnt--;
      else if (LexGetChar(cc)!='$')
      {
        cc->dollar_cnt=1;
        cc->flags|=CCF_USE_LAST_U16;
      }
    }
    else
      buf[i++]=ch;
  }
  *done=FALSE;
  return i;
}

I64 Lex(CCmpCtrl *cc)
{//Fetch next token.
  I64 i,j,k,l,ch;
  CHash *tmph;
  Bool str_done,in_str,neg_e;
  U8 *fbuf,*buf2,*buf3,buf[STR_LEN];
  cc->last_line_num=cc->lex_include_stk->line_num;
  while (TRUE)
  {
lex_cont:
    switch [ch=LexGetChar(cc)]
    {
    case 0:
      return cc->token=TK_EOF;
    case TK_SUPERSCRIPT:
      ch='>';
      goto lex_ident;
    case TK_SUBSCRIPT:
      ch='<';
      goto lex_ident;
    case TK_NORMALSCRIPT:
      ch='=';
      goto lex_ident;
    case '@':
      if (cc->flags&CCF_KEEP_AT_SIGN)
      {
        cc->token=ch;
        goto lex_end;
      }
    case 'A'...'Z':
    case 'a'...'z':
    case '_':
    case 128...255:
lex_ident:
      i=0;
      buf[i++]=ch;
      while (TRUE)
      {
        if (i>=STR_LEN)
          LexExcept(cc,"Ident limited to STR_LEN chars at ");
        else if (!(ch=LexGetChar(cc)))
          break;
        else if (Bt(cc->char_bmp_alpha_numeric,ch))
          buf[i++]=ch;
        else if (ch==TK_SUPERSCRIPT)
          buf[i++]='>';
        else if (ch==TK_SUBSCRIPT)
          buf[i++]='<';
        else if (ch==TK_NORMALSCRIPT)
          buf[i++]='=';
        else
        {
          cc->flags|=CCF_USE_LAST_U16;
          break;
        }
      }
      buf[i++]=0;
      tmph=NULL;
      if (cc->htc.local_var_lst)
        cc->local_var_entry=MemberFind(buf,cc->htc.local_var_lst);
      else
        cc->local_var_entry=NULL;
      if (!cc->local_var_entry && cc->htc.hash_table_lst)
        tmph=HashFind(buf,cc->htc.hash_table_lst,cc->htc.hash_mask);
      if (tmph)
        j=tmph->type;
      else
        j=0;
      if (j & HTT_DEFINE_STR && !(cc->flags & CCF_NO_DEFINES))
      {
        LexIncludeStr(cc,
            tmph->str,StrNew(tmph(CHashDefineStr *)->data),FALSE);
        cc->lex_include_stk->flags|=LFSF_DEFINE;
      }
      else
      {
        cc->hash_entry=tmph;
        Free(cc->cur_str);
        cc->cur_str=StrNew(buf);
        cc->cur_str_len=i;
        cc->token=TK_IDENT;
        goto lex_end;
      }
      break;
    case '0'...'9':
      i=ch-'0';
      ch=ToUpper(LexGetChar(cc));
      if (!Bt(&cc->opts, OPTf_DECIMAL_ONLY))
      {
        if (ch=='X')
        {
          while (TRUE)
          {
            ch=ToUpper(LexGetChar(cc));
            if (Bt(char_bmp_hex_numeric,ch))
            {
              if (ch<='9')
                i=i<<4+ch-'0';
              else
                i=i<<4+ch-'A'+10;
            }
            else
            {
              cc->cur_i64=i;
              cc->flags|=CCF_USE_LAST_U16;
              cc->token=TK_I64;
              goto lex_end;
            }
          }
        }
        else if (ch=='B')
        {
          while (TRUE)
          {
            ch=LexGetChar(cc);
            if (ch=='0')
              i=i<<1;
            else if (ch=='1')
              i=i<<1+1;
            else
            {
              cc->cur_i64=i;
              cc->flags|=CCF_USE_LAST_U16;
              cc->token=TK_I64;
              goto lex_end;
            }
          }
        }
      }
      while (TRUE)
      {
        if (Bt(char_bmp_dec_numeric,ch))
          i=i*10+ch-'0';
        else
        {
          if (ch=='.' || ch=='e' || ch=='E') break;
lex_is_int:
          cc->cur_i64=i;
          cc->flags|=CCF_USE_LAST_U16;
          cc->token=TK_I64;
          goto lex_end;
        }
        ch=LexGetChar(cc);
      }
      if (ch=='.')
      {
        ch=LexGetChar(cc);
        if (ch=='.')
        {
          cc->flags|=CCF_LAST_WAS_DOT;
          goto lex_is_int;
        }
      }
lex_float_start:
      k=0;
      while (TRUE)
      {
        if (Bt(char_bmp_dec_numeric,ch))
        {
          i=i*10+ch-'0';
          k++;
        }
        else
        {
          if (ch=='e' || ch=='E')
            break;
          cc->cur_f64=i*Pow10I64(-k);
          cc->flags|=CCF_USE_LAST_U16;
          cc->token=TK_F64;
          goto lex_end;
        }
        ch=LexGetChar(cc);
      }
      ch=LexGetChar(cc);
      neg_e=FALSE;
      if (ch=='-')
      {
        neg_e=TRUE;
        ch=LexGetChar(cc);
      }
      j=0;
      while (TRUE)
      {
        if (Bt(char_bmp_dec_numeric,ch))
          j=j*10+ch-'0';
        else
        {
          if (neg_e)
            cc->cur_f64=i*Pow10I64(-j-k);
          else
            cc->cur_f64=i*Pow10I64(j-k);
          cc->flags|=CCF_USE_LAST_U16;
          cc->token=TK_F64;
          goto lex_end;
        }
        ch=LexGetChar(cc);
      }
      break;
    case '"':
      cc->flags|=CCF_IN_QUOTES;
      buf2=NULL;
      i=0;
      do
      {
        j=LexInStr(cc,buf,STR_LEN,&str_done);
        buf3=MAlloc(i+j);
        if (buf2)
        {
          MemCpy(buf3,buf2,i);
          Free(buf2);
          buf2=buf3;
          MemCpy(buf2+i,buf,j);
        }
        else
        {
          buf2=buf3;
          MemCpy(buf2,buf,j);
        }
        i+=j;
      }
      while (!str_done);
      Free(cc->cur_str);
      cc->cur_str=MAlloc(i);
      MemCpy(cc->cur_str,buf2,i);
      Free(buf2);
      cc->cur_str_len=i;
      cc->flags&=~CCF_IN_QUOTES;
      cc->token=TK_STR;
      goto lex_end;
    case '\'':
      if (cc->flags&CCF_NO_CHAR_CONST)
        break;
      k=0;
      for (j=0; j<8; j++)
      {
        if (!(ch=LexGetChar(cc)) || ch=='\'')
          break;
        if (ch=='\\')
        {
          switch (ch=LexGetChar(cc))
          {
          case '0':
            k.u8[j]=0;
            break;
          case '\'':
            k.u8[j]='\'';
            break;
          case '\`':
            k.u8[j]='\`';
            break;
          case '"':
            k.u8[j]='"';
            break;
          case '\\':
            k.u8[j]='\\';
            break;
          case 'd':
            k.u8[j]='$';
            break;
          case 'n':
            k.u8[j]='\n';
            break;
          case 'r':
            k.u8[j]='\r';
            break;
          case 't':
            k.u8[j]='\t';
            break;
          case 'x':
          case 'X':
            i=0;
            for (l=0; l<2; l++)
            {
              ch=ToUpper(LexGetChar(cc));
              if (Bt(char_bmp_hex_numeric,ch))
              {
                if (ch<='9')
                  i=i<<4+ch-'0';
                else
                  i=i<<4+ch-'A'+10;
              }
              else
              {
                cc->flags|=CCF_USE_LAST_U16;
                break;
              }
            }
            k.u8[j]=i;
            break;
          default:
            k.u8[j]='\\';
            cc->flags|=CCF_USE_LAST_U16;
          }
        }
        else if (ch=='$')
        {
          ch=LexGetChar(cc);
          k.u8[j]='$';
          if (ch!='$')
            cc->flags|=CCF_USE_LAST_U16;
        }
        else
          k.u8[j]=ch;
      }
      if (ch!='\'' && (ch=LexGetChar(cc)) && ch!='\'')
        LexExcept(cc,"Char const limited to 8 chars at ");
      cc->cur_i64=k;
      cc->token=TK_CHAR_CONST;
      goto lex_end;
    case '#':
      if (cc->flags&CCF_KEEP_SIGN_NUM)
      {
        cc->token=ch;
        goto lex_end;
      }
      if (Lex(cc)!=TK_IDENT)    //skip '#'
        goto lex_end;
      if (!(tmph=cc->hash_entry))
        goto lex_end;
      if (!(tmph->type & HTT_KEYWORD))
        goto lex_end;
      switch (i=tmph(CHashGeneric *)->user_data0)
      {
      case KW_INCLUDE:
        if (Lex(cc)!=TK_STR)
          goto lex_end;
        fbuf=ExtDft(cc->cur_str,"HC.Z");
        buf2=FileNameAbs(fbuf);
        Free(fbuf);
        if (Bt(&sys_run_level,RLf_DOC))
          LexAttachDoc(cc,,,buf2);
        else
          LexIncludeStr(cc,buf2,FileRead(buf2),TRUE);
        Free(buf2);
        break;
      case KW_DEFINE:
        cc->flags|=CCF_NO_DEFINES;
        if (Lex(cc)==TK_IDENT)
        {
          tmph=CAlloc(sizeof(CHashDefineStr));
          tmph->str=cc->cur_str;
          cc->cur_str=0;
          tmph->type=HTT_DEFINE_STR;
          HashSrcFileSet(cc,tmph);
          do ch=LexGetChar(cc); //skip space between define name and start
          while (Bt(char_bmp_non_eol_white_space,ch));
          i=j=0;
          buf2=NULL;
          if (ch)
          {
            in_str=FALSE;
            do
            {
              if (ch=='\\')
              {
                if (ch=LexGetChar(cc))
                {
                  if (ch!='\r' && ch!='\n')
                  {
                    buf[j++]='\\';
                    buf[j++]=ch;
                  }
                  else if (ch=='\r' && LexGetChar(cc)!='\n')
                    cc->flags|=CCF_USE_LAST_U16;
                }
                else
                {
                  buf[j++]='\\';
                  break;
                }
              }
              else if (ch!='\n')
              {
                if (ch=='\"')
                  in_str=!in_str;
                buf[j++]=ch;
              }
              else
                break;
              while (ch=LexGetChar(cc))
              {
                if (ch=='/')
                {
                  ch=LexGetChar(cc);
                  if (ch=='/' && !in_str)
                  {
                    do ch=LexGetChar(cc);
                    while (Bt(char_bmp_non_eol,ch));
                    break;
                  }
                  else
                  {
                    buf[j++]='/';
                    cc->flags|=CCF_USE_LAST_U16;
                  }
                }
                else if (ch=='\\')
                {
                  if (ch=LexGetChar(cc))
                  {
                    if (ch=='\"')
                    {
                      buf[j++]='\\';
                      buf[j++]=ch;
                    }
                    else
                    {
                      cc->flags|=CCF_USE_LAST_U16;
                      ch='\\';
                      break;
                    }
                  }
                }
                else if (Bt(char_bmp_non_eol,ch))
                {
                  if (ch=='\"')
                    in_str=!in_str;
                  buf[j++]=ch;
                }
                else
                  break;
                if (j>=STR_LEN-4) //Spot for ['\'][ch],[ch],[0]
                {
                  buf[j++]=0;
                  buf3=MAlloc(i+j);
                  if (buf2)
                  {
                    MemCpy(buf3,buf2,i);
                    Free(buf2);
                    buf2=buf3;
                    MemCpy(buf2+i,buf,j);
                  }
                  else
                  {
                    buf2=buf3;
                    MemCpy(buf2,buf,j);
                  }
                  i+=j-1;
                  j=0;
                }
              }
            }
            while (ch=='\\');
          }
          buf[j++]=0;
          buf3=MAlloc(i+j);
          if (buf2)
          {
            MemCpy(buf3,buf2,i);
            Free(buf2);
            buf2=buf3;
            MemCpy(buf2+i,buf,j);
          }
          else
          {
            buf2=buf3;
            MemCpy(buf2,buf,j);
          }
          tmph(CHashDefineStr *)->data=buf2;
          tmph(CHashDefineStr *)->cnt=-1;
          HashAdd(tmph,cc->htc.define_hash_table);
        }
        cc->flags&=~CCF_NO_DEFINES;
        break;
      case KW_ELSE:
        if (cc->flags & CCF_IN_IF)
        {
          cc->token=TK_ELSE;
          goto lex_end;
        }
lex_else:
        j=1;
        do
        {
          if (ch=LexGetChar(cc))
          {
            if (ch=='#')
            {
              if (!Lex(cc))
                goto lex_end;
              i=PrsKeyWord(cc);
              if (i==KW_IF || i==KW_IFDEF || i==KW_IFNDEF ||
                  i==KW_IFAOT || i==KW_IFJIT)
                j++;
              else if (i==KW_ENDIF)
                j--;
            }
          }
          else
          {
            cc->token=TK_EOF;
            goto lex_end;
          }
        }
        while (j);
        break;
      case KW_IF:
        if (cc->flags & CCF_IN_IF)
        {
          cc->token=TK_IF;
          goto lex_end;
        }
lex_if:
        cc->flags|=CCF_IN_IF;
        if (!Lex(cc))
        {
          cc->flags&=~CCF_IN_IF;
          goto lex_end;
        }
        if (LexExpression(cc))
        {
          cc->flags&=~CCF_IN_IF;
          switch (cc->token)
          {
          case TK_IF:
            goto lex_if;
          case TK_IFDEF:
            goto lex_ifdef;
          case TK_IFNDEF:
            goto lex_ifndef;
          case TK_IFAOT:
            goto lex_ifaot;
          case TK_IFJIT:
            goto lex_ifjit;
          case TK_ELSE:
            goto lex_else;
          case TK_ENDIF:
            goto lex_cont;
          default:
            goto lex_end;
          }
        }
        else
        {
          cc->flags&=~CCF_IN_IF;
          if (cc->token!=TK_ENDIF && cc->token!=TK_ELSE)
          {
            if (cc->token==TK_IF || cc->token==TK_IFDEF ||
                cc->token==TK_IFNDEF || cc->token==TK_IFAOT ||
                cc->token==TK_IFJIT)
              j=2;
            else
              j=1;
            do
            {
              if (ch=LexGetChar(cc))
              {
                if (ch=='#')
                {
                  if (!Lex(cc))
                    goto lex_end;
                  i=PrsKeyWord(cc);
                  if (i==KW_IF || i==KW_IFDEF || i==KW_IFNDEF ||
                      i==KW_IFAOT || i==KW_IFJIT)
                    j++;
                  else if (i==KW_ENDIF)
                    j--;
                  else if (i==KW_ELSE && j==1)
                    break;
                }
              }
              else
              {
                cc->token=TK_EOF;
                goto lex_end;
              }
            }
            while (j);
          }
        }
        break;
      case KW_IFDEF:
        if (cc->flags & CCF_IN_IF)
        {
          cc->token=TK_IFDEF;
          goto lex_end;
        }
lex_ifdef:
        cc->flags|=CCF_NO_DEFINES;
        if (!Lex(cc))
        {
          cc->flags&=~CCF_NO_DEFINES;
          goto lex_end;
        }
        cc->flags&=~CCF_NO_DEFINES;
        if (cc->token!=TK_IDENT)
          goto lex_end;
        if (cc->hash_entry)
          goto lex_cont;
        j=1;
        do
        {
          if (ch=LexGetChar(cc))
          {
            if (ch=='#')
            {
              if (!Lex(cc))
                goto lex_end;
              i=PrsKeyWord(cc);
              if (i==KW_IF || i==KW_IFDEF || i==KW_IFNDEF ||
                  i==KW_IFAOT || i==KW_IFJIT)
                j++;
              else if (i==KW_ENDIF)
                j--;
              else if (i==KW_ELSE && j==1)
                break;
            }
          }
          else
          {
            cc->token=TK_EOF;
            goto lex_end;
          }
        }
        while (j);
        break;
      case KW_IFNDEF:
        if (cc->flags & CCF_IN_IF)
        {
          cc->token=TK_IFNDEF;
          goto lex_end;
        }
lex_ifndef:
        cc->flags|=CCF_NO_DEFINES;
        if (!Lex(cc))
        {
          cc->flags&=~CCF_NO_DEFINES;
          goto lex_end;
        }
        cc->flags&=~CCF_NO_DEFINES;
        if (cc->token!=TK_IDENT)
          goto lex_end;
        if (!cc->hash_entry)
          goto lex_cont;
        j=1;
        do
        {
          if (ch=LexGetChar(cc))
          {
            if (ch=='#')
            {
              if (!Lex(cc))
                goto lex_end;
              i=PrsKeyWord(cc);
              if (i==KW_IF || i==KW_IFDEF || i==KW_IFNDEF ||
                  i==KW_IFAOT || i==KW_IFJIT)
                j++;
              else if (i==KW_ENDIF)
                j--;
              else if (i==KW_ELSE && j==1)
                break;
            }
          }
          else
          {
            cc->token=TK_EOF;
            goto lex_end;
          }
        }
        while (j);
        break;
      case KW_IFAOT:
        if (cc->flags & CCF_IN_IF)
        {
          cc->token=TK_IFAOT;
          goto lex_end;
        }
lex_ifaot:
        if (cc->flags & CCF_AOT_COMPILE)
          goto lex_cont;
        j=1;
        do
        {
          if (ch=LexGetChar(cc))
          {
            if (ch=='#')
            {
              if (!Lex(cc))
                goto lex_end;
              i=PrsKeyWord(cc);
              if (i==KW_IF || i==KW_IFDEF || i==KW_IFNDEF ||
                  i==KW_IFAOT || i==KW_IFJIT)
                j++;
              else if (i==KW_ENDIF)
                j--;
              else if (i==KW_ELSE && j==1)
                break;
            }
          }
          else
          {
            cc->token=TK_EOF;
            goto lex_end;
          }
        }
        while (j);
        break;
      case KW_IFJIT:
        if (cc->flags & CCF_IN_IF)
        {
          cc->token=TK_IFAOT;
          goto lex_end;
        }
lex_ifjit:
        if (!(cc->flags & CCF_AOT_COMPILE))
          goto lex_cont;
        j=1;
        do
        {
          if (ch=LexGetChar(cc))
          {
            if (ch=='#')
            {
              if (!Lex(cc))
                goto lex_end;
              i=PrsKeyWord(cc);
              if (i==KW_IF || i==KW_IFDEF || i==KW_IFNDEF ||
                  i==KW_IFAOT || i==KW_IFJIT)
                j++;
              else if (i==KW_ENDIF)
                j--;
              else if (i==KW_ELSE && j==1)
                break;
            }
          }
          else
          {
            cc->token=TK_EOF;
            goto lex_end;
          }
        }
        while (j);
        break;
      case KW_ENDIF:
        if (cc->flags & CCF_IN_IF)
        {
          cc->token=TK_ENDIF;
          goto lex_end;
        }
        break;
      case KW_ASSERT:
        if (!Lex(cc))
          goto lex_end;
        if (!LexExpression(cc))
          LexWarn(cc,"Assert Failed ");
        goto lex_end;
      case KW_EXE:
        if (!Lex(cc))
          goto lex_end;
        PrsStreamBlk(cc);
        goto lex_end;
      case KW_HELP_INDEX:
        if (Lex(cc)!=TK_STR)
          goto lex_end;
        Free(cc->cur_help_idx);
        cc->cur_help_idx=LexExtStr(cc,,FALSE);
        break;
      case KW_HELP_FILE:
        if (Lex(cc)!=TK_STR)
          goto lex_end;
        tmph=CAlloc(sizeof(CHashSrcSym));
        fbuf=ExtDft(cc->cur_str,"DD.Z");
        tmph->str=FileNameAbs(fbuf);
        Free(fbuf);
        tmph->type=HTT_HELP_FILE|HTF_PUBLIC;
        HashSrcFileSet(cc,tmph);
        HashAdd(tmph,cc->htc.glbl_hash_table);
        break;
      }
      break;
    case '\n':
      if (!(cc->flags&CCF_KEEP_NEW_LINES))
        break; //else fall through
    case TK_INS_BIN:
    case TK_INS_BIN_SIZE:
      cc->token=ch;
      goto lex_end;
    case '.':
      if (cc->flags&CCF_KEEP_DOT)
      {
        cc->token=ch;
        goto lex_end;
      }
      if (cc->flags&CCF_LAST_WAS_DOT)
      {
        cc->flags&=~CCF_LAST_WAS_DOT;
        goto lex_dot_dot;
      }
      ch=LexGetChar(cc);
      if ('0'<=ch<='9')
      {
        i=0;
        goto lex_float_start;
      }
      else if (ch=='.')
      {
lex_dot_dot:
        cc->token=TK_DOT_DOT;
        if (LexGetChar(cc)=='.')
          cc->token=TK_ELLIPSIS;
        else
          cc->flags|=CCF_USE_LAST_U16;
        goto lex_end;
      }
      cc->flags|=CCF_USE_LAST_U16;
      cc->token='.';
      goto lex_end;
    case '!':
    case '$'...'&':
    case '('...'-':
    case '/':
    case ':'...'?':
    case '[':
    case ']'...'^':
    case '{'...'~':
    case '`':
      if (!(i=cmp.dual_U16_tokens1[ch]))
      {
        if (ch=='$')
        {
          ch=LexGetChar(cc);
          if (ch=='$')
          {
            cc->token='$';
            goto lex_end;
          }
          else if (ch)
          {
            do ch=LexGetChar(cc);
            while (ch && ch!='$');
            if (!ch)
            {
              cc->token=TK_EOF;
              goto lex_end;
            }
            else
              goto lex_cont;
          }
          else
          {
            cc->flags|=CCF_USE_LAST_U16;
            cc->token='$';
            goto lex_end;
          }
        }
        else
        {
          cc->token=ch;
          goto lex_end;
        }
      }
      else
      {
        j=LexGetChar(cc);
        if (i.u16[0]==j)
        {
          i>>=16;
          if (!i) // "/*"
          {
            j=1;
            do
            {
              if (!(ch=LexGetChar(cc)))
                return cc->token=TK_EOF;
lex_check_comment:
              if (ch=='*')
              {
                if (!(ch=LexGetChar(cc)))
                  return cc->token=TK_EOF;
                if (ch=='/')
                  j--;
                else
                  goto lex_check_comment;
              }
              else if (ch=='/')
              {
                if (!(ch=LexGetChar(cc)))
                  return cc->token=TK_EOF;
                if (ch=='*')
                  j++;
                else
                  goto lex_check_comment;
              }
            }
            while (j);
            goto lex_cont;
          }
          else
          {
            cc->token=i;
            goto lex_end;
          }
        }
        if (i=cmp.dual_U16_tokens2[ch])
        {
          if (i.u16[0]==j)
          {
            i>>=16;
            if (!i) // "//"
            {
              LexSkipEol(cc);
              if (cc->flags&CCF_KEEP_NEW_LINES)
              {
                cc->token='\n';
                goto lex_end;
              }
              else
                goto lex_cont;
            }
            else
            {
              if (i==TK_SHL || i==TK_SHR)
              {
                j=LexGetChar(cc);
                if (j=='=')
                {
                  if (i==TK_SHL)
                    i=TK_SHL_EQU;
                  else
                    i=TK_SHR_EQU;
                }
                else
                  cc->flags|=CCF_USE_LAST_U16;
              }
              cc->token=i;
              goto lex_end;
            }
          }
          if (i=cmp.dual_U16_tokens3[ch])
          {
            if (i.u16[0]==j)
            {
              cc->token=i.u16[1];
              goto lex_end;
            }
          }
        }
        cc->flags|=CCF_USE_LAST_U16;
        cc->token=ch;
        goto lex_end;
      }
    case TK_TKS_NUM:
      break;
    }
  }
lex_end:
  LexGetChar(cc); //Do this so WAS_NEW_LINE is right
  cc->flags|=CCF_USE_LAST_U16;
  return cc->token;
}