Exemplo n.º 1
0
void MainDialog::UpdateTokenValues(ConfigToken & updateProfile, const string & searchStr, const string &replaceStr) const
{
  // Get the value array in the token
  uint i;
  vector<string> tokenValues;
  updateProfile.GetArray(updateProfile.GetNumValues(), tokenValues);

  // Loop for all values in the token
  for(i=0; i<tokenValues.size(); i++)
  {
    // Loop and find the token values
    string::size_type findPos = tokenValues[i].find(searchStr);
    while(findPos != string::npos)
    {
      // Replace the string
      tokenValues[i].replace(findPos, searchStr.size(), replaceStr);
      
      // Attempt to find more matches
      findPos = tokenValues[i].find(searchStr, findPos + replaceStr.size());
    }
  }

  // Replace the stored token values
  updateProfile.SetValueArray(tokenValues);

  // Loop for all children
  for(i=0; i<updateProfile.GetNumChildren(); i++) 
  {
    // Recurse
    UpdateTokenValues(*updateProfile.GetChildToken(i), searchStr, replaceStr);
  }
}
Exemplo n.º 2
0
bool ConfigParser::ExtractTokens(RawTokenArray &rawTokens, uint &tokenNum, ConfigToken *parent)
{
  ConfigToken *currToken=NULL;
  bool inbracket = false;
  bool assignment= false;

  //NOTE: May have to use "proper" parser recursion if this gets much more complex

  //Loop for all tokens
  for(;tokenNum<rawTokens.size();tokenNum++)
  {
    string & tokenString = rawTokens[tokenNum].value;
    int commandChar = (int)tokenString.find_first_of(singleTokens.c_str());
  
    //If this is a command character, process it 
    if(commandChar == 0  && tokenString.length() == 1 &&
       !rawTokens[tokenNum].isString)
    {

      if(tokenString == "{")
      {
        //Check that we are not in a bracket
        if(inbracket || !currToken || assignment)
        {
          LOGERR(("ConfigParser::ExtractTokens - Un-expected '{'"));
          return false;
        }

        //Recursive call
        tokenNum++;
        if(!ExtractTokens(rawTokens,tokenNum,currToken))
        {
          LOGERR(("ConfigParser::ExtractTokens - Error in child block"));
          return false;
        }
      }
      else if(tokenString == "}")
      {
        //Check that we are not in a bracket and that there was a '{'
        if(inbracket || !parent || assignment)
        {
          LOGERR(("ConfigParser::ExtractTokens - Un-expected '}'"));
          return false;
        }

        return true;
      }
      else if(tokenString == "(")
      {
        if(inbracket || !assignment || !currToken)
        {
          LOGERR(("ConfigParser::ExtractTokens - Un-expected '('"));
          return false;
        }

        //Set bracket flag
        inbracket = true;
      }
      else if(tokenString == ")")
      {
        //Check for missing opening bracket
        if(!inbracket || !assignment || !currToken)
        {
          LOGERR(("ConfigParser::ExtractTokens - Un-expected ')'"));
          return false;
        }

        //Un-set bracket flag
        inbracket = false;
        assignment= false;
      }
      else if(tokenString == ",")
      {
        //NOTE: does not check for excess comma's (ie double or extra trailing commas)
        //Check for missing previous child and in a bracket
        if(!inbracket || !currToken || currToken->GetNumValues() == 0)
        {
          LOGERR(("ConfigParser::ExtractTokens - Un-expected ','"));
          return false;
        }
      }
      else if(tokenString == "=")
      {
        //Check for current token
        if(!currToken || assignment || inbracket)
        {
          LOGERR(("ConfigParser::ExtractTokens - Un-expected '='"));
          return false;
        }

        assignment=true;
      }
      else if(tokenString == ";")
      {
        //Check for current token
        if(!currToken || assignment || inbracket)
        {
          LOGERR(("ConfigParser::ExtractTokens - Un-expected ';'"));
          return false;
        }
      
        //The token is just a seperator, so do nothing
      }
      else
      {
        LOGERR(("ConfigParser::ExtractTokens - Unknown command '%s'",tokenString.c_str()));
        return false;
      }
    }

    //Process the non-command token
    else
    {
      //Else just create a new config token 
      if(inbracket && currToken)
      {
        //Add a new value to the config token
        currToken->values.push_back(tokenString);
      }
      else if(assignment)
      {
        //Add a new value to the config token
        currToken->values.push_back(tokenString);

        //Flag that the assignment is complete
        assignment =false;
      }
      else
      {
        //Create a new token
        ConfigToken newToken;
        newToken.name = tokenString;

        //Either add to the parent or root
        ConfigToken * addToToken = &rootToken;
        if(parent)
        {
          addToToken = parent;
        }

        //Test if the child already exists
        ConfigToken * existingToken = const_cast<ConfigToken *>(addToToken->GetChildToken(tokenString));
        if(existingToken == NULL)
        {
          //Add the token
          addToToken->children.push_back(newToken);
          currToken = &addToToken->children.back();
        }
        else
        {
          //Cannot simply ignore as there may be children or ther values associated with the token
          LOGERR(("ConfigParser::ExtractTokens - Extra %s token -using last value",tokenString.c_str()));
          
          //Reset the token
          existingToken->Reset();

          //Assign as the current token
          existingToken->name = tokenString;
          currToken = existingToken;
        }
      }
    }
  }


  //If this is not the root token, and we have processed all the data
  //  there is a missing closing bracket
  if((parent != NULL || inbracket || assignment) && tokenNum>=rawTokens.size())
  {
    //Missing closing bracket
    LOGERR(("ConfigParser::ExtractTokens - Un-expected end of tokens (end of file missing a '}' or a ')'?"));
    return false;
  }
/*
  //Debug
  for(uint i=0;i<parsedTokens.size();i++)
  {
    LOGERR(("%s",parsedTokens[i].name.c_str()));
  }
*/
  return true;
}
bool ConfigOptionsDialog::SetProfileData(const ConfigToken &setProfile, ConfigHeaderValue & headerToken)
{
  uint i;

  // If this is the plugins header
  if(headerToken.headerName == CONFIG_PLUGINS_HEADER_NAME)
  {
    // Process from the plugins array
    for(i=0; i<pluginGridValues.size(); i++)
    {
      // If there is a child with the plugin name
      const ConfigToken * childToken = setProfile.GetChildToken(pluginGridValues[i].headerName);
      if(childToken)
      { 
        // Set the Plugin as enabled 
        for(uint pluginValue=0; pluginValue<pluginGridValues[i].childSelectArray.size(); pluginValue++)
        {
          // Set the plugin enabled flag to true
          if(pluginGridValues[i].childSelectArray[pluginValue].typeName == CONFIG_PLUGIN_ENABLE_NAME)
          {
            pluginGridValues[i].childSelectArray[pluginValue].isValueDisplayed = true;
            pluginGridValues[i].childSelectArray[pluginValue].defaultValue.clear();
            pluginGridValues[i].childSelectArray[pluginValue].defaultValue.push_back(CONFIG_PLUGIN_TOKEN_TRUE);
            break;
          }
        }

        // Recurse
        if(!SetProfileData(*childToken, pluginGridValues[i]))
        {
          return false;
        }
      }
    }

    return true;
  }

  // Loop for all read tokens
  for(i=0; i<headerToken.childSelectArray.size(); i++)
  {
    // Find the token in the config data
    const ConfigToken * childToken = setProfile.GetChildToken(headerToken.childSelectArray[i].typeName);
    if(childToken)
    { 
      // Get the new defaults
      vector<string> newValues;
      childToken->GetArray(childToken->GetNumValues(), newValues);

      // Check the new values
      if(newValues.size() == 0)
      {
        wxLogError("SetProfileData - Empty value for token %s", headerToken.childSelectArray[i].typeName.c_str());        
        return false; 
      }

      // Check if there are a different number of values than the existing defaults  
      if(newValues.size() != headerToken.childSelectArray[i].defaultValue.size())
      {
        headerToken.childSelectArray[i].isValueDisplayed = true;
      }
      else
      {
        // Loop and check if any of the new values are different from the default string
        for(uint cmpIndex=0; cmpIndex<newValues.size(); cmpIndex++)
        {
          // Find the first string that does not match
          if(newValues[cmpIndex] != headerToken.childSelectArray[i].defaultValue[cmpIndex])
          {
            headerToken.childSelectArray[i].isValueDisplayed = true;
            break;
          }
        }
      }

      // Assign the new values as the defaults
      headerToken.childSelectArray[i].defaultValue = newValues;
    }
  }

  // Loop for all child header tokens
  for(i=0; i<headerToken.childHeaderArray.size(); i++)
  {
    // If there is a child with the header name
    const ConfigToken * childToken = setProfile.GetChildToken(headerToken.childHeaderArray[i].headerName);
    if(childToken)
    { 
      // Recurse
      if(!SetProfileData(*childToken, headerToken.childHeaderArray[i]))
      {
        return false;
      }
    }
  }

  return true;
}
void ConfigOptionsDialog::OnButtonSaveAs(wxCommandEvent& event)
{
  // Get the profile data
  ConfigToken saveConfigData;
  if(!GetDisplayConfigData(saveConfigData))
  {
    wxLogError("Unable to get config data");
    return;
  }

  // Convert the token data to a string
  string stlConfigString;
  for(uint childNum =0;childNum < saveConfigData.GetNumChildren(); childNum++)
  {
    //Convert each child back to raw config string data
    const ConfigToken * childData = saveConfigData.GetChildToken(childNum);
    if(childData)
    {
      string retString;
      if(ConfigParser::GenerateConfigString(childData, retString))
      {
        stlConfigString += retString;
      }
      else
      {
        wxLogError("Unable to generate GLIntercept configuration file data");
        return;
      }
    }
  }
  wxString saveConfigString = stlConfigString.c_str();

  wxStandardPaths stdPaths;
  wxFileName dirProcess;

  // Get the main profile directory
  dirProcess.AssignDir(stdPaths.GetDataDir());
  dirProcess.AppendDir("Profiles");
  wxString profileDir = dirProcess.GetPath();

  // Open the profile save dialog
  wxFileDialog fileDialog(this, _T("Save profile as"), profileDir, _T(""), _T("GLIntercept Profile (*.xni)|*.xni|Any (*.*)|*.*"), wxSAVE | wxOVERWRITE_PROMPT );
  if (fileDialog.ShowModal() != wxID_OK)
  {
    return;
  }
  wxFile configWrite;
  if(!configWrite.Open(fileDialog.GetPath(), wxFile::write))
  {
    wxLogError("Unable to open config file (%s)", fileDialog.GetPath().c_str());     
    return;
  }
  if(!configWrite.Write(saveConfigString))
  {
    wxLogError("Unable to write to config file (%s)", fileDialog.GetPath().c_str());     
    return;
  }

  // Flag that a config was saved
  isConfigSaved = true;
}
Exemplo n.º 5
0
bool MainDialog::GetSaveProfileString(bool copySystemLib, wxString &retString) const
{
  wxStandardPaths stdPaths;

  // Get the current selected profile
  ConfigToken saveProfile;
  if(!GetCurrentProfile(saveProfile))
  {
    wxLogError("No GLIntercept profile selected");
    return false;
  }

  // Get the profile name (if any)
  string profileName = "*Unknown*";
  {
    // Get the profile name if it exists
    const ConfigToken * profileNameToken = saveProfile.GetChildToken("ProfileName");
    if(profileNameToken)
    {
      profileNameToken->Get(profileName);
    }

    // Remove the profile/description tokens
    saveProfile.RemoveChild("ProfileName");
    saveProfile.RemoveChild("ProfileDescription");
  }

  // If copying the OpenGL system library
  if(copySystemLib)
  {
    // Get the input files token (or create it)
    ConfigToken * sourceInputFilesToken = GetCreateChildToken(saveProfile, "InputFiles");
    if(sourceInputFilesToken)
    {
      // Get the system lib token (or create it)
      ConfigToken * syslibToken = GetCreateChildToken(*sourceInputFilesToken, "GLSystemLib");
      if(syslibToken)
      {
        // Set the new override system lib name
        vector<string> newSystemLibName;
        newSystemLibName.push_back("opengl32.orig.dll");

        // Override the existing library name
        syslibToken->SetValueArray(newSystemLibName);
      }
    }
  }
 

  // Replace any string that start with %InstallPath% with the current path
  UpdateTokenValues(saveProfile, "%InstallPath%", stdPaths.GetDataDir().c_str());

  // Generate the config string from the profile
  string stlConfigString;
  for(uint childNum =0;childNum < saveProfile.GetNumChildren(); childNum++)
  {
    //Convert each child back to raw config string data
    const ConfigToken * childData = saveProfile.GetChildToken(childNum);
    if(childData)
    {
      string retString;
      if(ConfigParser::GenerateConfigString(childData, retString))
      {
        stlConfigString += retString;
      }
      else
      {
        wxLogError("Unable to generate GLIntercept configuration file data");
        return false;
      }
    }
  }

  // Add a header comment
  retString.Printf("/*\n*  GLIntercept config file generated by GLIConfig.\n*  Configuration based on profile \"%s\".\n*/\n\n", profileName.c_str());
  retString += stlConfigString.c_str();

  return true;
}