xfile.c

本程序为ST公司开发的源代码

          return st;
        do
        {
          i++;
          if ((XAR_NodeType(i) == XTYPE_DIRECTORY) && (i < X_NEXTFREE_ITEM))
          {
            st = X_array[i].data.xdir.first_file;
            if (st)
              return st;
          }
        }
        while ((XAR_NodeType(i) != XTYPE_VOLUME) && (i < X_NEXTFREE_ITEM));
        return i;
      }
    }

    i--;
  }

  return st;
}


GRESULT XAR_DirFirstFromFile(uint16 item)
{
  uint16 i, j;

  i = item - 1;

  while (XAR_NodeType(i) != XTYPE_VOLUME)
  {
    if (XAR_NodeType(i) == XTYPE_DIRECTORY)
    {
      j = X_array[i].data.xdir.first_file;
      if ((j) && (j <= item))
        return j;
    }

    i--;
  }

  ASSERT(0, "XAR_DirFirstFromFile invalid index");
  return E_FAIL;
}
#endif // #if XARREM

GRESULT XAR_FindVolumeByDevice(t_duid dtype)
{
  GRESULT voli = 0, volume = 1;


  while (voli < X_NEXTFREE_ITEM)
  {
    if (XTYPE_VOLUME != XAR_NodeType(voli))
      return E_FAIL;
    if ((XAR_VolNodeDevType(voli) == dtype) && (X_array[voli].data.xvolume.fs_type != FS_TOC))
      return volume; //XAR_VolumeForItem(voli);
    voli = voli + X_array[voli].data.xvolume.nodes_num + 1;
    volume++;
  }


  return E_FAIL;
}

void XAR_DisableTOCVolume(void)
{
  if (X_NEXTFREE_ITEM & (FS_TOC == X_array[0].data.xvolume.fs_type))
    ; //X_array[0].type |= FLAG_VOLUME_TOC_UNKNOWN;
}


