sgram.cpp

此文件包含了在linux下实现tpr-tree索引的源代码

      { 
         fread(st->coordslow + Settings.GetDims(), sizeof(RTcoord), Settings.GetDims(), fl);
         for (i = Settings.GetDims(); i < Settings.GetDims() * 2; i++) 
            st->coordshigh[i] = st->coordslow[i];
      }
      else 
         for (i = Settings.GetDims(); i < Settings.GetDims() * 2; i++) 
            st->coordshigh[i] = st->coordslow[i] = 0;
      st->rid  = 0;
      st->oper = RToverlap;
      CommandSelect(st); 
      delete st;
      break;
    
    default:
      Error (eWrongBinOperation);
   } 
}

//------------------------------------------------
int ParseCommands ()
{
   TToken       curToken;
   double       U;
   int          level;
   RTvisobject  vobj;
   char        *p, *tstr;
   char         table[20];
   inputstruct* st;

   for(;;)
   {
      if (Sbinary)
      { 
         DoBinaryOp();
         continue;
      }

      do
      {
         p = GetCommandString(buf);
         if (!p) Quit();
      } while (IsWhiteSpace(p));
      curToken = Scanner(p, tstr);
      switch (curToken)
      {
      case tBinary :
         if (!numImports) Error (eIllegalSwitchToBinary); 
         Sbinary = true;         
         break;

      case tCreate :
         curToken = Scanner(p, tstr);
         strcpy(table, tstr);
         curToken = Scanner(p, tstr);
         switch (curToken)
         {
         case tMORTree:    // for backward compatibility
         case tTPRtree:
            curToken = Scanner(p, tstr);
            if (!isdigit(*tstr)) Error (eMissingNumOfDimensions);
            else CommandCreate ("tprtree", table, atol(tstr));
            break;
         case tRTree:
            curToken = Scanner(p, tstr);
            if (!isdigit(*tstr)) Error (eMissingNumOfDimensions);
            else CommandCreate ("rtree", table, atol(tstr));
            break;
         case tOptTree:
            curToken = Scanner(p, tstr);
            if (!isdigit(*tstr)) Error (eMissingNumOfDimensions);
            else CommandCreate ("opttree", table, atol(tstr));
            break;
         default:
	    Error (eMissingMethodName);
         }
         break;

      case tOpen :
         curToken = Scanner(p, tstr);
         CommandOpen (tstr);
         break;

      case tDrop :
         CommandDrop ();
         break;

      case tClose :
         CommandClose ();
         break;
       
      case tLoad:
         curToken = Scanner(p, tstr);     
         CommandLoad(tstr); 
         break;

      case tSelect :
         st = GetPredicate (p, true);
         CommandSelect (st);
         delete st;
         break;

      case tDelete :
         st = GetKey (p);
         CommandDelete (st);
         delete st;
         break;

      case tInsert :
         st = GetKey (p);
         CommandInsert (st);
         delete st;
         break;

      case tQuit :
         CommandQuit ();
         break;

      case tAlpha:
         curToken = Scanner(p, tstr);
         if (curToken != tOther) Error (eMissingAlpha);
         if (*tstr) CommandAlpha (atof(tstr));
         else       CommandGetAlpha();
         break;

      case tHorizon:
         curToken = Scanner(p, tstr); 
         if (curToken == tAuto) 
         {
            curToken = Scanner(p, tstr); 
            if (curToken != tOther || !*tstr) Error (eMissingWfactor);
            CommandAutoHorizon (atof(tstr));
            break;
         } 
         if (curToken != tOther) Error (eMissingUW);
         if (!*tstr) CommandGetHorizon();
         else
         {  
            U = atof(tstr);
            curToken = Scanner(p, tstr);
            if (curToken != tOther || !*tstr) Error (eMissingUW); 
            CommandHorizon (U, atof(tstr));
         }
         break;

      case tParam:
         curToken = Scanner(p, tstr);
         if (curToken != tOther) Error (eMissingParam);
         if (isdigit(*tstr)) CommandParam (atof(tstr));
         else                CommandGetParam();
         break;

      case tAdvanceTime:
         curToken = Scanner(p, tstr);
         if (curToken != tOther) Error (eMissingTimeValue);
         if (isdigit(*tstr)) CommandAdvanceTime (atof(tstr));
         else                CommandAdvanceTime();
         break;

      case tTime:
         curToken = Scanner(p, tstr);
         if (curToken != tOther) Error (eMissingTimeValue);
         if (isdigit(*tstr)) CommandTime (atof(tstr));
         else                CommandGetTime();
         break;

      case tBuffer:
         curToken = Scanner(p, tstr);
         if (curToken != tOther) Error (eMissingBufferSize);
         if (isdigit(*tstr)) CommandBufferSize (atol(tstr));
         else                CommandGetBufferSize();
         break;

      case tPage:
         curToken = Scanner(p, tstr);
         if (curToken != tOther) Error (eMissingPageSize);
         if (isdigit(*tstr)) CommandPage (atol(tstr));
         else                CommandGetPage();
         break;

      case tPrint:
         curToken = Scanner(p, tstr);
         if (curToken != tOn && curToken != tOff) CommandGetPrint();
         else CommandPrint (curToken == tOn);
         break;

      case tStatistics:
         curToken = Scanner(p, tstr);
         switch (curToken)
         {
         case tOn:
         case tOff:
            CommandStatistics(curToken == tOn);
            break;
         case tOut:
            CommandOutStatistics();
            break;
         default:
            CommandGetStatistics();
         }
         break;

      case tAlgorithm:
         curToken = Scanner(p, tstr);
         switch (curToken)
         {
         case tNormal:
            CommandAlgorithm(RTsettings::aNormal);
            break;
         case tNormalHilbert:
            CommandAlgorithm(RTsettings::aNormalHilbert);
            break;
         case tRatio:
            CommandAlgorithm(RTsettings::aRatio);
            break;
         case tDual:
            CommandAlgorithm(RTsettings::aDual);
            break;
         case tDualHilbert:
            CommandAlgorithm(RTsettings::aDualHilbert);
            break;
         case tDualSpeed:
            CommandAlgorithm(RTsettings::aDualSpeed);
            break;
         case tVelocity:
            CommandAlgorithm(RTsettings::aVelocity);
            break;
         case tCSD:
            CommandAlgorithm(RTsettings::aCSD);
            break;
         case tCDS:
            CommandAlgorithm(RTsettings::aCDS);
            break;
         case tDSC:
            CommandAlgorithm(RTsettings::aDSC);
            break;
         case tSDC:
            CommandAlgorithm(RTsettings::aSDC);
            break;
         default:
            CommandGetAlgorithm();
         }
         break;
         
      case tSplit:
         curToken = Scanner(p, tstr);
         switch (curToken)
         {
         case tOld:
            CommandSplitAlgorithm(RTsettings::saOld);
            break;
         case tNoOverlap:
            CommandSplitAlgorithm(RTsettings::saNoOverlap);
            break;
         default:
            CommandGetAlgorithm();
         }
         break;

      case tChooseSubtree:
         curToken = Scanner(p, tstr);
         switch (curToken)
         {
         case tArea:
            CommandChooseSubtreeAlgorithm(RTsettings::cstArea);
            break;
         case tOverlap:
            CommandChooseSubtreeAlgorithm(RTsettings::cstOverlap);
            break;
         default:
            CommandGetAlgorithm();
         }
         break;

      case tUnion:
         curToken = Scanner(p, tstr);
         switch (curToken)
         {
         case tInsCT:
            CommandUnionMode(RTsettings::unInsCT);
            break;
         case tInsRefT:
            CommandUnionMode(RTsettings::unInsRefT);
            break;
         default:
            CommandGetAlgorithm();
         }
         break;

      case tImport:
         CommandImport(GetFileName(p));
         break;

      case tDebug:
         curToken = Scanner(p, tstr);
         if (curToken != tOn && curToken != tOff) CommandGetDebug();
         else CommandDebug(curToken == tOn);
         break;

      case tProperties:
         curToken = Scanner(p, tstr);
         CommandProperties(curToken == tCompare);
         break;

      case tInfo:
          curToken = Scanner(p, tstr);
          switch (curToken)
          {
          case tNodes:
             CommandInfoNodes();
             break;

          case tOverUnderFlows:
             curToken = Scanner(p, tstr);
             switch (curToken)
             {
             case tOn:
             case tOff:
                CommandInfoSet(it_flows, curToken == tOn);
                break;
             case tOut:
                CommandInfoOut(it_flows);
                break;
             default:
                Error(eMissingOnOffOut);
             }
             break;
             
          case tInsert:
             curToken = Scanner(p, tstr);
             switch (curToken)
             {
             case tOn:
             case tOff:
                CommandInfoSet(it_insert, curToken == tOn);
                break;
             case tOut:
                CommandInfoOut(it_insert);
                break;
             default:
                Error(eMissingOnOffOut);
             }
             break;
             
          case tSearch:
             curToken = Scanner(p, tstr);
             switch (curToken)
             {
             case tOn:
             case tOff:
                CommandInfoSet(it_search, curToken == tOn);
                break;
             case tOut:
                CommandInfoOut(it_search);
                break;
             default:
                Error(eMissingOnOffOut);
             }
             break;
             
          case tSplit:
             curToken = Scanner(p, tstr);
             switch (curToken)
             {
             case tOn:
             case tOff:
                CommandInfoSet(it_split, curToken == tOn);
                break;
             case tOut:
                CommandInfoOut(it_split);
                break;
             default:
                Error(eMissingOnOffOut);
             }
             break;
             
          default:
             outstr << "Parser warning: Info keywords: flows, insert, search, split" 
                    << endl;
             break;
          }
          break;

      case tVisualize:
         curToken = Scanner(p, tstr);
         if (isdigit(*tstr) || *tstr == '-') 
         {
            level = atol(tstr);
            curToken = Scanner(p, tstr);
         }
         else level = 0;
         switch (curToken)
         {
         case tTree : vobj = voTree;  break;
         case tLevel: vobj = voLevel; break;
         case tNode : vobj = voNode;  break;
         case tPath : vobj = voPath;  break;
         case tOff  : vobj = voNone;  break;
         default: 
            Error (eWrongVisualizationObject);
         }
         curToken = Scanner(p, tstr);
         CommandVisualize (vobj, level, isdigit(*tstr) ? atof(tstr) : 0.0);
         break;
          
      case tOutput:
         if (*p == ' ' ) p++;
         CommandOutput(p);
         break;

      case tOutFile:
         CommandOutFile(GetFileName(p));
         break;

      default  :
      	 Error (eUnknownCommand);
      }
      CommandPrompt();
   }
}