示例#1
0
string ParamSet::FindOneFilename(const string &name, const string &d) const {
    string filename = FindOneString(name, "");
    if (filename == "")
        return d;
    filename = AbsolutePath(ResolveFilename(filename));
    return filename;
}
  bool ParseArgs(const CompilerInstance &CI,
                 const std::vector<std::string> &Args) override {
    StringRef DB = "yaml";
    StringRef Input;

    // Parse the extra command line args.
    // FIXME: This is very limited at the moment.
    for (StringRef Arg : Args) {
      if (Arg.startswith("-db="))
        DB = Arg.substr(strlen("-db="));
      else if (Arg.startswith("-input="))
        Input = Arg.substr(strlen("-input="));
    }

    llvm::ErrorOr<std::unique_ptr<include_fixer::YamlSymbolIndex>> SymbolIdx(
        nullptr);
    if (DB == "yaml") {
      if (!Input.empty()) {
        SymbolIdx = include_fixer::YamlSymbolIndex::createFromFile(Input);
      } else {
        // If we don't have any input file, look in the directory of the first
        // file and its parents.
        const FrontendOptions &FO = CI.getFrontendOpts();
        SmallString<128> AbsolutePath(
            tooling::getAbsolutePath(FO.Inputs[0].getFile()));
        StringRef Directory = llvm::sys::path::parent_path(AbsolutePath);
        SymbolIdx = include_fixer::YamlSymbolIndex::createFromDirectory(
            Directory, "find_all_symbols_db.yaml");
      }
    }
    SymbolIndexMgr->addSymbolIndex(std::move(*SymbolIdx));
    return true;
  }