GRESULT XAR_DeleteDir(uint16 dir)
{
  int voli, j, n;
  UInt par;
  UInt name,p,offs;
  uint32 namel;
  GRESULT deleted = 0;
  uint8 *namep, *namep2;


  voli = XAR_VolumeNodeForItem(dir);

  do
  {
    if (XAR_DirChild(dir) || XAR_DirFirstFile(dir))
      return deleted;

    par = XAR_DirParent(dir);
    if (par)
    {
      n = XAR_NextDir(dir);
      if (dir == XAR_DirChild(par))
      {
        XAR_SetDirChild(par, n);  // change child index or clear it
      }
    }


    // move names
    name = X_array[dir].data.xdir.name;
#if HAVE_EXTERNAL_XARRAY
    name += (X_array[dir].nodetype.b[1]<<16);
#endif

    namep = ((uint8 *)&X_array[XFILE_NODES_NUM]) - name - 1;
#if HAVE_EXTERNAL_XARRAY
    namel = *((uint16 *) namep);
    namel += (namel & 1);
    namep2 = namep - namel;
    namep2 -= 2;
#else
    namel = *namep;
    namep2 = namep - namel;
    namep2 --;
#endif


#if HAVE_EXTERNAL_XARRAY
    while (namep2 >= (((uint8 *)&X_array[XFILE_NODES_NUM]) - X_POOL_TOP - 1))
    {
      *(uint16 *) namep = *(uint16 *) namep2;
      namep -= 2;
      namep2 -= 2;
    }
#else
    while (namep2 >= (((uint8 *)&X_array[XFILE_NODES_NUM]) - X_POOL_TOP))
    {
      *namep = *namep2;
      namep--;
      namep2--;
    }
#endif

#if HAVE_EXTERNAL_XARRAY
    //X_POOL_TOP -= (namel + 2);
    writeSDRAM32((int16*)&X_POOL_TOP,X_POOL_TOP -(namel+2));
#else
    X_POOL_TOP -= (namel + 1);
#endif

	// update all safe indexes
	for(j=X_SAFE_LIST_LENGTH-1;j>=0;j--)
    {
       if(X_safe_list[j] != NULL)
       {
         if(*X_safe_list[j]==dir)
         	  *X_safe_list[j]=0;
         else
         	if((*X_safe_list[j] > dir)&&(*X_safe_list[j]<X_NEXTFREE_ITEM))
            	*X_safe_list[j] -= 1; 
       }

    }

    // copy all items after deli to one cell lower
    for (j = dir + 1; j < X_NEXTFREE_ITEM; j++)
    {
#if (1 == HAVE_EXTERNAL_XARRAY)
      memcpy16(&X_array[j - 1],&X_array[j],sizeof(t_XNode));
#else
      memcpy(&X_array[j - 1],&X_array[j],sizeof(t_XNode));
#endif
    }
    
    X_NEXTFREE_ITEM--;

    for (j = voli + 1; j < X_NEXTFREE_ITEM; j++)
    {
      switch (XAR_NodeType(j))
      {
      case XTYPE_DIRECTORY:
        p = X_array[j].data.xdir.parent;
        if (p > dir)
          X_array[j].data.xdir.parent--;
        p = X_array[j].data.xdir.child;
        if (p > dir)
          X_array[j].data.xdir.child--;
        p = X_array[j].data.xdir.first_file;
        if (p > dir)
          X_array[j].data.xdir.first_file--;

        p = X_array[j].data.xdir.name;
#if HAVE_EXTERNAL_XARRAY
        p += (X_array[j].nodetype.b[1]<<16);
#endif        
        if (p > name)
        {
#if HAVE_EXTERNAL_XARRAY
          //offs = X_array[j].data.xdir.name + (X_array[j].nodetype.b[1]<<16);
          offs = p-(namel + 2);
          X_array[j].data.xdir.name = offs&0xffff;
          X_array[j].nodetype.i = X_array[j].nodetype.b[0] | ((offs&0xff0000)>>8);
#else
          X_array[j].data.xdir.name -= (namel + 1);
#endif
        }
        break;

      case XTYPE_DATA_FILE:
        p = X_array[j].data.xfile.name;
        
#if HAVE_EXTERNAL_XARRAY
        p += (X_array[j].nodetype.b[1]<<16);
#endif        
        
        if (p > name)
        {
#if HAVE_EXTERNAL_XARRAY
          //X_array[j].data.xfile.name -= (namel + 2);
          //offs = X_array[j].data.xfile.name + (X_array[j].nodetype.b[1]<<16);
          offs = p- (namel + 2);
          X_array[j].data.xfile.name = offs&0xffff;
          X_array[j].nodetype.i = X_array[j].nodetype.b[0] | ((offs&0xff0000)>>8);
#else
          X_array[j].data.xfile.name -= (namel + 1);
#endif
        }

      case XTYPE_FILE_EXTEND:
        p = X_array[j].data.xfile.next_extent & 0x7FFF; // O.T. mask off UDF simple file flag
        if (p > dir)
          X_array[j].data.xfile.next_extent--;
        break;
      }
    }
    deleted++;
    dir = par;
  }
  while (dir);

  return deleted;
}


UInt XAR_FirstVolumeString(uint16 vi)
{
UInt offs;

  offs = X_array[vi].data.xvolume.name;
#if HAVE_EXTERNAL_XARRAY
  offs += (X_array[vi].nodetype.b[1]<<16); 
  if(offs != 0xffffff)
#else
  if ( offs != 0xffff)  
#endif  
  {
    return offs;  //X_array[vi].data.xvolume.name;
  }
  if (X_array[vi].data.xvolume.nodes_num)
  {
    if (XAR_NodeType(vi + 1) == XTYPE_DIRECTORY)
    {
      //if (X_array[vi + 1].data.xdir.name != 0xffff)
      offs = X_array[vi+1].data.xvolume.name;
#if HAVE_EXTERNAL_XARRAY
      offs += (X_array[vi+1].nodetype.b[1]<<16); 
      if(offs != 0xffffff)
#else
      if ( offs != 0xffff)  
#endif  
         return offs; //X_array[vi + 1].data.xdir.name;
    }
  }
#if HAVE_EXTERNAL_XARRAY
  return 0xffffff;
#else  
  return 0xffff;
#endif
  
}


