static void load_script(const char *name)
{
  struct stat st;
  int rc;

  updatecontext();

  if (!name)
    return;

  if (stat(name, &st) < 0) {
    myruby_loaded = -1;
    outerror(OUTERROR_TYPE_WARN_LOUD,
             "cannot access '%s', ignoring: %s",
             name, strerror(errno));
    return;
  }
  ruby_script(name);
  myruby_time = st.st_mtime;
  rb_load_protect(rb_str_new(name, strlen(name)), 0, &rc);
  if (rc != 0) {
    outerror(OUTERROR_TYPE_WARN_LOUD,
             "ruby_exec failed with %d: %s",
             rc, strerror(errno));
    myruby_loaded = 1;
    return;
  }

  myruby_loaded = 1;
  oIrofferEvent = rb_class_new_instance(0, NULL, cIrofferEvent);
  rb_define_variable("objIrofferEvent", &oIrofferEvent); /* NOTRANSLATE */
}

/* search the DDC transfer a user wants to resume */
unsigned int t_find_resume(const char *nick, const char *filename, const char *localport, const char *bytes, char *token)
{
    char *sendnamestr;
    transfer *guess;
    transfer *tr;
    off_t len;

    guess = NULL;
    for (tr = irlist_get_head(&gdata.trans);
            tr;
            tr = irlist_get_next(tr)) {
        if ((tr->tr_status != TRANSFER_STATUS_LISTENING) && (tr->tr_status != TRANSFER_STATUS_RESUME))
            continue;
        if (strcasecmp(tr->caps_nick, nick))
            continue;

        /* the filename can be converted */
        if (guess == NULL)
            guess = tr;
        if (strcasestr(tr->xpack->file, filename))
            break;
        if (tr->con.localport == (unsigned)atoi(localport))
            break;
    }
    if (tr == NULL) {
        if (guess != NULL) {
            outerror(OUTERROR_TYPE_WARN,
                     "Guessed transfer that %s on %s tried to resume!",
                     nick, gnetwork->name);
            outerror(OUTERROR_TYPE_WARN,
                     "resume trying %s, %s, %d",
                     nick, filename, atoi(localport));
            tr = guess;
        } else {
            t_find_debug(nick, filename, localport);
            return 1;
        }
    }
    len = atoull(bytes);
    if (len >= tr->xpack->st_size) {
        notice(nick, "You can't resume the transfer at a point greater than the size of the file");
        ioutput(OUT_S|OUT_L|OUT_D, COLOR_YELLOW,
                "XDCC [%02i:%s on %s]: Resume attempted beyond end of file ( %" LLPRINTFMT "d >= %" LLPRINTFMT "d )",
                tr->id, tr->nick, gnetwork->name, len,
                tr->xpack->st_size);
        return 1;
    }
    t_setresume(tr, bytes);
    sendnamestr = getsendname(filename);
    if ((tr->tr_status == TRANSFER_STATUS_RESUME) && (token != NULL)) {
        privmsg_fast(nick, IRC_CTCP "DCC ACCEPT %s %s %s %s" IRC_CTCP, sendnamestr, localport, bytes, token); /* NOTRANSLATE */
    } else {
        privmsg_fast(nick, IRC_CTCP "DCC ACCEPT %s %s %s" IRC_CTCP, sendnamestr, localport, bytes); /* NOTRANSLATE */
    }
    mydelete(sendnamestr);
    ioutput(OUT_S|OUT_L|OUT_D, COLOR_YELLOW,
            "XDCC [%02i:%s on %s]: Resumed at %" LLPRINTFMT "dK", tr->id,
            tr->nick, gnetwork->name, tr->startresume/1024);
    return 0;
}

/* rename file after upload */
static void fetch_rename(fetch_curl_t *ft, const char *effective_url)
{
  char *name;
  char *destname;
  int rc;
  int fd;

  if (strncasecmp(ft->name, "AUTO", 4) != 0) /* NOTRANSLATE */
    return;

  name = fetch_get_filename(ft, effective_url);
  if (name == NULL)
    return;

  destname = mystrjoin(ft->uploaddir, name, '/');
  fd = open(destname, O_RDONLY | ADDED_OPEN_FLAGS);
  if (fd >= 0) {
    close(fd);
    outerror(OUTERROR_TYPE_WARN_LOUD, "File %s could not be moved to %s: %s",
             ft->name, name, strerror(EEXIST));
  } else {
    rc = rename(ft->fullname, destname);
    if (rc < 0) {
      outerror(OUTERROR_TYPE_WARN_LOUD, "File %s could not be moved to %s: %s",
               ft->name, name, strerror(errno));
    } else {
      a_respond(&(ft->u), "fetched: '%s'", destname);
    }
  }
  mydelete(destname);
  mydelete(name);
}

