std::string Channel::_Patternize(const std::string &message,Player* caller)
{
std::string m=message;
std::stringstream format;
std::string::iterator it, itEnd;
BOOL emote=false;
if (m[0]==':')
{
emote=true;
m.erase(m.begin());
}
if (emote)
{
itEnd = _epattern.end();
}
else
{
itEnd = _pattern.end();
}
for (it=_pattern.begin(); it != itEnd; ++it)
{
if (((*it)=='%')&&((it++)!=(emote?_epattern.end():_pattern.end())))
{
switch ((*it))
{
case 'p':
format << caller->GetName();
break;
case 'P':
format << Capitalize(caller->GetName());
break;
case 'n':
format << _name;
break;
case 'N':
format << Capitalize(_name);
break;
case 'm':
format <<m;
break;
case 'M':
format << Capitalize(m);
break;
case '%':
format << "%";
break;
default:
break;
}
}
else
{
format << (*it);
}
}
return format.str();
}
void ReceptorArrow::Step( TapNoteScore score )
{
m_bIsPressed = true;
RString sJudge = TapNoteScoreToString( score );
m_pReceptor->PlayCommand( Capitalize(sJudge) );
}
void festring::PostProcessForFebot()
{
Capitalize();
truth CapitalizeNextChar = false;
for(sizetype c = 0; c < Size - 1; ++c)
{
char Char1 = Data[c];
if(Char1 == ' ')
{
char Char2 = Data[c + 1];
if((Char2 == '.' || Char2 == '!' || Char2 == '?')
&& (c == Size - 2 || Data[c + 2] == ' ' || Data[c + 2] == '\t'))
{
Erase(c++, 1);
CapitalizeNextChar = true;
}
}
else if((Char1 == '.' || Char1 == '!' || Char1 == '?')
&& (c == Size - 2 || Data[c + 2] == ' ' || Data[c + 2] == '\t'))
CapitalizeNextChar = true;
/* Erase() guarantees that OwnsData != false && REFS(Data) == 0 */
else if(CapitalizeNextChar)
{
if(Char1 > 0x60 && Char1 < 0x7B)
Data[c] &= ~0x20;
CapitalizeNextChar = false;
}
}
}
void festring::PostProcessForFebot()
{
Capitalize();
truth CapitalizeNextChar = false;
for(sizetype c = 0; c < Size - 1; ++c)
{
char Char1 = Data[c];
if(Char1 == ' ')
{
char Char2 = Data[c + 1];
if((Char2 == '.' || Char2 == '!' || Char2 == '?')
&& (c == Size - 2 || Data[c + 2] == ' ' || Data[c + 2] == '\t'))
{
Erase(c++, 1);
CapitalizeNextChar = true;
}
}
else if((Char1 == '.' || Char1 == '!' || Char1 == '?')
&& (c == Size - 2 || Data[c + 2] == ' ' || Data[c + 2] == '\t'))
CapitalizeNextChar = true;
else if(CapitalizeNextChar)
{
if(Char1 > 0x60 && Char1 < 0x7B)
(*this)[c] &= ~0x20; // Use (*this)[c] to modify Data[c]!
CapitalizeNextChar = false;
}
}
}
FOREACH_ENUM( Difficulty, dc )
{
if( dc == Difficulty_Edit )
continue;
vector<Steps*> vSteps;
SongUtil::GetSteps( pSong, vSteps, st, dc );
/* Delete steps that are completely identical. This happened due to a
* bug in an earlier version. */
DeleteDuplicateSteps( pSong, vSteps );
CHECKPOINT;
StepsUtil::SortNotesArrayByDifficulty( vSteps );
CHECKPOINT;
for( unsigned k=1; k<vSteps.size(); k++ )
{
vSteps[k]->SetDifficulty( Difficulty_Edit );
if( vSteps[k]->GetDescription() == "" )
{
/* "Hard Edit" */
RString EditName = Capitalize( DifficultyToString(dc) ) + " Edit";
vSteps[k]->SetDescription( EditName );
}
}
}
RString InputHandler::GetLocalizedInputString( const DeviceInput &di )
{
switch( di.button )
{
case KEY_HOME: return HOME.GetValue();
case KEY_END: return END.GetValue();
case KEY_UP: return UP.GetValue();
case KEY_DOWN: return DOWN.GetValue();
case KEY_SPACE: return SPACE.GetValue();
case KEY_LSHIFT: case KEY_RSHIFT: return SHIFT.GetValue();
case KEY_LCTRL: case KEY_RCTRL: return CTRL.GetValue();
case KEY_LALT: case KEY_RALT: return ALT.GetValue();
case KEY_INSERT: return INSERT.GetValue();
case KEY_DEL: return DEL.GetValue();
case KEY_PGUP: return PGUP.GetValue();
case KEY_PGDN: return PGDN.GetValue();
case KEY_BACKSLASH: return BACKSLASH.GetValue();
default:
wchar_t c = DeviceButtonToChar( di.button, false );
if( c && c != L' ' ) // Don't show "Key " for space.
return Capitalize( WStringToRString(wstring()+c) );
return DeviceButtonToString( di.button );
}
}
bool ReceptorArrow::Load( const CString &NoteSkin, PlayerNumber pn, int iColNo )
{
m_PlayerNumber = pn;
m_iColNo = iColNo;
NoteFieldMode &mode = g_NoteFieldMode[pn];
CString sButton = mode.GrayButtonNames[iColNo];
if( sButton == "" )
sButton = GAMESTATE->GetCurrentGame()->ColToButtonName( iColNo );
CString sPath;
m_pReceptorWaiting.Load( NOTESKIN->GetPathToFromNoteSkinAndButton(NoteSkin,sButton,"receptor waiting") );
m_pReceptorGo.Load( NOTESKIN->GetPathToFromNoteSkinAndButton(NoteSkin,sButton,"receptor go") );
FOREACH_TapNoteScore( i )
{
CString sJudge = TapNoteScoreToString( i );
m_sScoreCommand[i] = NOTESKIN->GetMetric( NoteSkin, m_sName, Capitalize(sJudge)+"Command" );
}
m_pPressBlock.Load( NOTESKIN->GetPathToFromNoteSkinAndButton(NoteSkin,sButton,"KeypressBlock") );
// draw pressblock before receptors
this->AddChild( m_pPressBlock );
this->AddChild( m_pReceptorWaiting );
this->AddChild( m_pReceptorGo );
return true;
}
std::string Entity::DoLook(Player* mobile)
{
std::string str;
LookArgs* args=new LookArgs(mobile,this,str);
events.CallEvent("PreLook", args, (void*)mobile);
str+=Capitalize(this->GetName())+"\n";
str+=this->GetDescription()+"\n";
events.CallEvent("PostLook", args, (void*)mobile);
delete args;
return str;
}
std::string CRPCTable::help(const std::string& strCommand, const JSONRPCRequest& helpreq) const
{
std::string strRet;
std::string category;
std::set<rpcfn_type> setDone;
std::vector<std::pair<std::string, const CRPCCommand*> > vCommands;
for (const auto& entry : mapCommands)
vCommands.push_back(make_pair(entry.second->category + entry.first, entry.second));
sort(vCommands.begin(), vCommands.end());
JSONRPCRequest jreq(helpreq);
jreq.fHelp = true;
jreq.params = UniValue();
for (const std::pair<std::string, const CRPCCommand*>& command : vCommands)
{
const CRPCCommand *pcmd = command.second;
std::string strMethod = pcmd->name;
if ((strCommand != "" || pcmd->category == "hidden") && strMethod != strCommand)
continue;
jreq.strMethod = strMethod;
try
{
rpcfn_type pfn = pcmd->actor;
if (setDone.insert(pfn).second)
(*pfn)(jreq);
}
catch (const std::exception& e)
{
// Help text is returned in an exception
std::string strHelp = std::string(e.what());
if (strCommand == "")
{
if (strHelp.find('\n') != std::string::npos)
strHelp = strHelp.substr(0, strHelp.find('\n'));
if (category != pcmd->category)
{
if (!category.empty())
strRet += "\n";
category = pcmd->category;
strRet += "== " + Capitalize(category) + " ==\n";
}
}
strRet += strHelp + "\n";
}
}
if (strRet == "")
strRet = strprintf("help: unknown command: %s\n", strCommand);
strRet = strRet.substr(0,strRet.size()-1);
return strRet;
}
SharedValue AccessorBoundList::Get(const char *name)
{
std::string getter_name = "get" + Capitalize(name);
SharedValue v = this->RawGet(getter_name.c_str());
if (v->IsMethod())
{
SharedKMethod m = v->ToMethod();
return m->Call(ValueList());
}
else
{
return this->RawGet(name);
}
}
void AccessorBoundList::Set(const char *name, SharedValue value)
{
std::string setter_name = "set" + Capitalize(name);
SharedValue v = this->RawGet(setter_name.c_str());
if (v->IsMethod())
{
SharedKMethod m = v->ToMethod();
ValueList args;
args.push_back(value);
m->Call(args);
}
else
{
this->RawSet(name, value);
}
}
RString InputHandler::GetDeviceSpecificInputString( const DeviceInput &di )
{
if( di.device == InputDevice_Invalid )
return RString();
if( di.device == DEVICE_KEYBOARD )
{
wchar_t c = DeviceButtonToChar( di.button, false );
if( c && c != L' ' ) // Don't show "Key " for space.
return InputDeviceToString( di.device ) + " " + Capitalize( WStringToRString(wstring()+c) );
}
RString s = DeviceButtonToString( di.button );
if( di.device != DEVICE_KEYBOARD )
s = InputDeviceToString( di.device ) + " " + s;
return s;
}
SongCreditDisplay::SongCreditDisplay()
{
if( GAMESTATE->IsCourseMode() )
return;
this->LoadFromFont( THEME->GetPathF("SongCreditDisplay","text") );
Song* pSong = GAMESTATE->m_pCurSong;
ASSERT( pSong );
CString s = pSong->GetFullDisplayTitle() + "\n" + pSong->GetDisplayArtist() + "\n";
if( !pSong->m_sCredit.empty() )
s += pSong->m_sCredit + "\n";
// use a vector and not a set so that ordering is maintained
vector<Steps*> vpStepsToShow;
FOREACH_PlayerNumber( p )
{
if( !GAMESTATE->IsHumanPlayer(p) )
continue; // skip
Steps* pSteps = GAMESTATE->m_pCurSteps[p];
bool bAlreadyAdded = find( vpStepsToShow.begin(), vpStepsToShow.end(), pSteps ) != vpStepsToShow.end();
if( !bAlreadyAdded )
vpStepsToShow.push_back( pSteps );
}
for( unsigned i=0; i<vpStepsToShow.size(); i++ )
{
Steps* pSteps = vpStepsToShow[i];
CString sDifficulty = DifficultyToThemedString( pSteps->GetDifficulty() );
// HACK: reset capitalization
sDifficulty.MakeLower();
sDifficulty = Capitalize( sDifficulty );
s += sDifficulty + " steps: " + pSteps->GetDescription() + "\n";
}
// erase the last newline
s.erase( s.end()-1 );
this->SetText( s );
}
bool StudentTree::ValidFullname(char* fullname, unsigned int* len)
{
tempUint = strlen(fullname);
RemoveComma(fullname, 0, tempUint);
RemoveExtraSpaces(fullname);
Trim(fullname);
Capitalize(fullname);
tempUint = strlen(fullname);
for(unsigned int i=0; i<tempUint; i++)
if (isdigit(*(fullname + i)) || !isalpha(*(fullname + i)))
{
if (*(fullname + i) == ' ')
continue;
else
return false;
}
return tempUint?(len?(*len = tempUint):true):false;
}
ScreenBranch::ScreenBranch( CString sClassName ) : Screen( sClassName )
{
LOG->Trace( "ScreenBranch::ScreenBranch()" );
CStringArray as;
split( CHOICES, ",", as, true );
for( unsigned i=0; i<as.size(); i++ )
{
CString sChoice = Capitalize( as[i] );
CString sCondition = CONDITION(sChoice);
if( Lua::RunExpression(sCondition) )
{
m_sChoice = sChoice;
HandleScreenMessage( SM_GoToNextScreen );
return;
}
}
RageException::Throw( "On screen '%s' no conditions are true", sClassName.c_str() );
}
void generate_lock_src_cpp_files(std::string &path_name) {
// Generate Pers_*_src.cpp file for Lock functions
std::set<std::string>::iterator it;
for (it = LockFunctionsInUse.begin(); it != LockFunctionsInUse.end(); it++) {
std::string module_name = *it;
std::string macro_name = "HTC_KEEP_MODULE_" + Upper(module_name);
std::string cpp_name = path_name + "Pers" +
Capitalize(module_name) + "_src.cpp";
std::fstream fs;
fs.open(cpp_name.c_str(), std::fstream::out | std::fstream::trunc);
fs << "#define " << macro_name << std::endl;
fs << "#include \"rose_lock.c\"" << std::endl;
fs.close();
}
LockFunctionsInUse.clear();
}
void PlayerOptions::GetMods( vector<RString> &AddTo, bool bForceNoteSkin ) const
{
//RString sReturn;
if( !m_fTimeSpacing )
{
if( m_fMaxScrollBPM )
{
RString s = ssprintf( "m%.0f", m_fMaxScrollBPM );
AddTo.push_back( s );
}
else if( m_bSetScrollSpeed || m_fScrollSpeed != 1 )
{
/* -> 1.00 */
RString s = ssprintf( "%2.2f", m_fScrollSpeed );
if( s[s.size()-1] == '0' )
{
/* -> 1.0 */
s.erase( s.size()-1 ); // delete last char
if( s[s.size()-1] == '0' )
{
/* -> 1 */
s.erase( s.size()-2 ); // delete last 2 chars
}
}
AddTo.push_back( s + "x" );
}
}
else
{
RString s = ssprintf( "C%.0f", m_fScrollBPM );
AddTo.push_back( s );
}
AddPart( AddTo, m_fAccels[ACCEL_BOOST], "Boost" );
AddPart( AddTo, m_fAccels[ACCEL_BRAKE], "Brake" );
AddPart( AddTo, m_fAccels[ACCEL_WAVE], "Wave" );
AddPart( AddTo, m_fAccels[ACCEL_EXPAND], "Expand" );
AddPart( AddTo, m_fAccels[ACCEL_BOOMERANG], "Boomerang" );
AddPart( AddTo, m_fEffects[EFFECT_DRUNK], "Drunk" );
AddPart( AddTo, m_fEffects[EFFECT_DIZZY], "Dizzy" );
AddPart( AddTo, m_fEffects[EFFECT_CONFUSION], "Confusion" );
AddPart( AddTo, m_fEffects[EFFECT_MINI], "Mini" );
AddPart( AddTo, m_fEffects[EFFECT_TINY], "Tiny" );
AddPart( AddTo, m_fEffects[EFFECT_FLIP], "Flip" );
AddPart( AddTo, m_fEffects[EFFECT_INVERT], "Invert" );
AddPart( AddTo, m_fEffects[EFFECT_TORNADO], "Tornado" );
AddPart( AddTo, m_fEffects[EFFECT_TIPSY], "Tipsy" );
AddPart( AddTo, m_fEffects[EFFECT_BUMPY], "Bumpy" );
AddPart( AddTo, m_fEffects[EFFECT_BEAT], "Beat" );
AddPart( AddTo, m_fEffects[EFFECT_XMODE], "XMode" );
AddPart( AddTo, m_fEffects[EFFECT_TWIRL], "Twirl" );
AddPart( AddTo, m_fEffects[EFFECT_ROLL], "Roll" );
AddPart( AddTo, m_fAppearances[APPEARANCE_HIDDEN], "Hidden" );
AddPart( AddTo, m_fAppearances[APPEARANCE_HIDDEN_OFFSET], "HiddenOffset" );
AddPart( AddTo, m_fAppearances[APPEARANCE_SUDDEN], "Sudden" );
AddPart( AddTo, m_fAppearances[APPEARANCE_SUDDEN_OFFSET], "SuddenOffset" );
AddPart( AddTo, m_fAppearances[APPEARANCE_STEALTH], "Stealth" );
AddPart( AddTo, m_fAppearances[APPEARANCE_BLINK], "Blink" );
AddPart( AddTo, m_fAppearances[APPEARANCE_RANDOMVANISH], "RandomVanish" );
AddPart( AddTo, m_fScrolls[SCROLL_REVERSE], "Reverse" );
AddPart( AddTo, m_fScrolls[SCROLL_SPLIT], "Split" );
AddPart( AddTo, m_fScrolls[SCROLL_ALTERNATE], "Alternate" );
AddPart( AddTo, m_fScrolls[SCROLL_CROSS], "Cross" );
AddPart( AddTo, m_fScrolls[SCROLL_CENTERED], "Centered" );
AddPart( AddTo, m_fDark, "Dark" );
AddPart( AddTo, m_fBlind, "Blind" );
AddPart( AddTo, m_fCover, "Cover" );
AddPart( AddTo, m_fRandAttack, "RandomAttacks" );
AddPart( AddTo, m_fNoAttack, "NoAttacks" );
AddPart( AddTo, m_fPlayerAutoPlay, "PlayerAutoPlay" );
AddPart( AddTo, m_fPassmark, "Passmark" );
AddPart( AddTo, m_fRandomSpeed, "RandomSpeed" );
if( m_bTurns[TURN_MIRROR] ) AddTo.push_back( "Mirror" );
if( m_bTurns[TURN_BACKWARDS] ) AddTo.push_back( "Backwards" );
if( m_bTurns[TURN_LEFT] ) AddTo.push_back( "Left" );
if( m_bTurns[TURN_RIGHT] ) AddTo.push_back( "Right" );
if( m_bTurns[TURN_SHUFFLE] ) AddTo.push_back( "Shuffle" );
if( m_bTurns[TURN_SOFT_SHUFFLE] ) AddTo.push_back( "SoftShuffle" );
if( m_bTurns[TURN_SUPER_SHUFFLE] ) AddTo.push_back( "SuperShuffle" );
if( m_bTransforms[TRANSFORM_NOHOLDS] ) AddTo.push_back( "NoHolds" );
if( m_bTransforms[TRANSFORM_NOROLLS] ) AddTo.push_back( "NoRolls" );
if( m_bTransforms[TRANSFORM_NOMINES] ) AddTo.push_back( "NoMines" );
if( m_bTransforms[TRANSFORM_LITTLE] ) AddTo.push_back( "Little" );
if( m_bTransforms[TRANSFORM_WIDE] ) AddTo.push_back( "Wide" );
if( m_bTransforms[TRANSFORM_BIG] ) AddTo.push_back( "Big" );
if( m_bTransforms[TRANSFORM_QUICK] ) AddTo.push_back( "Quick" );
if( m_bTransforms[TRANSFORM_BMRIZE] ) AddTo.push_back( "BMRize" );
if( m_bTransforms[TRANSFORM_SKIPPY] ) AddTo.push_back( "Skippy" );
if( m_bTransforms[TRANSFORM_MINES] ) AddTo.push_back( "Mines" );
if( m_bTransforms[TRANSFORM_ATTACKMINES] ) AddTo.push_back( "AttackMines" );
if( m_bTransforms[TRANSFORM_ECHO] ) AddTo.push_back( "Echo" );
if( m_bTransforms[TRANSFORM_STOMP] ) AddTo.push_back( "Stomp" );
if( m_bTransforms[TRANSFORM_PLANTED] ) AddTo.push_back( "Planted" );
if( m_bTransforms[TRANSFORM_FLOORED] ) AddTo.push_back( "Floored" );
if( m_bTransforms[TRANSFORM_TWISTER] ) AddTo.push_back( "Twister" );
if( m_bTransforms[TRANSFORM_HOLDROLLS] ) AddTo.push_back( "HoldsToRolls" );
if( m_bTransforms[TRANSFORM_NOJUMPS] ) AddTo.push_back( "NoJumps" );
if( m_bTransforms[TRANSFORM_NOHANDS] ) AddTo.push_back( "NoHands" );
if( m_bTransforms[TRANSFORM_NOLIFTS] ) AddTo.push_back( "NoLifts" );
if( m_bTransforms[TRANSFORM_NOFAKES] ) AddTo.push_back( "NoFakes" );
if( m_bTransforms[TRANSFORM_NOQUADS] ) AddTo.push_back( "NoQuads" );
if( m_bTransforms[TRANSFORM_NOSTRETCH] )AddTo.push_back( "NoStretch" );
if( m_bMuteOnError ) AddTo.push_back( "MuteOnError" );
switch( m_FailType )
{
case FailType_Immediate: break;
case FailType_ImmediateContinue: AddTo.push_back("FailImmediateContinue"); break;
case FailType_EndOfSong: AddTo.push_back("FailAtEnd"); break;
case FailType_Off: AddTo.push_back("FailOff"); break;
default:
FAIL_M(ssprintf("Invalid FailType: %i", m_FailType));
}
if( m_fSkew==0 && m_fPerspectiveTilt==0 )
{
AddTo.push_back( "Overhead" );
}
else if( m_fSkew == 0 )
{
if( m_fPerspectiveTilt > 0 )
AddPart( AddTo, m_fPerspectiveTilt, "Distant" );
else
AddPart( AddTo, -m_fPerspectiveTilt, "Hallway" );
}
else if( fabsf(m_fSkew-m_fPerspectiveTilt) < 0.0001f )
{
AddPart( AddTo, m_fSkew, "Space" );
}
else if( fabsf(m_fSkew+m_fPerspectiveTilt) < 0.0001f )
{
AddPart( AddTo, m_fSkew, "Incoming" );
}
else
{
AddPart( AddTo, m_fSkew, "Skew" );
AddPart( AddTo, m_fPerspectiveTilt, "Tilt" );
}
// Don't display a string if using the default NoteSkin unless we force it.
if( bForceNoteSkin || (!m_sNoteSkin.empty() && m_sNoteSkin != CommonMetrics::DEFAULT_NOTESKIN_NAME.GetValue()) )
{
RString s = m_sNoteSkin;
Capitalize( s );
AddTo.push_back( s );
}
}
void process() {
int i;
for (i = 0; i < fdefList.size(); i++) {
SgFunctionDefinition* fndef = fdefList.at(i);
if (fndef == NULL) {
return;
}
std::string functionName =
fndef->get_declaration()->get_name().getString();
SgFunctionDeclaration *f = fndef->get_declaration();
if (!debugHooks) {
SgNode *body = fndef->get_body();
// Move any preprocessing info before the function to a new
// null statement preceding the function.
AttachedPreprocessingInfoType save_buf;
SageInterface::cutPreprocessingInfo(f,
PreprocessingInfo::before,
save_buf) ;
if (save_buf.size()) {
SgVariableDeclaration *dummy =
SageBuilder::buildVariableDeclaration(
"___htc_dummy_decl_for_preproc_info",
SageBuilder::buildIntType(), 0, f->get_scope());
SageInterface::setExtern(dummy);
SageInterface::insertStatementBefore(f, dummy);
SageInterface::pastePreprocessingInfo(
dummy,
PreprocessingInfo::before,
save_buf);
}
SageInterface::addTextForUnparser(
f,
"\n#if 0",
AstUnparseAttribute::e_before);
std::string CapFnName = Capitalize(functionName);
std::string before_body = "\n#endif\n";
std::string macro_name = "HTC_KEEP_MODULE_" + Upper(functionName);
before_body +=
"#ifdef " +
macro_name +
"\n";
before_body += "#include \"Ht.h\"\n";
before_body += "#include \"Pers" +
CapFnName +
".h\"\n";
before_body += "#ifndef __htc_GW_write_addr\n";
before_body += "#define __htc_GW_write_addr(v,a) v.write_addr(a)\n";
before_body += "#endif\n";
before_body += "#ifndef __htc_GW_write_addr2\n";
before_body += "#define __htc_GW_write_addr2(v,a,b) v.write_addr(a,b)\n";
before_body += "#endif\n";
before_body += "void CPers" +
CapFnName +
"::Pers" +
CapFnName +
"()\n";
SageInterface::addTextForUnparser(body, before_body,
AstUnparseAttribute::e_before);
std::string after_body =
"\n#endif /* " +
macro_name +
" */\n";
SageInterface::addTextForUnparser(body, after_body,
AstUnparseAttribute::e_after);
// Write the _src.cpp file
generate_src_cpp_file(fndef, CapFnName, macro_name);
}
}
for (i = 0; i < fdeclList.size(); i++) {
SgFunctionDeclaration *fdecl = fdeclList.at(i);
if (!debugHooks &&
fdecl &&
fdecl->get_definingDeclaration() != fdecl) {
// Move any preprocessing info before the function to a new
// null statement preceding the function.
AttachedPreprocessingInfoType save_buf;
SageInterface::cutPreprocessingInfo(fdecl,
PreprocessingInfo::before,
save_buf) ;
if (save_buf.size()) {
SgVariableDeclaration *dummy2 =
SageBuilder::buildVariableDeclaration(
"___htc_dummy_decl2_for_preproc_info",
SageBuilder::buildIntType(),
0,
fdecl->get_scope());
SageInterface::setExtern(dummy2);
SageInterface::insertStatementBefore(fdecl, dummy2);
SageInterface::pastePreprocessingInfo(
dummy2,
PreprocessingInfo::before,
save_buf);
}
SageInterface::addTextForUnparser(fdecl, "\n/* ",
AstUnparseAttribute::e_before);
SageInterface::addTextForUnparser(fdecl, " */",
AstUnparseAttribute::e_after);
// comment out function prototypes
// fdecl->setCompilerGenerated();
// fdecl->unsetOutputInCodeGeneration();
}
}
}
bool GetAcceleratorTexts(HACCEL hAccel, std::map<UINT, CString>& mapId2AccelText) {
if(!hAccel)
return false;
int nAccelEntries = ::CopyAcceleratorTable(hAccel, 0, 0);
if(!nAccelEntries)
return true; // We're done - there were no accelerators (not an error per se)
ACCEL* pAccels = new ACCEL[nAccelEntries];
if(!::CopyAcceleratorTable(hAccel, pAccels, nAccelEntries)) {
delete [] pAccels;
return false;
}
for(int i = 0; i < nAccelEntries; ++i) {
CString strAccel;
CString strTemp;
if(pAccels[i].fVirt & FSHIFT) {
GetKeyName(VK_SHIFT, strTemp);
Capitalize(strTemp);
strAccel.Append(strTemp);
}
if(pAccels[i].fVirt & FCONTROL) {
if(strAccel.GetLength())
strAccel.Append(_T("+"));
GetKeyName(VK_CONTROL, strTemp);
Capitalize(strTemp);
strAccel.Append(strTemp);
}
if(pAccels[i].fVirt & FALT) {
if(strAccel.GetLength())
strAccel.Append(_T("+"));
GetKeyName(VK_MENU, strTemp);
Capitalize(strTemp);
strAccel.Append(strTemp);
}
if(pAccels[i].fVirt & FVIRTKEY) {
CString strKey;
if(GetKeyName(pAccels[i].key, strKey)) {
Capitalize(strKey);
if(strAccel.GetLength())
strAccel.Append(_T("+"));
strAccel.Append(strKey);
mapId2AccelText.insert(std::map<UINT, CString>::value_type(pAccels[i].cmd, strAccel));
}
} else {
// key field is an ASCII key code.
CString strKey;
#ifdef _UNICODE
char ca = (char)pAccels[i].key;
wchar_t cu;
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, &ca, 1, &cu, 1);
strKey.AppendChar(cu);
#else
strKey.AppendChar((char)pAccels[i].key); // Do NOT capitalize key as it's case sensitive
#endif
if(strAccel.GetLength())
strAccel.Append(_T("+"));
strAccel.Append(strKey);
mapId2AccelText.insert(std::map<UINT, CString>::value_type(pAccels[i].cmd, strAccel));
}
}
return true;
}
BOOL COleClipSource::DoImmediateRender()
{
if(m_bLoadedFormats)
return TRUE;
m_bLoadedFormats = true;
if(m_pasteOptions.m_pPasteFormats != NULL)
{
return PutFormatOnClipboard(m_pasteOptions.m_pPasteFormats) > 0;
}
INT_PTR count = m_ClipIDs.GetSize();
if(count <= 0)
return 0;
CClip clip;
if(count > 1)
{
CStringA SepA = CTextConvert::ConvertToChar(g_Opt.GetMultiPasteSeparator());
CCF_TextAggregator CFText(SepA);
if(m_ClipIDs.AggregateData(CFText, CF_TEXT, g_Opt.m_bMultiPasteReverse))
{
CClipFormat cf(CF_TEXT, CFText.GetHGlobal());
clip.m_Formats.Add(cf);
//clip.m_Formats now owns the global data
cf.m_autoDeleteData = false;
}
CStringW SepW = CTextConvert::ConvertToUnicode(g_Opt.GetMultiPasteSeparator());
CCF_UnicodeTextAggregator CFUnicodeText(SepW);
if(m_ClipIDs.AggregateData(CFUnicodeText, CF_UNICODETEXT, g_Opt.m_bMultiPasteReverse))
{
CClipFormat cf(CF_UNICODETEXT, CFUnicodeText.GetHGlobal());
clip.m_Formats.Add(cf);
//clip.m_Formats now owns the global data
cf.m_autoDeleteData = false;
}
if ((m_pasteOptions.LimitFormatsToText()) &&
clip.m_Formats.GetCount() == 0)
{
CCF_HDropAggregator HDrop;
if (m_ClipIDs.AggregateData(HDrop, CF_HDROP, g_Opt.m_bMultiPasteReverse))
{
CClipFormat cf(CF_UNICODETEXT, HDrop.GetHGlobalAsString());
clip.m_Formats.Add(cf);
//clip.m_Formats now owns the global data
cf.m_autoDeleteData = false;
}
}
else if (m_pasteOptions.LimitFormatsToText() == false)
{
CCF_HDropAggregator HDrop;
if(m_ClipIDs.AggregateData(HDrop, CF_HDROP, g_Opt.m_bMultiPasteReverse))
{
CClipFormat cf(CF_HDROP, HDrop.GetHGlobal());
clip.m_Formats.Add(cf);
//clip.m_Formats now owns the global data
cf.m_autoDeleteData = false;
}
CRichTextAggregator RichText(SepA);
if(m_ClipIDs.AggregateData(RichText, theApp.m_RTFFormat, g_Opt.m_bMultiPasteReverse))
{
CClipFormat cf(theApp.m_RTFFormat, RichText.GetHGlobal());
clip.m_Formats.Add(cf);
//clip.m_Formats now owns the global data
cf.m_autoDeleteData = false;
}
CHTMLFormatAggregator Html(SepA);
if(m_ClipIDs.AggregateData(Html, theApp.m_HTML_Format, g_Opt.m_bMultiPasteReverse))
{
CClipFormat cf(theApp.m_HTML_Format, Html.GetHGlobal());
clip.m_Formats.Add(cf);
//clip.m_Formats now owns the global data
cf.m_autoDeleteData = false;
}
}
}
if (count >= 1 && clip.m_Formats.GetCount() == 0)
{
clip.LoadFormats(m_ClipIDs[0], m_pasteOptions.LimitFormatsToText(), m_pasteOptions.IncludeRTFForTextOnly());
}
if (m_pasteOptions.LimitFormatsToText())
{
PlainTextFilter(clip);
}
if(m_pasteOptions.m_pasteUpperCase ||
m_pasteOptions.m_pasteLowerCase)
{
DoUpperLowerCase(clip, m_pasteOptions.m_pasteUpperCase);
}
else if(m_pasteOptions.m_pasteCapitalize)
{
Capitalize(clip);
}
else if(m_pasteOptions.m_pasteSentenceCase)
{
SentenceCase(clip);
}
else if(m_pasteOptions.m_pasteRemoveLineFeeds)
{
RemoveLineFeeds(clip);
}
else if(m_pasteOptions.m_pasteAddOneLineFeed)
{
AddLineFeeds(clip, 1);
}
else if (m_pasteOptions.m_pasteAddTwoLineFeeds)
{
AddLineFeeds(clip, 2);
}
else if (m_pasteOptions.m_pasteTypoglycemia)
{
Typoglycemia(clip);
}
return PutFormatOnClipboard(&clip.m_Formats) > 0;
}
void scCharArray::Transform( long startOffset,
long endOffset,
eChTranType trans,
int numChars )
{
CharRecordP chRec;
CharRecordP chStop;
UCS2 lastChar,
thisChar;
scHandleArrayLock h( this );
CharRecordP startChRec = (CharRecordP)*h;
chStop = startChRec + endOffset;
chRec = startChRec + startOffset;
if ( startOffset == 0 )
lastChar = scWordSpace;
else
lastChar = (chRec-1)->character;
#ifdef jis4051
// remove the special japanese stuff beyond the indicated boundary,
// because the boundaries maynot be accurate
if ( trans == eRemoveJapTran ) {
CharRecordP chRec2;
for ( chRec2 = chRec; --chRec2 >= startChRec; ) {
if ( chRec2->flags.IsSpecialNihon() ) {
chRec2->flags.ClrSpecialNihon();
chRec2->flags.ClrNoBreak();
}
else
break;
}
for ( chRec2 = chStop; chRec2->character && chRec2->flags.IsSpecialNihon(); chRec2++ ) {
chRec2->flags.ClrSpecialNihon();
chRec2->flags.ClrNoBreak();
}
}
#endif
for ( ; chRec < chStop; chRec++ ) {
thisChar = chRec->character;
if ( thisChar >= ' ' ) {
switch ( trans ) {
default:
case eNormalTran:
break;
case eLowerTran:
chRec->character = CTToLower( thisChar );
break;
case eUpperTran:
chRec->character = CTToUpper( thisChar );
break;
case eCapitalizeTran:
if ( Capitalize( lastChar ) )
chRec->character = CTToUpper( thisChar );
else
chRec->character = CTToLower( thisChar );
lastChar = thisChar;
break;
case eChangeCaseTran:
chRec->character = CTToggleCase( thisChar );
break;
case eNoBreakTran:
chRec->flags.SetNoBreak();
break;
case eAllowBreakTran:
chRec->flags.ClrNoBreak();
break;
#ifdef jis4051
case eWarichuTran:
chRec->flags.ClrSpecialNihon();
scAssert( numChars < 4 );
chRec->flags.SetWarichu( numChars );
break;
case eRenMojiTran:
chRec->flags.ClrSpecialNihon();
scAssert( numChars < 8 );
chRec->flags.SetRenMoji( numChars );
break;
case eRubiTran:
chRec->flags.ClrSpecialNihon();
chRec->flags.SetRubi( );
chRec->flags.SetNoBreak();
break;
case eRemoveJapTran: // remove the japanese transformations
chRec->flags.ClrSpecialNihon();
chRec->flags.ClrNoBreak();
break;
#endif
}
}
}
}