//#ifndef APM_PICKUP

GRESULT XAR_ReallocateTOC(void)
{

int p,shift,i,j,vol2;


  p = toc_get_max_track();
  shift = p  - X_array[0].data.xvolume.nodes_num;

  if(!shift)
    return S_OK;

  vol2 = XAR_VolumeNode(2);

  if(X_NEXTFREE_ITEM + shift > X_MAX_INDEX)
     return E_FAIL;
  
  if(shift>0)
  {
    if((uint8*)(X_array + X_NEXTFREE_ITEM) + shift * sizeof(t_XNode) > (uint8*)(X_array + XFILE_NODES_NUM) - X_POOL_TOP )
    {
      return E_INSUFFICIENT_MEMORY;
    }

    // copy nodes up
    semaphore_wait(&sem_xfile);

    if(0<vol2)
    {

      for(i = X_NEXTFREE_ITEM - 1;i>=vol2;i--)
      {

        for(j=X_SAFE_LIST_LENGTH-1;j>=0;j--)
        {
          if(X_safe_list[j] != NULL)
          {
            if(*X_safe_list[j] == i )
              *X_safe_list[j] += shift; // update all safe indexes
          }

        }


        switch(XAR_NodeType(i))
        {
          case XTYPE_DIRECTORY:
            if(X_array[i].data.xdir.parent)
                X_array[i].data.xdir.parent += shift;
            if(X_array[i].data.xdir.child)
                X_array[i].data.xdir.child += shift;
            if(X_array[i].data.xdir.first_file)
                X_array[i].data.xdir.first_file += shift;
            break;
          case XTYPE_FILE_EXTEND:
            if(X_array[i].data.xfile.next_extent & 0x7FFF) // O.T. mask off UDF simple file flag
                X_array[i].data.xfile.next_extent += shift;
            break;
          default:
            break;
        }

//  X_array[i+shift]=X_array[i];
#if HAVE_EXTERNAL_XARRAY
    memcpy16(&X_array[shift+i],&X_array[i],sizeof(t_XNode));
#else
    memcpy(&X_array[shift+i],&X_array[i],sizeof(t_XNode));
#endif


      }
    }


  }
  else
  {
  // copy nodes down
    semaphore_wait(&sem_xfile);

    if(0<vol2)
    {

      for(i = vol2; i < X_NEXTFREE_ITEM ;i++)
      {

        for(j=X_SAFE_LIST_LENGTH-1;j>=0;j--)
        {
          if(X_safe_list[j] != NULL)
          {
            if(*X_safe_list[j] == i)
              *X_safe_list[j] += shift; // update all safe indexes
          }

        }


        switch(XAR_NodeType(i))
        {
          case XTYPE_DIRECTORY:
            if(X_array[i].data.xdir.parent)
                X_array[i].data.xdir.parent += shift;
            if(X_array[i].data.xdir.child)
                X_array[i].data.xdir.child += shift;
            if(X_array[i].data.xdir.first_file)
                X_array[i].data.xdir.first_file += shift;
            break;
          case XTYPE_FILE_EXTEND:
            if(X_array[i].data.xfile.next_extent & 0x7FFF ) // O.T. mask off UDF simple file flag
                X_array[i].data.xfile.next_extent += shift;
            break;
          default:
            break;
        }

//  X_array[i+shift]=X_array[i];
#if HAVE_EXTERNAL_XARRAY
    memcpy16(&X_array[shift+i],&X_array[i],sizeof(t_XNode));
#else
    memcpy(&X_array[shift+i],&X_array[i],sizeof(t_XNode));
#endif


      }
    }


  }

  X_NEXTFREE_ITEM += shift;

  X_array[0].data.xvolume.nodes_num += shift;
//	X_array[X_array[0].data.xvolume.nodes_num].type = XTYPE_TOC_INFO;	
  semaphore_signal(&sem_xfile);

  return S_OK;


}
//#endif // #ifndef APM_PICKUP