static void t_find_debug(const char *nick, const char *filename, const char *remoteport)
{
    transfer *tr;

    outerror(OUTERROR_TYPE_WARN,
             "Couldn't find transfer that %s on %s tried to resume!",
             nick, gnetwork->name);
    outerror(OUTERROR_TYPE_WARN,
             "resume trying %s, %s, %d",
             nick, filename, atoi(remoteport));
    if (gdata.debug == 0)
        return;

    for (tr = irlist_get_head(&gdata.trans);
            tr;
            tr = irlist_get_next(tr)) {
        ioutput(OUT_S, COLOR_NO_COLOR,
                "transfer %u: %s on %s, %s, %d\n",
                tr->tr_status,
                tr->caps_nick,
                gdata.networks[tr->net].name,
                tr->xpack->file,
                tr->con.localport);
    }
}

void wheresyntax(int &lexpos, int &lineno)
{
   int index1, index2, icond;
   f_int cond;

   lexmovenext(lexpos);
   if (outArray[lexpos] == id)
   {
      index1 = idnosyn++;
      lexmovenext(lexpos);

      if (IsCon(lexpos))
      {
         icond = outArray[lexpos];
         F77_NAME(decode_cond_code, DECODE_COND_CODE)(keywords[icond], &cond);
         lexmovenext(lexpos);
         if (outArray[lexpos] == id)
         {
            index2 = idnosyn++;
            lexmovenext(lexpos);
            Instruct.insert(where, index1, index2, cond);
         }
         else
            outerror(lineno, "Second operand of WHERE must be an index");
      }
      else
         outerror(lineno, "Invalid conditional in WHERE");
   }
   else
      outerror(lineno, "First operand in WHERE must be an index");

   moveoverreturn(lexpos, lineno);
}

void in_syntax_check(int &lexpos, int &lineno, int subindex_idnosyn)
{
    int superindex, subindex_varid;
    lexmovenext(lexpos);  // eat the "in" keyword 
    if (outArray[lexpos] == id)  // next element must be the superindex 
    {
       /* Check to make sure the index is the superindex of this 
          subindex. */

       superindex = Variable.getidnumber(idnosyn); 
       subindex_varid   = Variable.getidnumber(subindex_idnosyn);
              
       /* The superindex is stored in the range1 field of the 
          variable table entry of the subindex.  It should match the
          superindex declared in this pardo. */
 
       if (Variable.getrange1(subindex_varid) != superindex)
          outerror(lineno, "subindex and superindex do not correspond.");
                 
    }
    else
    {
       outerror(lineno, "subindex missing superindex");
    }

    /* Done with the "in" syntax check.  Move to next index on pardo. */

    idnosyn++;
    lexmovenext(lexpos);  
    if (outArray[lexpos] == comma) lexmovenext(lexpos);  
}

/* call a ruby script as CGI via HTTP */
unsigned int http_ruby_script(const char *name, const char *output)
{
  struct stat st;
  char *tempstr;
  int rc;

  updatecontext();

  if (!name)
    return 1;

  if (stat(name, &st) < 0) {
    outerror(OUTERROR_TYPE_WARN_LOUD,
             "cannot access '%s', ignoring: %s",
             name, strerror(errno));
    return 1;
  }
  ruby_script(name);
  tempstr = mymalloc(maxtextlength);
  snprintf(tempstr, maxtextlength, "$stdout = File.new(\"%s\", \"w+\")", output); /* NOTRANSLATE */
  rb_eval_string_protect(tempstr, &rc);
  mydelete(tempstr);
  rb_load_protect(rb_str_new(name, strlen(name)), 0, &rc);
  if (rc != 0) {
    outerror(OUTERROR_TYPE_WARN_LOUD,
             "ruby_exec failed with %d: %s",
             rc, strerror(errno));
    iroffer_ruby_errro(rc);
  }
  rb_eval_string_protect("$stdout.close", &rc); /* NOTRANSLATE */
  if (rc != 0)
    return 1;
  return 0;
}