示例#3
0
void ParamSet::AddSampledSpectrumFiles(const string &name, const char **names,
        int nItems) {
    EraseSpectrum(name);
    Spectrum *s = new Spectrum[nItems];
    for (int i = 0; i < nItems; ++i) {
        string fn = AbsolutePath(ResolveFilename(names[i]));
        if (cachedSpectra.find(fn) != cachedSpectra.end()) {
            s[i] = cachedSpectra[fn];
            continue;
        }

        vector<float> vals;
        if (!ReadFloatFile(fn.c_str(), &vals)) {
            Warning("Unable to read SPD file \"%s\".  Using black distribution.",
                    fn.c_str());
            s[i] = Spectrum(0.);
        }
        else {
            if (vals.size() % 2) {
                Warning("Extra value found in spectrum file \"%s\". "
                        "Ignoring it.", fn.c_str());
            }
            vector<float> wls, v;
            for (uint32_t j = 0; j < vals.size() / 2; ++j) {
                wls.push_back(vals[2*j]);
                v.push_back(vals[2*j+1]);
            }
            s[i] = Spectrum::FromSampled(&wls[0], &v[0], wls.size());
        }
        cachedSpectra[fn] = s[i];
    }

    spectra.push_back(new ParamSetItem<Spectrum>(name, s, nItems));
    delete[] s;
}
示例#4
0
string DaemonConfig::RunDirectory( void )
{
 string Data = NormalizeString( Parse_XML( Parse_XML( ConfigurationXML, "resource" ), "run_directory" ) );
 if( Data.empty() )
  CRITICAL_LOG_RETURN( Data, "DaemonConfig::RunDirectory; No data in run_directory tag found" )
 else {
  Data = AbsolutePath( Data );
  VERBOSE_DEBUG_LOG_RETURN( Data, "DaemonConfig::RunDirectory; Returned " << Data );
 }
}
示例#5
0
string DaemonConfigProjectApplication::Check_System_Limits_Script( void )
{
 string Data = NormalizeString( Parse_XML( ApplicationCache, "check_system_limits_script" ) );
 if( Data.empty() ) {
  CRITICAL_LOG_RETURN( Data, "DaemonConfigProjectApplication::Check_System_Limits_Script; No data in check_system_limits_script tag found" )
 } else {
  Data = AbsolutePath( Data );
  VERBOSE_DEBUG_LOG_RETURN( Data, "DaemonConfigProjectApplication::Check_System_Limits_Script; Returned " << Data );
 }
}
示例#6
0
string DaemonConfigProjectApplication::Job_Abort_Script( void )
{
 string Data = NormalizeString( Parse_XML( ApplicationCache, "job_abort_script" ) );
 if( Data.empty() ) {
  CRITICAL_LOG_RETURN( Data, "DaemonConfigProjectApplication::Job_Abort_Script; No data in job_abort_script tag found" )
 } else {
  Data = AbsolutePath( Data );
  VERBOSE_DEBUG_LOG_RETURN( Data, "DaemonConfigProjectApplication::Job_Abort_Script; Returned " << Data );
 }
}
示例#7
0
string DaemonConfig::Resource_Certificate_File( void )
{
 string Data = NormalizeString( Parse_XML( Parse_XML( ConfigurationXML, "resource" ), "resource_certificate_file" ) );
 if( Data.empty() ) {
  CRITICAL_LOG_RETURN( Data, "DaemonConfig::Resource_Certificate_File; No data in resource_certificate_file tag found" )
 } else {
  Data = AbsolutePath( Data );
  VERBOSE_DEBUG_LOG_RETURN( Data, "DaemonConfig::Resource_Certificate_File; Returned " << Data );
 }
}
示例#8
0
EncryptionInfoPtr ManifestItem::GetEncryptionInfo() const
{
    ContainerPtr container = GetPackage()->GetContainer();
    string abs = AbsolutePath();
    if (abs.at(0) == '/')
    {
        abs = abs.substr(1, abs.length()-1);
    }
    return container->EncryptionInfoForPath(abs);
}
示例#9
0
unique_ptr<AsyncByteStream> ManifestItem::AsyncReader() const
{
    auto package = GetPackage();
    if ( !package )
        return nullptr;
    
    auto container = package->GetContainer();
    if ( !container )
        return nullptr;
    
    return container->GetArchive()->AsyncByteStreamAtPath(AbsolutePath());
}
示例#10
0
CompilationDatabase *
CompilationDatabase::autoDetectFromDirectory(StringRef SourceDir,
                                             std::string &ErrorMessage) {
  SmallString<1024> AbsolutePath(getAbsolutePath(SourceDir));

  CompilationDatabase *DB = findCompilationDatabaseFromDirectory(AbsolutePath,
                                                                 ErrorMessage);

  if (!DB)
    ErrorMessage = ("Could not auto-detect compilation database from directory \"" +
                   SourceDir + "\"\n" + ErrorMessage).str();
  return DB;
}
示例#11
0
CompilationDatabase *
CompilationDatabase::autoDetectFromSource(StringRef SourceFile,
                                          std::string &ErrorMessage) {
  SmallString<1024> AbsolutePath(getAbsolutePath(SourceFile));
  StringRef Directory = llvm::sys::path::parent_path(AbsolutePath);

  CompilationDatabase *DB = findCompilationDatabaseFromDirectory(Directory,
                                                                 ErrorMessage);

  if (!DB)
    ErrorMessage = ("Could not auto-detect compilation database for file \"" +
                   SourceFile + "\"\n" + ErrorMessage).str();
  return DB;
}
SEARCH_STACK* PROJECT::SchSearchS()
{
    SEARCH_STACK* ss = (SEARCH_STACK*) GetElem( PROJECT::ELEM_SCH_SEARCH_STACK );

    wxASSERT( !ss || dynamic_cast<SEARCH_STACK*>( GetElem( PROJECT::ELEM_SCH_SEARCH_STACK ) ) );

    if( !ss )
    {
        ss = new SEARCH_STACK();

        // Make PROJECT the new SEARCH_STACK owner.
        SetElem( PROJECT::ELEM_SCH_SEARCH_STACK, ss );

        // to the empty SEARCH_STACK for SchSearchS(), add project dir as first
        ss->AddPaths( m_project_name.GetPath() );

        // next add the paths found in *.pro, variable "LibDir"
        wxString        libDir;

        try
        {
            PART_LIBS::LibNamesAndPaths( this, false, &libDir );
        }
        catch( const IO_ERROR& DBG( ioe ) )
        {
            DBG(printf( "%s: %s\n", __func__, TO_UTF8( ioe.What() ) );)
        }

        if( !!libDir )
        {
            wxArrayString   paths;

            SEARCH_STACK::Split( &paths, libDir );

            for( unsigned i =0; i<paths.GetCount();  ++i )
            {
                wxString path = AbsolutePath( paths[i] );

                ss->AddPaths( path );     // at the end
            }
        }

        // append all paths from aSList
        add_search_paths( ss, Kiface().KifaceSearch(), -1 );

        // addLibrarySearchPaths( SEARCH_STACK* aSP, wxConfigBase* aCfg )
        // This is undocumented, but somebody wanted to store !schematic!
        // library search paths in the .kicad_common file?
        add_search_paths( ss, Pgm().CommonSettings(), -1 );
    }
示例#13
0
/// \brief Returns the absolute path of 'File', by prepending it with
/// 'BaseDirectory' if 'File' is not absolute.
///
/// Otherwise returns 'File'.
/// If 'File' starts with "./", the returned path will not contain the "./".
/// Otherwise, the returned path will contain the literal path-concatenation of
/// 'BaseDirectory' and 'File'.
///
/// \param File Either an absolute or relative path.
/// \param BaseDirectory An absolute path.
static std::string getAbsolutePath(
    StringRef File, StringRef BaseDirectory) {
  assert(llvm::sys::path::is_absolute(BaseDirectory));
  if (llvm::sys::path::is_absolute(File)) {
    return File;
  }
  StringRef RelativePath(File);
  if (RelativePath.startswith("./")) {
    RelativePath = RelativePath.substr(strlen("./"));
  }
  llvm::SmallString<1024> AbsolutePath(BaseDirectory);
  llvm::sys::path::append(AbsolutePath, RelativePath);
  return AbsolutePath.str();
}
示例#14
0
/// \brief Returns the absolute path of 'File', by prepending it with
/// 'BaseDirectory' if 'File' is not absolute.
///
/// Otherwise returns 'File'.
/// If 'File' starts with "./", the returned path will not contain the "./".
/// Otherwise, the returned path will contain the literal path-concatenation of
/// 'BaseDirectory' and 'File'.
///
/// \param File Either an absolute or relative path.
/// \param BaseDirectory An absolute path.
static std::string getAbsolutePath(
    StringRef File, StringRef BaseDirectory) {
  SmallString<1024> PathStorage;
  assert(llvm::sys::path::is_absolute(BaseDirectory));
  if (llvm::sys::path::is_absolute(File)) {
    llvm::sys::path::native(File, PathStorage);
    return PathStorage.str();
  }
  StringRef RelativePath(File);
  // FIXME: Should '.\\' be accepted on Win32?
  if (RelativePath.startswith("./")) {
    RelativePath = RelativePath.substr(strlen("./"));
  }
  llvm::SmallString<1024> AbsolutePath(BaseDirectory);
  llvm::sys::path::append(AbsolutePath, RelativePath);
  llvm::sys::path::native(Twine(AbsolutePath), PathStorage);
  return PathStorage.str();
}
示例#15
0
std::string getAbsolutePath(StringRef File) {
  SmallString<1024> BaseDirectory;
  if (const char *PWD = ::getenv("PWD"))
    BaseDirectory = PWD;
  else
    llvm::sys::fs::current_path(BaseDirectory);
  SmallString<1024> PathStorage;
  if (llvm::sys::path::is_absolute(File)) {
    llvm::sys::path::native(File, PathStorage);
    return PathStorage.str();
  }
  StringRef RelativePath(File);
  // FIXME: Should '.\\' be accepted on Win32?
  if (RelativePath.startswith("./")) {
    RelativePath = RelativePath.substr(strlen("./"));
  }
  SmallString<1024> AbsolutePath(BaseDirectory);
  llvm::sys::path::append(AbsolutePath, RelativePath);
  llvm::sys::path::native(Twine(AbsolutePath), PathStorage);
  return PathStorage.str();
}
示例#16
0
void ParamSet::AddSampledSpectrumFiles(const std::string &name,
                                       const char **names, int nValues) {
    EraseSpectrum(name);
    std::unique_ptr<Spectrum[]> s(new Spectrum[nValues]);
    for (int i = 0; i < nValues; ++i) {
        std::string fn = AbsolutePath(ResolveFilename(names[i]));
        if (cachedSpectra.find(fn) != cachedSpectra.end()) {
            s[i] = cachedSpectra[fn];
            continue;
        }

        std::vector<Float> vals;
        if (!ReadFloatFile(fn.c_str(), &vals)) {
            Warning(
                "Unable to read SPD file \"%s\".  Using black distribution.",
                fn.c_str());
            s[i] = Spectrum(0.);
        } else {
            if (vals.size() % 2) {
                Warning(
                    "Extra value found in spectrum file \"%s\". "
                    "Ignoring it.",
                    fn.c_str());
            }
            std::vector<Float> wls, v;
            for (size_t j = 0; j < vals.size() / 2; ++j) {
                wls.push_back(vals[2 * j]);
                v.push_back(vals[2 * j + 1]);
            }
            s[i] = Spectrum::FromSampled(&wls[0], &v[0], wls.size());
        }
        cachedSpectra[fn] = s[i];
    }

    std::shared_ptr<ParamSetItem<Spectrum>> psi(
        new ParamSetItem<Spectrum>(name, std::move(s), nValues));
    spectra.push_back(psi);
}
示例#17
0
bool ManifestItem::CanLoadDocument() const
{
	return GetPackage()->GetContainer()->FileExistsAtPath(AbsolutePath());
}
示例#18
0
文件: eleeye.cpp 项目: gucong/robotxq
int main(void) {
    int i;
    bool bPonderTime;
    UcciCommStruct UcciComm;
    const char *szEngineName;
    PositionStruct posProbe;
#ifdef _WIN32
    HMODULE hModule;
#else
    void *hModule;
#endif

    int mv, stat;
    char fen[1024];

    /* disable stdio buffering */
    if (setvbuf(stdin, NULL, _IONBF, 0) != 0)
        perror("setvbuf");
    if (setvbuf(stdout, NULL, _IONBF, 0) != 0)
        perror("setvbuf");

    // myfp = fopen("test", "w+");
    // fputs("test\n", myfp);

    xb_mv_left = 40;
    xb_mv_ctrl = 40;
    xb_tm_left = 30000;
    xb_tm_ctrl = 30000;
    xb_tm_incr = 0;
    xb_post = 0;
    xb_ponder = 0;
    xb_depth = UCCI_MAX_DEPTH;
    xb_force = 0;
    Search.nHashSize = 4;
    Search.nRandom = 0;
    Search.nRandomSave = 2;

    /* if not working with autotools */
#ifndef PKGDATADIR
#define PKGDATADIR "."
#endif

    LocatePath(Search.szBookFile, PKGDATADIR "/book.dat");
    //LocatePath(Search.szBookFile, "book.dat");
    LocatePath(Search.szLibEvalFile, cszLibEvalFile);
    hModule = LoadEvalApi(Search.szLibEvalFile);

    bPonderTime = false;
    PreGenInit();
    NewHash(24); // 24=16MB, 25=32MB, 26=64MB, ...
    Search.pos.FromFen(cszStartFen);
    Search.pos.nDistance = 0;
    Search.PreEvaluate(&Search.pos, &PreEval);
    Search.nBanMoves = 0;
    Search.bQuit = Search.bBatch = Search.bDebug = Search.bAlwaysCheck = false;
    Search.bUseHash = Search.bUseBook = Search.bNullMove = Search.bKnowledge = true;
    Search.bIdle = false;
    Search.nCountMask = INTERRUPT_COUNT - 1;
    Search.nRandomMask = 0;
    Search.rc4Random.InitRand();

    szEngineName = Search.GetEngineName();
    if (szEngineName == NULL) {
        PrintLn("id name ElephantEye");
    } else {
        printf("id name %s / ElephantEye\n", szEngineName);
        fflush(stdout);
    }
    PrintLn("id version 3.15");
    PrintLn("id copyright 2004-2008 www.elephantbase.net");
    PrintLn("id author Morning Yellow");
    PrintLn("id user ElephantEye Test Team");

    while (BootLine() != UCCI_COMM_XBOARD);
    // PrintLn("option usemillisec type check default true");
    // PrintLn("option promotion type check default false");
    // PrintLn("option batch type check default false");
    // PrintLn("option debug type check default false");
    // PrintLn("option ponder type check default false");
    // PrintLn("option alwayscheck type check default false");
    // PrintLn("option usehash type check default true");
    // PrintLn("option usebook type check default true");
    // printf("option bookfiles type string default %s\n", Search.szBookFile);
    // fflush(stdout);
    // printf("option evalapi type string default %s\n", szLibEvalFile);
    // fflush(stdout);
    // PrintLn("option hashsize type spin min 16 max 1024 default 16");
    // PrintLn("option idle type combo var none var small var medium var large default none");
    // PrintLn("option pruning type combo var none var small var medium var large default large");
    // PrintLn("option knowledge type combo var none var small var medium var large default large");
    // PrintLn("option randomness type combo var none var small var medium var large default none");
    // PrintLn("option newgame type button");
    // PrintLn("ucciok");

    // 以下是接收指令和提供对策的循环体
    while (!Search.bQuit) {
        switch (IdleLine(UcciComm, Search.bDebug)) {
        case UCCI_COMM_STOP:
            PrintLn("nobestmove");
            break;
        case UCCI_COMM_POSITION:
            BuildPos(Search.pos, UcciComm);
            Search.pos.nDistance = 0;
            Search.PreEvaluate(&Search.pos, &PreEval);
            Search.nBanMoves = 0;
            hint_mv = 0;
            break;
        case UCCI_COMM_NEW:
            Search.pos.FromFen(cszStartFen);
            Search.pos.nDistance = 0;
            Search.PreEvaluate(&Search.pos, &PreEval);
            Search.nBanMoves = 0;
            xb_force = 0;
            xb_tm_left = xb_tm_ctrl;
            xb_mv_left = xb_mv_ctrl;
            xb_depth = UCCI_MAX_DEPTH;
            hint_mv = 0;
            break;
        case UCCI_COMM_BANMOVES:
            Search.nBanMoves = UcciComm.nBanMoveNum;
            for (i = 0; i < UcciComm.nBanMoveNum; i ++) {
                Search.wmvBanList[i] = COORD_MOVE(UcciComm.lpdwBanMovesCoord[i]);
            }
            break;
        case UCCI_COMM_SETOPTION:
            switch (UcciComm.Option) {
            case UCCI_OPTION_PROMOTION:
                PreEval.bPromotion = UcciComm.bCheck;
                break;
            case UCCI_OPTION_ALWAYSCHECK:
                Search.bAlwaysCheck = UcciComm.bCheck;
                break;
            case UCCI_OPTION_USEHASH:
                Search.bUseHash = UcciComm.bCheck;
                break;
            case UCCI_OPTION_USEBOOK:
                Search.bUseBook = UcciComm.bCheck;
                break;
            case UCCI_OPTION_BOOKFILES:
                if (AbsolutePath(UcciComm.szOption)) {
                    strcpy(Search.szBookFile, UcciComm.szOption);
                } else {
                    LocatePath(Search.szBookFile, UcciComm.szOption);
                }
                break;
            case UCCI_OPTION_EVALAPI:
                if (AbsolutePath(UcciComm.szOption)) {
                    strcpy(Search.szLibEvalFile, UcciComm.szOption);
                } else {
                    LocatePath(Search.szLibEvalFile, UcciComm.szOption);
                }
                FreeEvalApi(hModule);
                hModule = LoadEvalApi(Search.szLibEvalFile);
                break;
            case UCCI_OPTION_HASHSIZE:
                DelHash();
                Search.nHashSize = UcciComm.nSpin;
                NewHash(UcciComm.nSpin + 20);
                break;
            case UCCI_OPTION_PRUNING:
                Search.bNullMove = UcciComm.bCheck;
                break;
            case UCCI_OPTION_KNOWLEDGE:
                Search.bKnowledge = UcciComm.bCheck;
                break;
            case UCCI_OPTION_RANDOMNESS:
                Search.nRandom = UcciComm.nSpin;
                if (UcciComm.nSpin)
                    Search.nRandomSave = UcciComm.nSpin;
                Search.nRandomMask = (1 << Search.nRandom) - 1;
                break;
            default:
                break;
            }
            break;
        case UCCI_COMM_GO:
            // Search.bPonder = UcciComm.bPonder;
            // Search.bDraw = UcciComm.bDraw;
            // switch (UcciComm.Go) {
            // case UCCI_GO_DEPTH:
            //   Search.nGoMode = GO_MODE_INFINITY;
            //   Search.nNodes = 0;
            //   SearchMain(UcciComm.nDepth);
            //   break;
            // case UCCI_GO_NODES:
            //   Search.nGoMode = GO_MODE_NODES;
            //   Search.nNodes = UcciComm.nNodes;
            //   SearchMain(UCCI_MAX_DEPTH);
            //   break;
            // case UCCI_GO_TIME_MOVESTOGO:
            // case UCCI_GO_TIME_INCREMENT:
            //   Search.nGoMode = GO_MODE_TIMER;
            //   if (UcciComm.Go == UCCI_GO_TIME_MOVESTOGO) {
            //     // 对于时段制,把剩余时间平均分配到每一步,作为适当时限。
            //     // 剩余步数从1到5,最大时限依次是剩余时间的100%、90%、80%、70%和60%,5以上都是50%
            //     Search.nProperTimer = UcciComm.nTime / UcciComm.nMovesToGo;
            //     Search.nMaxTimer = UcciComm.nTime * MAX(5, 11 - UcciComm.nMovesToGo) / 10;
            //   } else {
            //     // 对于加时制,假设棋局会在20回合内结束,算出平均每一步的适当时限,最大时限是剩余时间的一半
            //     Search.nProperTimer = UcciComm.nTime / 20 + UcciComm.nIncrement;
            //     Search.nMaxTimer = UcciComm.nTime / 2;
            //   }
            //   // 如果是后台思考的时间分配策略,那么适当时限设为原来的1.25倍
            //   Search.nProperTimer += (bPonderTime ? Search.nProperTimer / 4 : 0);
            //   Search.nMaxTimer = MIN(Search.nMaxTimer, Search.nProperTimer * 10);
            //   SearchMain(UCCI_MAX_DEPTH);
            //   break;
            // default:
            //   break;
            // }
            xb_force = 0;
            Search.nGoMode = GO_MODE_TIMER;
            prepare_clock();
            SearchMain(xb_depth);
            update_clock();
            break;
        case UCCI_COMM_PROBE:
            BuildPos(posProbe, UcciComm);
            if (!PopHash(posProbe)) {
                PopLeaf(posProbe);
            }
            break;
        case UCCI_COMM_QUIT:
            Search.bQuit = true;
            break;
        case UCCI_COMM_UNDO:
            if (Search.pos.nDistance >= 1)
                Search.pos.UndoMakeMove();
            hint_mv = 0;
            break;
        case UCCI_COMM_REMOVE:
            if (Search.pos.nDistance >= 2) {
                Search.pos.UndoMakeMove();
                Search.pos.UndoMakeMove();
            }
            hint_mv = 0;
            break;
        case UCCI_COMM_USERMOVE:
            mv = COORD_MOVE(UcciComm.dwMoveCoord);
            TryMove(Search.pos, stat, mv);
            switch (stat) {
            case MOVE_ILLEGAL:
                printf("Illegal move: %.4s\n", (char *)&UcciComm.dwMoveCoord);
                break;
            case MOVE_INCHECK:
                printf("Illegal move (in check): %.4s\n", (char *)&UcciComm.dwMoveCoord);
                break;
            case MOVE_DRAW:
                puts("1/2-1/2 {Draw by rule}\n");
                break;
            case MOVE_PERPETUAL_LOSS:
                printf("Illegal move (perpetual attack): %.4s\n", (char *)&UcciComm.dwMoveCoord);
                break;
            case MOVE_PERPETUAL:
                puts("1/2-1/2 {Draw by repetition}\n");
                break;
            case MOVE_MATE:
                if (Search.pos.sdPlayer == 0)
                    puts("1-0 {checkmate or stalemate}\n");
                else
                    puts("0-1 {checkmate or stalemate}\n");
                break;
            default:
                Search.pos.MakeMove(mv);
                if (!xb_force) {
                    prepare_clock();
                    SearchMain(xb_depth);
                    update_clock();
                }
                break;
            }
            break;
        default:
            break;
        }
    }
    DelHash();
    FreeEvalApi(hModule);
    return 0;
}
示例#19
0
int start(void) {
  int i;
  bool bPonderTime;
  UcciCommStruct UcciComm;
  char szLibEvalFile[1024];
  const char *szEngineName;
  PositionStruct posProbe;
#ifdef _WIN32
  HMODULE hModule;  
#else
  void *hModule;
#endif

  if (BootLine() != UCCI_COMM_UCCI) {
    return 0;
  }
  LocatePath(Search.szBookFile, "BOOK.DAT");
  LocatePath(szLibEvalFile, cszLibEvalFile);
  hModule = LoadEvalApi(szLibEvalFile);
  bPonderTime = false;
  PreGenInit();
  NewHash(24); // 24=16MB, 25=32MB, 26=64MB, ...
  Search.pos.FromFen("rnbakabnr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/9/RNBAKABNR b - - 0 1");
  Search.pos.nDistance = 0;
  Search.PreEvaluate(&Search.pos, &PreEval);
  Search.nBanMoves = 0;
  Search.bQuit = Search.bBatch = Search.bDebug = Search.bAlwaysCheck = false;
  Search.bUseHash = Search.bUseBook = Search.bNullMove = Search.bKnowledge = true;
  Search.bIdle = false;
  Search.nCountMask = INTERRUPT_COUNT - 1;
  Search.nRandomMask = 0;
  Search.rc4Random.InitRand();
  szEngineName = Search.GetEngineName();
  if (szEngineName == NULL) {
    PrintLn("#id name ElephantEye");
  } else {
	  //printf("id name %s / ElephantEye\n", szEngineName);
	  //fflush(stdout);
	  pipeOutputWrite("id name %s / ElephantEye\n", szEngineName);
  }
  PrintLn("#id version 3.15");
  PrintLn("#id copyright 2004-2008 www.elephantbase.net");
  PrintLn("#id author Morning Yellow");
  PrintLn("#id user ElephantEye Test Team");
  PrintLn("#option usemillisec type check default true");
  PrintLn("#option promotion type check default false");
  PrintLn("#option batch type check default false");
  PrintLn("#option debug type check default false");
  PrintLn("#option ponder type check default false");
  PrintLn("#option alwayscheck type check default false");
  PrintLn("#option usehash type check default true");
  PrintLn("#option usebook type check default true");
  //printf("option bookfiles type string default %s\n", Search.szBookFile);
  //fflush(stdout);
  pipeOutputWrite("#option bookfiles type string default %s\n", Search.szBookFile);
  //printf("option evalapi type string default %s\n", szLibEvalFile);
  //fflush(stdout);
  pipeOutputWrite("#option evalapi type string default %s\n", szLibEvalFile);
  PrintLn("#option hashsize type spin min 16 max 1024 default 16");
  PrintLn("#option idle type combo var none var small var medium var large default none");
  PrintLn("#option pruning type combo var none var small var medium var large default large");
  PrintLn("#option knowledge type combo var none var small var medium var large default large");
  PrintLn("#option randomness type combo var none var small var medium var large default none");
  PrintLn("#option newgame type button");
  PrintLn("#ucciok");

  // 以下是接收指令和提供对策的循环体
  while (!Search.bQuit) {
    switch (IdleLine(UcciComm, Search.bDebug)) {
    case UCCI_COMM_ISREADY:
      PrintLn("#readyok");
      break;
    case UCCI_COMM_STOP:
      PrintLn("#nobestmove");
      break;
    case UCCI_COMM_POSITION:
      BuildPos(Search.pos, UcciComm);
      Search.pos.nDistance = 0;
      Search.PreEvaluate(&Search.pos, &PreEval);
      Search.nBanMoves = 0;
      break;
    case UCCI_COMM_BANMOVES:
      Search.nBanMoves = UcciComm.nBanMoveNum;
      for (i = 0; i < UcciComm.nBanMoveNum; i ++) {
        Search.wmvBanList[i] = COORD_MOVE(UcciComm.lpdwBanMovesCoord[i]);
      }
      break;
    case UCCI_COMM_SETOPTION:
      switch (UcciComm.Option) {
      case UCCI_OPTION_PROMOTION:
        PreEval.bPromotion = UcciComm.bCheck;
        break;
      case UCCI_OPTION_BATCH:
        Search.bBatch = UcciComm.bCheck;
        break;
      case UCCI_OPTION_DEBUG:
        Search.bDebug = UcciComm.bCheck;
        break;
      case UCCI_OPTION_PONDER:
        bPonderTime = UcciComm.bCheck;
        break;
      case UCCI_OPTION_ALWAYSCHECK:
        Search.bAlwaysCheck = UcciComm.bCheck;
        break;
      case UCCI_OPTION_USEHASH:
        Search.bUseHash = UcciComm.bCheck;
        break;
      case UCCI_OPTION_USEBOOK:
        Search.bUseBook = UcciComm.bCheck;
        break;
      case UCCI_OPTION_BOOKFILES:
        if (AbsolutePath(UcciComm.szOption)) {
          strcpy(Search.szBookFile, UcciComm.szOption);
        } else {
          LocatePath(Search.szBookFile, UcciComm.szOption);
        }
        break;
      case UCCI_OPTION_EVALAPI:
        if (AbsolutePath(UcciComm.szOption)) {
          strcpy(szLibEvalFile, UcciComm.szOption);
        } else {
          LocatePath(szLibEvalFile, UcciComm.szOption);
        }
        FreeEvalApi(hModule);
        hModule = LoadEvalApi(szLibEvalFile);
        break;
      case UCCI_OPTION_HASHSIZE:
        DelHash();
        i = 19; // 小于1,分配0.5M置换表
        while (UcciComm.nSpin > 0) {
          UcciComm.nSpin /= 2;
          i ++;
        }
        NewHash(MAX(i, 24)); // 最小的置换表设为16M
        break;
      case UCCI_OPTION_IDLE:
        switch (UcciComm.Grade) {
        case UCCI_GRADE_NONE:
          Search.bIdle = false;
          Search.nCountMask = INTERRUPT_COUNT - 1;
          break;
        case UCCI_GRADE_SMALL:
          Search.bIdle = true;
          Search.nCountMask = INTERRUPT_COUNT / 4 - 1;
          break;
        case UCCI_GRADE_MEDIUM:
          Search.bIdle = true;
          Search.nCountMask = INTERRUPT_COUNT / 16 - 1;
          break;
        case UCCI_GRADE_LARGE:
          Search.bIdle = true;
          Search.nCountMask = INTERRUPT_COUNT / 64 - 1;
          break;
        default:
          break;
        }
        break;
      case UCCI_OPTION_PRUNING:
        Search.bNullMove = (UcciComm.Grade != UCCI_GRADE_NONE);
        break;
      case UCCI_OPTION_KNOWLEDGE:
        Search.bKnowledge = (UcciComm.Grade != UCCI_GRADE_NONE);
        break;
      case UCCI_OPTION_RANDOMNESS:
        switch (UcciComm.Grade) {
        case UCCI_GRADE_NONE:
          Search.nRandomMask = 0;
          break;
        case UCCI_GRADE_SMALL:
          Search.nRandomMask = 1;
          break;
        case UCCI_GRADE_MEDIUM:
          Search.nRandomMask = 3;
          break;
        case UCCI_GRADE_LARGE:
          Search.nRandomMask = 7;
          break;
        default:
          break;
        }
        break;
      default:
        break;
      }
      break;
    case UCCI_COMM_GO:
      Search.bPonder = UcciComm.bPonder;
      Search.bDraw = UcciComm.bDraw;
      switch (UcciComm.Go) {
      case UCCI_GO_DEPTH:
        Search.nGoMode = GO_MODE_INFINITY;
        Search.nNodes = 0;
        SearchMain(UcciComm.nDepth);
        break;
      case UCCI_GO_NODES:
        Search.nGoMode = GO_MODE_NODES;
        Search.nNodes = UcciComm.nNodes;
        SearchMain(UCCI_MAX_DEPTH);
        break;
      case UCCI_GO_TIME_MOVESTOGO:
      case UCCI_GO_TIME_INCREMENT:
        Search.nGoMode = GO_MODE_TIMER;
        if (UcciComm.Go == UCCI_GO_TIME_MOVESTOGO) {
          // 对于时段制,把剩余时间平均分配到每一步,作为适当时限。
          // 剩余步数从1到5,最大时限依次是剩余时间的100%、90%、80%、70%和60%,5以上都是50%
          Search.nProperTimer = UcciComm.nTime / UcciComm.nMovesToGo;
          Search.nMaxTimer = UcciComm.nTime * MAX(5, 11 - UcciComm.nMovesToGo) / 10;
        } else {
          // 对于加时制,假设棋局会在20回合内结束,算出平均每一步的适当时限,最大时限是剩余时间的一半
          Search.nProperTimer = UcciComm.nTime / 20 + UcciComm.nIncrement;
          Search.nMaxTimer = UcciComm.nTime / 2;
        }
        // 如果是后台思考的时间分配策略,那么适当时限设为原来的1.25倍
        Search.nProperTimer += (bPonderTime ? Search.nProperTimer / 4 : 0);
        Search.nMaxTimer = MIN(Search.nMaxTimer, Search.nProperTimer * 10);
        SearchMain(UCCI_MAX_DEPTH);
        break;
      default:
        break;
      }
      break;
    case UCCI_COMM_PROBE:
      BuildPos(posProbe, UcciComm);
      if (!PopHash(posProbe)) {
        PopLeaf(posProbe);
      }
      break;
    case UCCI_COMM_QUIT:
      Search.bQuit = true;
      break;
    default:
      break;
    }
  }
  DelHash();
  FreeEvalApi(hModule);
  PrintLn("#bye");
  return 0;
}
示例#20
0
int main( int argc, char **argv ) {
    struct stat fstat;
    int 		c, err, maxsize_set, maxlife_set;
    int			do_rescan, do_expire, do_list, print_stat, do_update_param, print_books, is_profile, nfsen_format;
    char		*maxsize_string, *lifetime_string, *datadir;
    uint64_t	maxsize, lifetime, low_water;
    uint32_t	runtime;
    channel_t	*channel, *current_channel;

    maxsize_string = lifetime_string = NULL;
    datadir = NULL;
    maxsize = lifetime = 0;
    do_rescan  		= 0;
    do_expire  		= 0;
    do_list	   		= 0;
    do_update_param = 0;
    is_profile		= 0;
    print_stat		= 0;
    print_books		= 0;
    maxsize_set 	= 0;
    maxlife_set 	= 0;
    low_water		= 0;
    nfsen_format	= 0;
    runtime			= 0;

    while ((c = getopt(argc, argv, "e:hl:L:T:Ypr:s:t:u:w:")) != EOF) {
        switch (c) {
        case 'h':
            usage(argv[0]);
            exit(0);
            break;
        case 'l':
            CheckDataDir(datadir);
            datadir = optarg;
            do_list = 1;
            print_stat = 1;
            break;
        case 'L':
            CheckDataDir(datadir);
            datadir = optarg;
            print_stat  = 1;
            print_books = 1;
            break;
        case 'p':
            is_profile = 1;
            break;
        case 'r':
            CheckDataDir(datadir);
            do_rescan = 1;
            print_stat = 1;
            datadir = optarg;
            break;
        case 'e':
            CheckDataDir(datadir);
            datadir = optarg;
            do_expire = 1;
            print_stat = 1;
            break;
        case 's':
            if ( ParseSizeDef(optarg, &maxsize ) == 0 )
                exit(250);
            maxsize_set = 1;
            break;
        case 't':
            if ( ParseTimeDef(optarg, &lifetime ) == 0 )
                exit(250);
            maxlife_set = 1;
            break;
        case 'u':
            CheckDataDir(datadir);
            datadir = optarg;
            do_update_param = 1;
            break;
        case 'w':
            low_water = strtoll(optarg, NULL, 10);
            if ( low_water > 100 ) {
                fprintf(stderr, "Water mark > 100%%\n");
                exit(250);
            }
            if ( low_water == 0 )
                low_water = 100;
            break;
        case 'T':
            runtime = strtoll(optarg, NULL, 10);
            if ( runtime > 3600 ) {
                fprintf(stderr, "Runtime > 3600 (1h)\n");
                exit(250);
            }
            break;
        case 'Y':
            nfsen_format = 1;
            break;
        default:
            usage(argv[0]);
            exit(250);
        }

    }

    datadir = AbsolutePath(datadir);

    if ( !datadir ) {
        fprintf(stderr, "Missing data directory\n");
        usage(argv[0]);
        exit(250);
    }

    err  = stat(datadir, &fstat);
    if ( !(fstat.st_mode & S_IFDIR) ) {
        fprintf(stderr, "No such directory: %s\n", datadir);
        exit(250);
    }

    channel = GetChannelList(datadir, is_profile, do_rescan);
    // GetChannelList(datadir, is_profile, do_rescan);
    if ( !channel ) {
        exit(250);
    }

// printf("Size: %llu, time: %llu\n", maxsize, lifetime);

    // update water mark only, when not listing
    if ( !is_profile && !do_list && low_water )
        channel->dirstat->low_water = low_water;

    /* process do_list first: if the UpdateBookStat results in a FORCE_REBUILD,
     * this will immediately done afterwards
     * do_expire will need accurate books as well, so update the books here as well
     */
    if ( do_list || do_expire ) {
        current_channel = channel;
        while ( current_channel ) {
            if ( current_channel->books_stat == BOOKKEEPER_OK ) {
                bookkeeper_t	tmp_books;
                printf("Include nfcapd bookeeping record in %s\n", current_channel->datadir);
                ClearBooks(current_channel->books, &tmp_books);
                UpdateBookStat(current_channel->dirstat, &tmp_books);
                if ( current_channel->dirstat->status == FORCE_REBUILD )
                    current_channel->do_rescan = 1;
            }
            current_channel = current_channel->next;
        }
    }

    // process do_rescan: make sure stats are up to date, if required
    current_channel = channel;
    while ( current_channel ) {
        if ( current_channel->do_rescan ) {
            int	 i;
            uint64_t last_sequence;

            /* detect new files: If nfcapd adds a new file while we are rescanning the directory
            * this results in inconsistent data for the rescan. Therefore check at the begin and end
            * of the rescan for the sequence number, which reflects the accesss/change to the bookkeeping record
            * It's assumed, that such an event does not occure more than once. However, loop 3 times max
            */
            for ( i=0; i<3; i++ ) {
                last_sequence = BookSequence(current_channel->books);
                printf("Scanning files in %s .. ", current_channel->datadir);
                RescanDir(current_channel->datadir, current_channel->dirstat);
                if ( current_channel->dirstat->numfiles == 0 ) { //nothing found
                    current_channel->status = NOFILES;
                }
                if ( BookSequence(current_channel->books) == last_sequence )
                    break;
                printf("Rescan again, due to file changes in directory!\n");
            }
            if ( BookSequence(current_channel->books) != last_sequence ) {
                fprintf(stderr, "Could not savely rescan the directory. Data is not consistent.\n");
                ReleaseBookkeeper(current_channel->books, DETACH_ONLY);
                if ( current_channel->status == OK )
                    WriteStatInfo(current_channel->dirstat);
                exit(250);
            }
            printf("done.\n");
            if ( current_channel->books_stat == BOOKKEEPER_OK ) {
                printf("Updating nfcapd bookeeping records\n");
                ClearBooks(channel->books, NULL);
            }
        }
        current_channel = current_channel->next;
    }

    // now process do_expire if required
    if ( do_expire ) {
        dirstat_t	old_stat, current_stat;

        if ( is_profile ) {
            current_stat.status = 0;
            current_stat.max_lifetime 	= lifetime;
            current_stat.max_size  		= maxsize;
            current_stat.low_water 		= low_water ? low_water : 98;

            // sum up all channels in the profile
            current_channel = channel;
            current_stat.numfiles = current_channel->dirstat->numfiles;
            current_stat.filesize = current_channel->dirstat->filesize;
            current_stat.first 	  = current_channel->dirstat->first;
            current_stat.last 	  = current_channel->dirstat->last;
            current_channel = current_channel->next;
            while ( current_channel ) {
                current_stat.numfiles += current_channel->dirstat->numfiles;
                current_stat.filesize += current_channel->dirstat->filesize;
                if ( current_channel->dirstat->first && (current_channel->dirstat->first < current_stat.first) )
                    current_stat.first = current_channel->dirstat->first;
                if ( current_channel->dirstat->last > current_stat.last )
                    current_stat.last = current_channel->dirstat->last;

                current_channel = current_channel->next;
            }
            old_stat = current_stat;
            ExpireProfile(channel, &current_stat, maxsize, lifetime, runtime);

        } else {
            // cmd args override dirstat values
            if ( maxsize_set )
                channel->dirstat->max_size     = maxsize;
            else
                maxsize = channel->dirstat->max_size;
            if ( maxlife_set )
                channel->dirstat->max_lifetime = lifetime;
            else
                lifetime = channel->dirstat->max_lifetime;


            old_stat = *(channel->dirstat);
            ExpireDir(channel->datadir, channel->dirstat, maxsize, lifetime, runtime);
            current_stat = *(channel->dirstat);

        }
        // Report, what we have done
        printf("Expired files:      %llu\n", (unsigned long long)(old_stat.numfiles - current_stat.numfiles));
        printf("Expired file size:  %s\n", ScaleValue(old_stat.filesize - current_stat.filesize));
        printf("Expired time range: %s\n\n", ScaleTime(current_stat.first - old_stat.first));
    }

    if ( !is_profile && do_update_param ) {
        switch (channel->books_stat) {
        case BOOKKEEPER_OK:
            if ( maxsize_set )
                channel->dirstat->max_size = maxsize;
            else
                maxsize = channel->dirstat->max_size;
            if ( maxlife_set )
                channel->dirstat->max_lifetime = lifetime;
            else
                lifetime = channel->dirstat->max_lifetime;
            printf("Update collector process running for directory: '%s'\n", datadir);
            UpdateBooksParam(channel->books, (time_t)lifetime, maxsize);
            print_stat = 1;
            break;
        case ERR_NOTEXISTS:
            if ( maxsize_set )
                channel->dirstat->max_size = maxsize;
            if ( maxlife_set )
                channel->dirstat->max_lifetime = lifetime;
            print_stat = 1;
            break;
        default:
            // should never be reached as already cought earlier
            printf("Error %i while connecting to collector\n", channel->books_stat);
        }
        if ( channel->status == OK || channel->status == NOFILES  )
            WriteStatInfo(channel->dirstat);
    }

    if ( !is_profile && print_books ) {
        switch (channel->books_stat) {
        case BOOKKEEPER_OK:
            PrintBooks(channel->books);
            break;
        case ERR_NOTEXISTS:
            printf("No collector process running for directory: '%s'\n", channel->datadir);
            break;
        default:
            // should never be reached as already cought earlier
            printf("Error %i while connecting to collector\n", channel->books_stat);
        }

    }

    if ( print_stat ) {
        if ( is_profile ) {
            dirstat_t	current_stat;

            current_stat.status = 0;
            current_stat.max_lifetime 	= lifetime;
            current_stat.max_size  		= maxsize;
            current_stat.low_water 		= low_water ? low_water : 98;

            // sum up all channels in the profile
            current_channel = channel;
            current_stat.numfiles = current_channel->dirstat->numfiles;
            current_stat.filesize = current_channel->dirstat->filesize;
            current_stat.first 	  = current_channel->dirstat->first;
            current_stat.last 	  = current_channel->dirstat->last;
            current_channel = current_channel->next;
            while ( current_channel ) {
                current_stat.numfiles += current_channel->dirstat->numfiles;
                current_stat.filesize += current_channel->dirstat->filesize;
                if ( current_channel->dirstat->first && (current_channel->dirstat->first < current_stat.first) )
                    current_stat.first = current_channel->dirstat->first;
                if ( current_channel->dirstat->last > current_stat.last )
                    current_stat.last = current_channel->dirstat->last;

                current_channel = current_channel->next;
            }
            if ( nfsen_format ) {
                printf("Stat|%llu|%llu|%llu\n",
                       (unsigned long long)current_stat.filesize,
                       (unsigned long long)current_stat.first, (unsigned long long)current_stat.last);
            } else
                PrintDirStat(&current_stat);
        } else if ( nfsen_format )
            printf("Stat|%llu|%llu|%llu\n",
                   (unsigned long long)channel->dirstat->filesize,
                   (unsigned long long)channel->dirstat->first, (unsigned long long)channel->dirstat->last );
        else
            PrintDirStat(channel->dirstat);

    }

    current_channel = channel;
    while ( current_channel ) {
        ReleaseBookkeeper(current_channel->books, DETACH_ONLY);
        if ( current_channel->status == OK )
            WriteStatInfo(current_channel->dirstat);

        current_channel = current_channel->next;
    }

    return 0;
}
示例#21
0
//-------------------------------------------------------------
//- Load
//- Loads an MF1 model from a file
//-------------------------------------------------------------
uint8* CSGPModelMF1::LoadMF1(CSGPModelMF1* &pOutModelMF1, const String& WorkingDir, const String& Filename)
{
	uint8 * ucpBuffer = 0;	
	uint32 iFileSize = 0;

	String AbsolutePath(Filename);
	// Identify by their absolute filenames if possible.
	if( !File::isAbsolutePath(AbsolutePath) )
	{
		AbsolutePath = WorkingDir +	File::separatorString + String(Filename);
	}

	{
		ScopedPointer<FileInputStream> MF1FileStream( File(AbsolutePath).createInputStream() );
		if( MF1FileStream == nullptr )
		{
			Logger::getCurrentLogger()->writeToLog(String("Could not open MF1 File:") + Filename, ELL_ERROR);
			return NULL;
		}
		iFileSize = (uint32)MF1FileStream->getTotalLength();

		ucpBuffer = new uint8 [iFileSize];

		MF1FileStream->read(ucpBuffer, iFileSize);
	}

	//Make sure header is valid
	pOutModelMF1 = (CSGPModelMF1 *)ucpBuffer;

	if(pOutModelMF1->m_Header.m_iId != 0xCAFE2BEE || pOutModelMF1->m_Header.m_iVersion != 1)
	{
		Logger::getCurrentLogger()->writeToLog(Filename + String(" is not a valid MF1 File!"), ELL_ERROR);
		delete [] ucpBuffer;
		ucpBuffer = NULL;
		return NULL;
	}

	// Skin
	{
		if( pOutModelMF1->m_Header.m_iSkinOffset )
		{
			pOutModelMF1->m_pSkins = (SGPMF1Skin *)(ucpBuffer + (intptr_t)pOutModelMF1->m_Header.m_iSkinOffset);
			for( uint32 i=0; i<pOutModelMF1->m_Header.m_iNumSkins; i++ )
			{
				if( pOutModelMF1->m_pSkins[i].m_pMatKeyFrame )
					pOutModelMF1->m_pSkins[i].m_pMatKeyFrame = (SGPMF1MatKeyFrame *)(ucpBuffer + (intptr_t)pOutModelMF1->m_pSkins[i].m_pMatKeyFrame);
			}
		}
		else
			pOutModelMF1->m_pSkins = NULL;
	}

	//Mesh
	{
		if( pOutModelMF1->m_Header.m_iLod0MeshOffset )
		{
			pOutModelMF1->m_pLOD0Meshes = (SGPMF1Mesh *)(ucpBuffer + (intptr_t)pOutModelMF1->m_Header.m_iLod0MeshOffset);
			for( uint32 i=0; i<pOutModelMF1->m_Header.m_iNumMeshes; i++ )
			{
				if( pOutModelMF1->m_pLOD0Meshes[i].m_pVertex )
					pOutModelMF1->m_pLOD0Meshes[i].m_pVertex = (SGPMF1Vertex *)(ucpBuffer + (intptr_t)pOutModelMF1->m_pLOD0Meshes[i].m_pVertex);
				if( pOutModelMF1->m_pLOD0Meshes[i].m_pIndices )
					pOutModelMF1->m_pLOD0Meshes[i].m_pIndices = (uint16 *)(ucpBuffer + (intptr_t)pOutModelMF1->m_pLOD0Meshes[i].m_pIndices);
				if( pOutModelMF1->m_pLOD0Meshes[i].m_pVertexBoneGroupID )
					pOutModelMF1->m_pLOD0Meshes[i].m_pVertexBoneGroupID = (uint16 *)(ucpBuffer + (intptr_t)pOutModelMF1->m_pLOD0Meshes[i].m_pVertexBoneGroupID);
				if( pOutModelMF1->m_pLOD0Meshes[i].m_pTexCoords0 )
					pOutModelMF1->m_pLOD0Meshes[i].m_pTexCoords0 = (SGPMF1TexCoord *)(ucpBuffer + (intptr_t)pOutModelMF1->m_pLOD0Meshes[i].m_pTexCoords0);
				if( pOutModelMF1->m_pLOD0Meshes[i].m_pTexCoords1 )
					pOutModelMF1->m_pLOD0Meshes[i].m_pTexCoords1 = (SGPMF1TexCoord *)(ucpBuffer + (intptr_t)pOutModelMF1->m_pLOD0Meshes[i].m_pTexCoords1);
				if( pOutModelMF1->m_pLOD0Meshes[i].m_pVertexColor )
					pOutModelMF1->m_pLOD0Meshes[i].m_pVertexColor = (SGPMF1VertexColor *)(ucpBuffer + (intptr_t)pOutModelMF1->m_pLOD0Meshes[i].m_pVertexColor);
			}
		}
		else
			pOutModelMF1->m_pLOD0Meshes = NULL;

		if( pOutModelMF1->m_Header.m_iLod1MeshOffset )
		{}
		else
			pOutModelMF1->m_pLOD1Meshes = NULL;

		if( pOutModelMF1->m_Header.m_iLod2MeshOffset )
		{}
		else
			pOutModelMF1->m_pLOD2Meshes = NULL;
	}

	// Bone File name
	{
		if( pOutModelMF1->m_Header.m_iBoneAnimFileOffset )
			pOutModelMF1->m_pBoneFileNames = (SGPMF1BoneFileName *)(ucpBuffer + (intptr_t)pOutModelMF1->m_Header.m_iBoneAnimFileOffset);
		else
			pOutModelMF1->m_pBoneFileNames = NULL;
	}

	// ActionList
	{
		if( pOutModelMF1->m_Header.m_iActionListOffset )
			pOutModelMF1->m_pActionLists = (SGPMF1ActionList *)(ucpBuffer + (intptr_t)pOutModelMF1->m_Header.m_iActionListOffset);
		else
			pOutModelMF1->m_pActionLists = NULL;
	}

	//Attachment
	{
		if( pOutModelMF1->m_Header.m_iAttachOffset )
			pOutModelMF1->m_pAttachTags = (SGPMF1AttachmentTag *)(ucpBuffer + (intptr_t)pOutModelMF1->m_Header.m_iAttachOffset);
		else
			pOutModelMF1->m_pAttachTags = NULL;

		if( pOutModelMF1->m_Header.m_iEttachOffset )
			pOutModelMF1->m_pEffectTags = (SGPMF1AttachmentTag *)(ucpBuffer + (intptr_t)pOutModelMF1->m_Header.m_iEttachOffset);
		else
			pOutModelMF1->m_pEffectTags = NULL;
	}

	// Particle
	{
		if( pOutModelMF1->m_Header.m_iParticleOffset )
		{
			pOutModelMF1->m_pParticleEmitter = (SGPMF1ParticleTag *)(ucpBuffer + (intptr_t)pOutModelMF1->m_Header.m_iParticleOffset);

			for( uint32 i=0; i < pOutModelMF1->m_Header.m_iNumParticles; ++i )
			{
				// Particle System
				ParticleSystemParam& systemParam = pOutModelMF1->m_pParticleEmitter[i].m_SystemParam;
				systemParam.m_pGroupParam = (ParticleGroupParam *)(ucpBuffer + (intptr_t)systemParam.m_pGroupParam);
				for( uint32 j=0; j < systemParam.m_groupCount; ++j )
				{
					// Particle Group
					ParticleGroupParam& groupParam = systemParam.m_pGroupParam[j];
					// Particle Model
					ParticleModelParam& modelParam = groupParam.m_ModelParam;

					modelParam.m_pRegularParam = (ParticleRegularParam *)(ucpBuffer + (intptr_t)modelParam.m_pRegularParam);
					modelParam.m_pInterpolatorParam = (ParticleInterpolatorParam *)(ucpBuffer + (intptr_t)modelParam.m_pInterpolatorParam);
					
					// interpolator
					for(uint32 k=0; k < modelParam.m_InterpolatorCount; ++k)
					{
						ParticleInterpolatorParam& interpolatorParam = modelParam.m_pInterpolatorParam[k];
						if(interpolatorParam.m_InterpolatorType == Interpolator_SelfDefine)
						{
							ParticleSelfDefInterpolatorData& selfDefData = interpolatorParam.m_SelfDefData;
							selfDefData.m_pEntry = (ParticleEntryParam *)(ucpBuffer + (intptr_t)selfDefData.m_pEntry);
						}
					}

					// Particle Emitter
					groupParam.m_pEmitterParam = (ParticleEmitterParam *)(ucpBuffer + (intptr_t)groupParam.m_pEmitterParam);
					// Particle Modifier
					groupParam.m_pModifierParam = (ParticleModifierParam *)(ucpBuffer + (intptr_t)groupParam.m_pModifierParam);
				}
			}
		}
	}
	//Ribbon
	{
	}

	//Config Setting
	{
		if( pOutModelMF1->m_Header.m_iConfigsOffset )
		{
			pOutModelMF1->m_pConfigSetting = (SGPMF1ConfigSetting *)(ucpBuffer + (intptr_t)pOutModelMF1->m_Header.m_iConfigsOffset);
			for( uint32 i=0; i<pOutModelMF1->m_Header.m_iNumConfigs; i++ )
			{
				if( pOutModelMF1->m_pConfigSetting[i].pMeshConfigList )
					pOutModelMF1->m_pConfigSetting[i].pMeshConfigList = (SGPMF1ConfigSetting::MeshConfig *)(ucpBuffer + (intptr_t)pOutModelMF1->m_pConfigSetting[i].pMeshConfigList);
				if( pOutModelMF1->m_pConfigSetting[i].pReplaceTextureConfigList )
					pOutModelMF1->m_pConfigSetting[i].pReplaceTextureConfigList = (SGPMF1ConfigSetting::ReplaceTextureConfig *)(ucpBuffer + (intptr_t)pOutModelMF1->m_pConfigSetting[i].pReplaceTextureConfigList);
				if( pOutModelMF1->m_pConfigSetting[i].pParticleConfigList )
					pOutModelMF1->m_pConfigSetting[i].pParticleConfigList = (SGPMF1ConfigSetting::ParticleConfig *)(ucpBuffer + (intptr_t)pOutModelMF1->m_pConfigSetting[i].pParticleConfigList);
				if( pOutModelMF1->m_pConfigSetting[i].pRibbonConfigList )
					pOutModelMF1->m_pConfigSetting[i].pRibbonConfigList = (SGPMF1ConfigSetting::RibbonConfig *)(ucpBuffer + (intptr_t)pOutModelMF1->m_pConfigSetting[i].pRibbonConfigList);
			}
		}
		else
			pOutModelMF1->m_pConfigSetting = NULL;
	}

	pOutModelMF1->m_iNumBones = 0;
	pOutModelMF1->m_iNumBoneGroup = 0;

	pOutModelMF1->m_pBones = NULL;
	pOutModelMF1->m_pBoneGroup = NULL;


	return ucpBuffer;
}
示例#22
0
//Load an MF1 bone animation file
uint8* CSGPModelMF1::LoadBone(CSGPModelMF1* &pOutModelMF1, const String& WorkingDir, const String& BoneFilename, uint16 BoneFileIndex)
{
	uint8 * ucpBuffer = 0;	
	uint32 iFileSize = 0;

	String AbsolutePath(BoneFilename);
	// Identify by their absolute filenames if possible.
	if( !File::isAbsolutePath(AbsolutePath) )
	{
		AbsolutePath = WorkingDir +	File::separatorString + String(BoneFilename);
	}
	if( BoneFileIndex > 0 )
		AbsolutePath = AbsolutePath + String(BoneFileIndex);

	{
		ScopedPointer<FileInputStream> BF1FileStream( File(AbsolutePath).createInputStream() );
		if( BF1FileStream == nullptr )
		{
			Logger::getCurrentLogger()->writeToLog(String("Could not open BF1 File:") + BoneFilename, ELL_ERROR);
			return NULL;
		}
		iFileSize = (uint32)BF1FileStream->getTotalLength();

		ucpBuffer = new uint8 [iFileSize];

		BF1FileStream->read(ucpBuffer, iFileSize);
	}

	SGPMF1BoneHeader *pBoneHeader = (SGPMF1BoneHeader *)ucpBuffer;
	if(pBoneHeader->m_iId != 0xCAFEBBEE || pBoneHeader->m_iVersion != 1)
	{
		Logger::getCurrentLogger()->writeToLog(BoneFilename + String(" is not a valid BF1 File!"), ELL_ERROR);
		delete [] ucpBuffer;
		ucpBuffer = NULL;
		return NULL;
	}

	if( BoneFileIndex == 0 )
	{
		pOutModelMF1->m_iNumBones = pBoneHeader->m_iNumBones;
		pOutModelMF1->m_iNumBoneGroup = pBoneHeader->m_iNumBoneGroup;

		pOutModelMF1->m_pBones = (SGPMF1Bone *)(ucpBuffer + (intptr_t)pBoneHeader->m_iBonesOffset);

		for(uint32 i=0; i<pOutModelMF1->m_iNumBones; i++)
		{
			pOutModelMF1->m_pBones[i].m_ChildIds = (uint16*)(ucpBuffer + (intptr_t)pOutModelMF1->m_pBones[i].m_ChildIds);

			pOutModelMF1->m_pBones[i].m_TransKeyFrames = (KeyFrameBlock*)(ucpBuffer + (intptr_t)pOutModelMF1->m_pBones[i].m_TransKeyFrames);
			pOutModelMF1->m_pBones[i].m_RotsKeyFrames = (KeyFrameBlock*)(ucpBuffer + (intptr_t)pOutModelMF1->m_pBones[i].m_RotsKeyFrames);
			pOutModelMF1->m_pBones[i].m_ScaleKeyFrames = (ScaleKeyFrameBlock*)(ucpBuffer + (intptr_t)pOutModelMF1->m_pBones[i].m_ScaleKeyFrames);
			pOutModelMF1->m_pBones[i].m_VisibleKeyFrames = (VisibleKeyFrameBlock*)(ucpBuffer + (intptr_t)pOutModelMF1->m_pBones[i].m_VisibleKeyFrames);

			pOutModelMF1->m_pBones[i].m_TransKeyFrames->m_KeyFrames = (SGPMF1KeyFrame*) (ucpBuffer + (intptr_t)pOutModelMF1->m_pBones[i].m_TransKeyFrames->m_KeyFrames);
			pOutModelMF1->m_pBones[i].m_RotsKeyFrames->m_KeyFrames = (SGPMF1KeyFrame*) (ucpBuffer + (intptr_t)pOutModelMF1->m_pBones[i].m_RotsKeyFrames->m_KeyFrames);
			pOutModelMF1->m_pBones[i].m_ScaleKeyFrames->m_KeyFrames = (SGPMF1ScaleKeyFrame*) (ucpBuffer + (intptr_t)pOutModelMF1->m_pBones[i].m_ScaleKeyFrames->m_KeyFrames);
			pOutModelMF1->m_pBones[i].m_VisibleKeyFrames->m_KeyFrames = (SGPMF1VisibleKeyFrame*) (ucpBuffer + (intptr_t)pOutModelMF1->m_pBones[i].m_VisibleKeyFrames->m_KeyFrames);



		}
		pOutModelMF1->m_pBoneGroup = (SGPMF1BoneGroup *)(ucpBuffer + (intptr_t)pBoneHeader->m_iBoneGroupOffset);
	}
	else if( BoneFileIndex > 0 )
	{
		// Some check
		jassert(pOutModelMF1->m_iNumBones == pBoneHeader->m_iNumBones);
		jassert(pOutModelMF1->m_iNumBoneGroup == pBoneHeader->m_iNumBoneGroup);


		// Relocate Pointer
		SGPMF1Bone* pBones = (SGPMF1Bone *)(ucpBuffer + (intptr_t)pBoneHeader->m_iBonesOffset);
		for(uint32 i=0; i<pOutModelMF1->m_iNumBones; i++)
		{
			KeyFrameBlock* pTransBlock = (KeyFrameBlock*)(ucpBuffer + (intptr_t)pBones[i].m_TransKeyFrames);
			KeyFrameBlock* pRotsBlock = (KeyFrameBlock*)(ucpBuffer + (intptr_t)pBones[i].m_RotsKeyFrames);
			ScaleKeyFrameBlock* pScalesBlock = (ScaleKeyFrameBlock*)(ucpBuffer + (intptr_t)pBones[i].m_ScaleKeyFrames);
			VisibleKeyFrameBlock* pVisibleBlock = (VisibleKeyFrameBlock*)(ucpBuffer + (intptr_t)pBones[i].m_VisibleKeyFrames);

			pTransBlock->m_KeyFrames = (SGPMF1KeyFrame*) (ucpBuffer + (intptr_t)pTransBlock->m_KeyFrames);
			pRotsBlock->m_KeyFrames = (SGPMF1KeyFrame*) (ucpBuffer + (intptr_t)pRotsBlock->m_KeyFrames);
			pScalesBlock->m_KeyFrames = (SGPMF1ScaleKeyFrame*) (ucpBuffer + (intptr_t)pScalesBlock->m_KeyFrames);
			pVisibleBlock->m_KeyFrames = (SGPMF1VisibleKeyFrame*) (ucpBuffer + (intptr_t)pVisibleBlock->m_KeyFrames);						

			pTransBlock->m_BoneFileID = BoneFileIndex;
			pRotsBlock->m_BoneFileID = BoneFileIndex;
			pScalesBlock->m_BoneFileID = BoneFileIndex;
			pVisibleBlock->m_BoneFileID = BoneFileIndex;

			// Find next free Block
			KeyFrameBlock** ppNextTransBlock = &pOutModelMF1->m_pBones[i].m_TransKeyFrames->m_nextBlock;
			KeyFrameBlock** ppNextRotsBlock = &pOutModelMF1->m_pBones[i].m_RotsKeyFrames->m_nextBlock;
			ScaleKeyFrameBlock** ppNextScaleBlock = &pOutModelMF1->m_pBones[i].m_ScaleKeyFrames->m_nextBlock;
			VisibleKeyFrameBlock** ppNextVisibleBlock = &pOutModelMF1->m_pBones[i].m_VisibleKeyFrames->m_nextBlock;
			while(*ppNextTransBlock != NULL)
			{
				ppNextTransBlock = &((*ppNextTransBlock)->m_nextBlock);
				ppNextRotsBlock = &((*ppNextRotsBlock)->m_nextBlock);
				ppNextScaleBlock = &((*ppNextScaleBlock)->m_nextBlock);
				ppNextVisibleBlock = &((*ppNextVisibleBlock)->m_nextBlock);
			}
			
			*ppNextTransBlock = pTransBlock;
			*ppNextRotsBlock = pRotsBlock;
			*ppNextScaleBlock = pScalesBlock;
			*ppNextVisibleBlock = pVisibleBlock;
		}
	}

	return ucpBuffer;
}
bool JSONCompilationDatabase::parse(std::string &ErrorMessage) {
  llvm::yaml::document_iterator I = YAMLStream.begin();
  if (I == YAMLStream.end()) {
    ErrorMessage = "Error while parsing YAML.";
    return false;
  }
  llvm::yaml::Node *Root = I->getRoot();
  if (Root == NULL) {
    ErrorMessage = "Error while parsing YAML.";
    return false;
  }
  llvm::yaml::SequenceNode *Array =
    llvm::dyn_cast<llvm::yaml::SequenceNode>(Root);
  if (Array == NULL) {
    ErrorMessage = "Expected array.";
    return false;
  }
  for (llvm::yaml::SequenceNode::iterator AI = Array->begin(),
                                          AE = Array->end();
       AI != AE; ++AI) {
    llvm::yaml::MappingNode *Object =
      llvm::dyn_cast<llvm::yaml::MappingNode>(&*AI);
    if (Object == NULL) {
      ErrorMessage = "Expected object.";
      return false;
    }
    llvm::yaml::ScalarNode *Directory = NULL;
    llvm::yaml::ScalarNode *Command = NULL;
    llvm::yaml::ScalarNode *File = NULL;
    for (llvm::yaml::MappingNode::iterator KVI = Object->begin(),
                                           KVE = Object->end();
         KVI != KVE; ++KVI) {
      llvm::yaml::Node *Value = (*KVI).getValue();
      if (Value == NULL) {
        ErrorMessage = "Expected value.";
        return false;
      }
      llvm::yaml::ScalarNode *ValueString =
        llvm::dyn_cast<llvm::yaml::ScalarNode>(Value);
      if (ValueString == NULL) {
        ErrorMessage = "Expected string as value.";
        return false;
      }
      llvm::yaml::ScalarNode *KeyString =
        llvm::dyn_cast<llvm::yaml::ScalarNode>((*KVI).getKey());
      if (KeyString == NULL) {
        ErrorMessage = "Expected strings as key.";
        return false;
      }
      llvm::SmallString<8> KeyStorage;
      if (KeyString->getValue(KeyStorage) == "directory") {
        Directory = ValueString;
      } else if (KeyString->getValue(KeyStorage) == "command") {
        Command = ValueString;
      } else if (KeyString->getValue(KeyStorage) == "file") {
        File = ValueString;
      } else {
        ErrorMessage = ("Unknown key: \"" +
                        KeyString->getRawValue() + "\"").str();
        return false;
      }
    }
    if (!File) {
      ErrorMessage = "Missing key: \"file\".";
      return false;
    }
    if (!Command) {
      ErrorMessage = "Missing key: \"command\".";
      return false;
    }
    if (!Directory) {
      ErrorMessage = "Missing key: \"directory\".";
      return false;
    }
    llvm::SmallString<8> FileStorage;
    StringRef FileName = File->getValue(FileStorage);
    llvm::SmallString<128> NativeFilePath;
    if (llvm::sys::path::is_relative(FileName)) {
      llvm::SmallString<8> DirectoryStorage;
      llvm::SmallString<128> AbsolutePath(
          Directory->getValue(DirectoryStorage));
      llvm::sys::path::append(AbsolutePath, FileName);
      llvm::sys::path::native(AbsolutePath.str(), NativeFilePath);
    } else {
      llvm::sys::path::native(FileName, NativeFilePath);
    }
    IndexByFile[NativeFilePath].push_back(
        CompileCommandRef(Directory, Command));
    MatchTrie.insert(NativeFilePath.str());
  }
  return true;
}