GRESULT XAR_DeleteVolume(uint8 vol)
{
  GRESULT voli, next_voli, nextv;
  UInt last, next, shift = 0, shifti,offs;
  int i;
  char *lastp, *nextp, *top;

  voli = XAR_VolumeNode(vol);
  if (voli < 0)
    return S_FALSE;
  if (X_array[voli].data.xvolume.fs_type == FS_TOC)
    return S_FALSE;

  semaphore_wait(&sem_xfile);

  last = XAR_FirstVolumeString(voli);
#if HAVE_EXTERNAL_XARRAY
  if (last != 0xFFFFFF)
#else    
  if (last != 0xFFFF)
#endif  
  {
    // it is necessary to move strings
#if HAVE_EXTERNAL_XARRAY
    top = ((char *)&X_array[XFILE_NODES_NUM]) - X_POOL_TOP - 2;    // -1;
#else
    top = ((char *)&X_array[XFILE_NODES_NUM]) - X_POOL_TOP - 1;
#endif
    nextv = vol;
    do
    {
      nextv++;
      next_voli = XAR_VolumeNode(nextv);
      if (VALID_VOLUME_NODE(next_voli))
      {
        next = XAR_FirstVolumeString(next_voli);
      }
      else
      {
#if HAVE_EXTERNAL_XARRAY
        next = X_POOL_TOP + 1;
#else
        next = X_POOL_TOP;
#endif
      }
    }
#if HAVE_EXTERNAL_XARRAY    
    while ((next == 0xFFFFFF) && (next_voli > 0));
#else    
    while ((next == 0xFFFF) && (next_voli > 0));
#endif

    shift = next - last;

    if (next_voli > 0)
    {
      nextp = ((char *)&X_array[XFILE_NODES_NUM]) - next - 1;
      lastp = ((char *)&X_array[XFILE_NODES_NUM]) - last - 1;
      do
      {
#if HAVE_EXTERNAL_XARRAY
        *(uint16 *) lastp = *(uint16 *) nextp;
        lastp -= 2;
        nextp -= 2;
#else
        *lastp = *nextp;
        lastp--;
        nextp--;
#endif
      }
      while (nextp > top);   // copy strings;

    }

#if HAVE_EXTERNAL_XARRAY
    writeSDRAM32((int16*)&X_POOL_TOP,X_POOL_TOP-shift);
#else  
    X_POOL_TOP -= shift;
#endif    
  
  }

  next_voli = XAR_VolumeNode(vol + 1);
  if (!VALID_VOLUME_NODE(next_voli))    // it is last volume in X_array, check if some indexes are registered
  {
    for (i = X_SAFE_LIST_LENGTH - 1; i >= 0; i--)
    {
      if (X_safe_list[i] != NULL)
      {
        if (voli  <= *X_safe_list[i])    
          *X_safe_list[i] = 0;
      }
    }

    X_NEXTFREE_ITEM = voli;
    semaphore_signal(&sem_xfile);
    return S_OK;
  }

  shifti = next_voli - voli;

  // update all indexes from safe list, indexes to deleted volume will be assigned to 0
  for (i = X_SAFE_LIST_LENGTH - 1; i >= 0; i--)
  {
    if (X_safe_list[i] != NULL)
    {
      if (voli <= *X_safe_list[i])    // registered indexes are with offset 100
      {
        if