/*====================================
The function functionsyntax anylyzes the token array stored in outArray.
variable lexpos keeps tracking the position of the outArray.
string temp is the char array of lexical meanings.
====================================*/
void functionsyntax(int &lexpos, int& lineno)
{
    int sialnameno=0;
    if (outArray[lexpos]!=sial)
        outerror(lineno, "Data type is missing.");
    else
    {
        if(!lexmovenext(lexpos)) return;
    }

    if (id!=outArray[lexpos])               //id
        outerror(lineno, "<---Identifier missing.");
    else
    {
        sialnameno=idnosyn++;
        if(!lexmovenext(lexpos)) return;
    }
    moveoverreturn(lexpos, lineno);


    while (IsDeclaration (lexpos) && !endofoutArray)        //declaration
    {
        declarationsyntax(lexpos, lineno);
    }

    while (IsProc (lexpos)&& !endofoutArray)                //proc
    {
        procsyntax(lexpos, lineno);
    }

    Instruct.insert(start, 0);

    while(!endofoutArray &&endsial!=outArray[lexpos])
    {
        while(IsInstruction (lexpos) && !endofoutArray )    //instruction
        {
            instructionsyntax(lexpos, lineno);
        }
        if (!endofoutArray&&endsial!=outArray[lexpos])
            moveoverreturn(lexpos, lineno);
    }

    if (endsial!=outArray[lexpos])                         //endsial
    {
        outerror(lineno, "not instructions. endsial is missing.");
        return;
    }
    else
        lexmovenext(lexpos);

    if (idname[sialnameno]!=idname[idnosyn])
    {
        outerror(lineno, "endsial name does not match.");
    }
    else
    {
        idnosyn++;
        lexmovenext(lexpos);
    }
}

static void iroffer_ruby_errro(int error)
{
  VALUE lasterr;
  VALUE inclass;
  VALUE message;
  VALUE ary;
  long c;

  if (error == 0)
    return;

  lasterr = rb_gv_get("$!"); /* NOTRANSLATE */
  inclass = rb_class_path(CLASS_OF(lasterr));
  message = rb_obj_as_string(lasterr);
  outerror(OUTERROR_TYPE_WARN_LOUD,
           "error ruby_script: class=%s, message=%s",
           RSTRING_PTR(inclass), RSTRING_PTR(message));

  if (!NIL_P(rb_errinfo())) {
    ary = rb_funcall(rb_errinfo(), rb_intern("backtrace"), 0);
    for (c=0; c<RARRAY_LEN(ary); ++c) {
      outerror(OUTERROR_TYPE_WARN_LOUD,
               "backtrace from %s",
               RSTRING_PTR(RARRAY_PTR(ary)[c]));
    }
  }
}

void QCArrayClass::insert(int type, int idno, int nindex, int*indexarray)
{
    int i, j;
    int variableid;
    int found;

    if (Variable.getidnumber(idno)!=-1)
    {
        outerror(glno, "id exist.");
        return;
    }

    i=getidnumber(idno);
    if (i!=-1)
    {
        outerror(glno, "id exist.");
        return;
    }

    i=0;

    if (nvars<maxidnumber)
    {
        found=1;
        while(i<nindex&&found)
        {
            variableid=Variable.getidnumber(indexarray[i]);

            if(variableid==-1)
                found=0;
            else
            {
                arrayindex[nvars][i]=variableid;
                i++;
            }
        }

        if (!found)
        {
            outerror(glno, "index not defined.");
            printf("%s, \n",idname[indexarray[i]].c_str());
            return;
        }

        /*add 0 to meet the ll needs*/
        for (j=i; j<mx_array_dim; j++)
            arrayindex[nvars][j]=0;

        vararray[nvars]=idname[idno];
        arraynindex[nvars]=nindex;
        arraytype[nvars]=type;
        nvars++;
    }
    else
    {
        outerror(glno, 
            "More id than id container can hold, please contact writer.\n");
    }
}

void executesyntax(int &lexpos, int &lineno)
{
    int arraynameid, nindex;
    int indexarray[mx_array_dim];
    int fnnameid=0;
    int idno=0;
    int idno1=0;

    lexmovenext(lexpos);
    if (id!=outArray[lexpos])
        outerror(lineno, "function name is missing.");
    else
    {
        fnnameid=idnosyn++;
        lexmovenext(lexpos);
        if (id != outArray[lexpos])
        {
            Instruct.insert(execute, fnnameid, -1);
            moveoverreturn(lexpos, lineno);
            return;
        }

    }

    if (id ==outArray[lexpos] && lparen ==outArray[lexpos+1])
    {
        if(!commonarraysyntax(lexpos, lineno, arraynameid, nindex, indexarray))
        {
            outerror(lineno, "Array name is missing.");
            return;
        }

        Instruct.insert(execute, fnnameid, arraynameid, nindex, indexarray);
    }
    else if (id==outArray[lexpos])
    {
        idno=idnosyn++;
        lexmovenext(lexpos);

        if (id==outArray[lexpos])
        {
            idno1=idnosyn++;
            lexmovenext(lexpos);
            /*insert 2 arguements*/
            Instruct.insert(execute, fnnameid, idno, idno1);
        }
        else if (fconst==outArray[lexpos])
        {
           scalarsyntax(lexpos, idno1);
           Instruct.insert(execute, fnnameid, idno, idno1);
         }
        else                            /*insert one argument*/
            Instruct.insert(execute, fnnameid, idno);

    }

    moveoverreturn(lexpos, lineno);
}

int QCArrayClass::CheckTensor(int nindex1, int indexarray1[],
                      int nindex2, int indexarray2[],
                      int nindex3, int indexarray3[],
                      int &nindexr, int indexarrayr[]) const
{
    int i, i2, i3;
    nindexr=0;
    int sortindexarray1[mx_array_dim], sortindexarray2[mx_array_dim], 
        sortindexarray3[mx_array_dim];
    int contractionarray[2*mx_array_dim], contractnindex;

    selectionSort(indexarray1, sortindexarray1, nindex1);
    selectionSort(indexarray2, sortindexarray2, nindex2);
    selectionSort(indexarray3, sortindexarray3, nindex3);

/*check tensor index of array*/
    /*merge two arrays*/
    i2=i3=0;
    contractnindex=0;
    while (i2<nindex2 && i3<nindex3)
    {
        if (sortindexarray2[i2]>sortindexarray3[i3])
            contractionarray[contractnindex++]=sortindexarray3[i3++];
        else if (sortindexarray2[i2]<sortindexarray3[i3])
            contractionarray[contractnindex++]=sortindexarray2[i2++];
        else /*==*/
        {
            indexarrayr[nindexr++]=sortindexarray2[i2];
            i2++;
            i3++;
        }
    }
    while (i2<nindex2)
            contractionarray[contractnindex++]=sortindexarray2[i2++];
    while (i3<nindex3)
            contractionarray[contractnindex++]=sortindexarray3[i3++];

    /*compare array1 and calculated contraction array*/
    if (nindex1!=contractnindex)
    {
        outerror(glno, "error in tensor index.");
        return -2;
    }
    
    for (i=0; i<nindex1; i++)
    {
        if (contractionarray[i]!=sortindexarray1[i])
        {
            outerror(glno, "tensor array doesn't match.");
            return -1;
        }
    }
    return 0;
}

/* open file on disk for upload */
int l_setup_file(upload * const l, struct stat *stp)
{
  char *fullfile;
  int retval;

  updatecontext();

  if (l->uploaddir == NULL) {
    l_closeconn(l, "No uploaddir defined.", 0);
    return 1;
  }

  /* local file already exists? */
  fullfile = mystrjoin(l->uploaddir, l->file, '/');

  l->filedescriptor = open(fullfile,
                           O_WRONLY | O_CREAT | O_EXCL | ADDED_OPEN_FLAGS,
                           CREAT_PERMISSIONS );

  if ((l->filedescriptor < 0) && (errno == EEXIST)) {
    retval = stat(fullfile, stp);
    if (retval < 0) {
      outerror(OUTERROR_TYPE_WARN_LOUD, "Cant Stat Upload File '%s': %s",
               fullfile, strerror(errno));
      l_closeconn(l, "File Error, File couldn't be opened for writing", errno);
      mydelete(fullfile);
      return 1;
    }
    if (!S_ISREG(stp->st_mode) || (stp->st_size >= l->totalsize)) {
      l_closeconn(l, "File Error, That filename already exists", 0);
      mydelete(fullfile);
      return 1;
    }
    l->filedescriptor = open(fullfile, O_WRONLY | O_APPEND | ADDED_OPEN_FLAGS);
    if (l->filedescriptor >= 0) {
      l->resumesize = l->bytesgot = stp->st_size;
      if (l->resumed <= 0) {
        close(l->filedescriptor);
        mydelete(fullfile);
        return 2; /* RESUME */
      }
    }
  }
  if (l->filedescriptor < 0) {
    outerror(OUTERROR_TYPE_WARN_LOUD, "Cant Access Upload File '%s': %s",
             fullfile, strerror(errno));
    l_closeconn(l, "File Error, File couldn't be opened for writing", errno);
    mydelete(fullfile);
    return 1;
  }
  mydelete(fullfile);
  return 0;
}

void exitcyclesyntax(int &lexpos, int &lineno)
{
    if (docount==0)
        outerror(lineno, "exit or cycle not allowed outside do loop.");
    if (exitt==outArray[lexpos]||cycle==outArray[lexpos])
        Instruct.insert(outArray[lexpos], 0);
    else
        outerror(lineno, "unknow error in exitcyclesyntax.");
    lexmovenext(lexpos);

    moveoverreturn(lexpos, lineno);
}

void procsyntax(int &lexpos, int &lineno)
{
    int variableno=0;
    returncount=0;
    lexmovenext(lexpos);                                   //proc
    if (id!=outArray[lexpos])
        outerror(lineno, "id is missing.");
    else
    {
        variableno=idnosyn;
        Instruct.insert(proc, variableno);
        idnosyn++;
        lexmovenext(lexpos);
    }

    moveoverreturn(lexpos, lineno);

    while(!endofoutArray&&(IsInstruction(lexpos) ))
    {
            instructionsyntax(lexpos, lineno);
    }
/*
	while(!endofoutArray&&(IsInstruction(lexpos) ))//||returnsil==outArray[lexpos]))
    {
        while(IsInstruction(lexpos) && !endofoutArray)
        {
            instructionsyntax(lexpos, lineno);
        }
        if (returnsil==outArray[lexpos])
        {
            Instruct.insert (endproc, variableno);
            lexmovenext(lexpos);
            moveoverreturn(lexpos, lineno);

        }
    }
*/
    if (endproc!=outArray[lexpos])
        outerror(lineno,  "endproc is missing.");
    else
        lexmovenext(lexpos);

    if (idname[variableno]!=idname[idnosyn])
        outerror(lineno, "proc name does not match.");
    else
    {
        Instruct.insert (endproc, variableno);
        idnosyn++;
        lexmovenext(lexpos);
    }
    returncount=-1;
    moveoverreturn(lexpos, lineno);
}

void subindex_syntax(int &lexpos, int &lineno)
{
    int indexnameno=0;
    int indextype=outArray[lexpos]; //ao, moindex, index
    int superindex = 0;

    /* Syntax of the subindex declaration is: 
       subindex ii of i
       where ii is the name of the subindex
              i is the name of the superindex.
   */

    lexmovenext(lexpos);
    if (id!=outArray[lexpos])
    {
        outerror(lineno, "idname is missing.");
        indexnameno=0;
    }
    else
    {
        indexnameno=idnosyn++;    // subindex name.
        lexmovenext(lexpos);
    }

    /* Next element is the "of" keyword. */

    if (outArray[lexpos] != of_kwd)
        outerror(lineno, "subindex syntax error: of is missing.");
    else
        lexmovenext(lexpos);   // move pointer past "of".

    /* Check next element.  It must be an index of any type except subindex. */
 
    if (id!=outArray[lexpos])
    {
        outerror(lineno, "superindex idname is missing.");
    }
    else
    {
        superindex=Variable.getidnumber(idnosyn);    // superindex number.
        if (superindex == -1)
	{
           outerror(lineno, "superindex must be  a previously declared index.");
	}
        idnosyn++;
        lexmovenext(lexpos);
    }

    Variable.insert(indextype, indexnameno, superindex, 0);
    moveoverreturn(lexpos, lineno);
}

void scalardecsyntax(int &lexpos, int &lineno)
{
    int indexnameno=0;
    double value1=0;
    int negtive=0;

    lexmovenext(lexpos);
    if (id!=outArray[lexpos])
        outerror(lineno, "idname is missing.");
    else
    {
        indexnameno=idnosyn++;
        lexmovenext(lexpos);
    }

    if (assign==outArray[lexpos])
    {
        lexmovenext(lexpos);

        if (sub==outArray[lexpos])
        {
            negtive=1;
            lexmovenext(lexpos);
        }

        if (fconst==outArray[lexpos])
        {
            value1=floatconst[floatnosyn];
            if (negtive)
                value1=-value1;
            floatnosyn++;
            lexmovenext(lexpos);
        }
        else if (iconst==outArray[lexpos])
        {
            lexmovenext(lexpos);
            value1=double(intconst[intnosyn]);
            if (negtive)
                value1=-value1;
            intnosyn++;
        }
        else
            outerror(lineno, "value is missing.");
    }

    QCArray.insertscalar(indexnameno, value1);

    moveoverreturn (lexpos, lineno);
}

void pardoline(int &lexpos, int &lineno, int &nindex, int indexarray[],
               int in_flag[])
{
    int i;

    nindex=0;

    for (i = 0; i < mx_array_dim; i++)
      in_flag[i] = 0;
 
    while (!endofoutArray&& id==outArray[lexpos])
    {
        if (nindex<mx_array_dim)
            indexarray[nindex]=idnosyn;

        nindex++;

        idnosyn++;
        lexmovenext(lexpos);

        if (comma==outArray[lexpos])
            lexmovenext(lexpos);
        else if (outArray[lexpos] == in_kwd)   // "pardo ... ii in i" syntax.
        {
           in_syntax_check(lexpos, lineno, indexarray[nindex-1]);
           in_flag[nindex-1] = 1;
        }   
        else
            break;
    }

    if (nindex>mx_array_dim)
    {
        outerror(lineno, "Warning: Too many indices detected.");
        printf("Only the first %d are used.\n",mx_array_dim);
	printf("%d=nindex\n", nindex);
	printf("All the indices are: ");
        for (int ii=indexarray[0]; ii<idnosyn; ii++)
            printf("%s, ", idname[ii].c_str());
        printf("\n");
        nindex=mx_array_dim;
    }

    if (nindex==0)
        outerror(lineno, "id is missing.");
    Instruct.insert(pardo, nindex, indexarray, in_flag);

    moveoverreturn(lexpos, lineno);
}

/* process successful connection */
static void t_connected(transfer *tr)
{
    int callval_i;
    int connect_error;
    SIGNEDSOCK int connect_error_len = sizeof(connect_error);

    tr->con.connecttime = gdata.curtime;
    FD_CLR(tr->con.clientsocket, &gdata.writeset);
    callval_i = getsockopt(tr->con.clientsocket,
                           SOL_SOCKET, SO_ERROR,
                           &connect_error, &connect_error_len);

    if (callval_i < 0) {
        outerror(OUTERROR_TYPE_WARN,
                 "Couldn't determine upload connection status on %s: %s",
                 gnetwork->name, strerror(errno));
        t_closeconn(tr, "Download Connection Failed status:", errno);
        return;
    }
    if (connect_error) {
        t_closeconn(tr, "Download Connection Failed", connect_error);
        return;
    }

    ioutput(OUT_S|OUT_L|OUT_D, COLOR_MAGENTA,
            "Download Connection Established on %s", gnetwork->name);

    t_setup_send(tr);
    return;
}

void returnsilsyntax(int &lexpos, int &lineno)
{
    int variableno=0;
    if (returncount==-1)
        outerror(lineno, "return cannot be used in the main part of sial.");

    if (returnsil==outArray[lexpos])
    {
        Instruct.insert (endproc, variableno);
        lexmovenext(lexpos);
        moveoverreturn(lexpos, lineno);

    }
    else
        outerror(lineno, "unknown error in returnsilsyntax.");
}