AutomatedScreenshotController::WaitPredicate AutomatedScreenshotController::SelectedPinSceneSetup(const std::string& query, int searchMenuPinIx) const
{
const long long MsToWaitForSearchResults = 7000;
const long long MsToWaitForCameraToTransitionToPoi = 5000;
const long long MsWaitForPoiToOpen = 5000;
m_searchQueryPerformer.PerformSearchQuery(query, false, false);
return Seq(WaitMs(MsToWaitForSearchResults),
Act([=]() {
m_messageBus.Publish(SelectMenuItemMessage(searchMenuPinIx));
}),
WaitMs(MsToWaitForCameraToTransitionToPoi),
Act([=]() {
const float x = m_screenProperties.GetScreenWidth()/2.f;
const float y = m_screenProperties.GetScreenHeight()*(2.f/3.f);
m_worldPinsModule.GetWorldPinsService().HandleTouchTap({x, y});
}),
WaitMs(MsWaitForPoiToOpen),
Act([=]() {
m_searchQueryPerformer.RequestClear();
m_searchQueryPerformer.RemoveSearchQueryResults();
})
);
}
void Character::SendTell(Character *target, char *arg)
{
target->send(COLOR_RED(target, CL_NORMAL));
sprintf(buf, "$n tells you, '%s'", (char*)this->ScrambleSpeech(arg, target).c_str());
Act(buf, FALSE, this, 0, target, TO_VICT | TO_SLEEP);
target->send(COLOR_NORMAL(target, CL_NORMAL));
if(!IS_NPC(target) && NEWB_FLAGGED(target, NEW_TELL) && !IS_NPC(this))
{
REMOVE_BIT_AR(NEWB_FLAGS(target), NEW_TELL);
target->NewbieTip("You can reply to %s by typing 'reply' followed by the message you wish to send.\r\n",
GET_NAME(this), GET_NAME(this));
}
if (!IS_NPC(this) && PRF_FLAGGED(this, PRF_NOREPEAT))
this->send(OK);
else
{
CommManager::GetManager().SaveComm(std::string("tell"), arg, this, this->in_room->getVnum(), target);
sprintf(buf, "You tell $N, '%s'", arg);
Act(buf, FALSE, this, 0, target, TO_CHAR);
if(IS_NPC(target) && !IS_NPC(this))
MudLog(CMP, MAX(GET_LEVEL(this), LVL_GOD), TRUE, "%s tells %s '%s' in room %d.",
GET_NAME(this), GET_NAME(target), arg, this->in_room->getVnum());
if(this->IsIgnoring(target->player.name))
this->RemoveIgnore(target->player.name);
}
if (!IS_NPC(target) && !IS_NPC(this))
target->last_tell = this->player.idnum;
js_tell_triggers(this, target, arg);
}
VecDoub Actions_Spherical::angles_and_freqs(const VecDoub &x){
// call actions before
double E = Pot->H(x), L = Pot->L(x), Lz = Pot->Lz(x);
if(E>0.){
return {std::numeric_limits<double>::infinity(),L};
}
double r = sqrt(x[0]*x[0]+x[1]*x[1]+x[2]*x[2]);
VecDoub limits = find_limits(r,E,L);
double taubar = 0.5*(limits[0]+limits[1]);
double Delta = 0.5*(limits[1]-limits[0]);
Actions_Spherical_data_struct Act(Pot,E,L,Lz,Delta,taubar);
double OmegaR = Delta*GaussLegendreQuad(&dJrdH,-PI/2.,PI/2.,&Act,8)/PI;
OmegaR = 1./OmegaR;
double Omegap = Delta*GaussLegendreQuad(&dJrdL,-PI/2.,PI/2.,&Act,8)/PI;
Omegap*=-OmegaR;
VecDoub SPol = conv::CartesianToSphericalPolar(x);
double thetaLim = asin(MAX(-1.,MIN(1.,(SPol[0]-taubar)/Delta)));
double dSRdH=sign(SPol[3])*Delta*GaussLegendreQuad(&dJrdH,-PI/2.,thetaLim,&Act,8);
double dSRdL=sign(SPol[3])*Delta*GaussLegendreQuad(&dJrdL,-PI/2.,thetaLim,&Act);
double ThetaR = dSRdH*OmegaR;
double dStdL=sign(SPol[5])*GaussLegendreQuad(&dLdL,PI/2.,SPol[2],&Act,8);
// printVector(x);
double Thetap=dSRdL+dStdL+dSRdH*Omegap;
double LR=fabs(Lz)/L;
double sinu = LR/sqrt(1.-LR*LR)/tan(SPol[2]);
double u = 0.;
if(sinu>1.)
u=PI/2.;
else if(sinu<-1.)
u = -PI/2.;
else
u = asin(sinu);
if(SPol[5]>0.)
u=PI-u;
double Thetat=SPol[1]-u+sign(Lz)*Thetap;
if(SPol[5]>0.)
Thetat-=PI;
if(SPol[5]<0.) Thetap+=PI;
if(ThetaR>2.*PI) ThetaR-=2.*PI;
if(ThetaR<0.) ThetaR+=2.*PI;
if(Thetap>2.*PI) Thetap-=2.*PI;
if(Thetap<0.) Thetap+=2.*PI;
if(Thetat>2.*PI) Thetat-=2.*PI;
if(Thetat<0.) Thetat+=2.*PI;
if(Thetat<0.) Thetat+=2.*PI;
return {ThetaR,Thetat,Thetap,OmegaR,sign(Lz)*Omegap,Omegap};
}
VecDoub Actions_Spherical::find_limits(double r, double E, double L){
VecDoub limits;
Actions_Spherical_limits_struct Act(Pot,E,L);
double r_in=r, r_out=r;
root_find RF(SMALL,100);
if(p_r(0.,&Act)>0) r_in=0.;
else while(p_r(r_in,&Act)>=0.0) r_in*=0.9;
while(p_r(r_out,&Act)>=0.0) r_out*=1.1;
limits.push_back(RF.findroot(&p_r,r_in,r,&Act));
limits.push_back(RF.findroot(&p_r,r,r_out,&Act));
return limits;
}
VecDoub Actions_Spherical::actions(const VecDoub &x, void *params){
double r = sqrt(x[0]*x[0]+x[1]*x[1]+x[2]*x[2]);
double E = Pot->H(x), L = Pot->L(x), Lz = Pot->Lz(x);
if(E>0.){
return {std::numeric_limits<double>::infinity(),Lz,L-fabs(Lz)};
}
VecDoub limits = find_limits(r,E,L);
double taubar = 0.5*(limits[0]+limits[1]);
double Delta = 0.5*(limits[1]-limits[0]);
Actions_Spherical_data_struct Act(Pot,E,L,Lz,Delta,taubar);
double JR = Delta*GaussLegendreQuad(&J_r,-PI/2.,PI/2.,&Act,8)/PI;
return {JR,Lz,L-fabs(Lz)};
}
AutomatedScreenshotController::WaitPredicate AutomatedScreenshotController::SharedLandmarkSceneWaitPredicate(const bool openSearchMenu) const
{
const long long MsToWaitForWatermarkToSettle = 3000;
const long long MsToWaitForSearchResultsToReturn = 3000;
const long long MsToWaitForSearchMenuToOpen = 2000;
return Seq(WaitMs(MsToWaitForWatermarkToSettle),
Act([=]() { m_messageBus.Publish(SearchMenu::OpenSearchMenuMessage(openSearchMenu)); }),
WaitMs(MsToWaitForSearchMenuToOpen),
Act([=]() {
if (openSearchMenu)
{
m_messageBus.Publish(OpenSearchMenuSectionMessage([=](const Menu::View::IMenuSectionViewModel& section) {
return openSearchMenu && section.Name() == "Find";
}));
}
else
{
m_searchQueryPerformer.PerformSearchQuery("", true, false);
}
}),
WaitMs(MsToWaitForSearchResultsToReturn));
}
int is_tell_ok(Character *ch, Character *vict)
{
if( ch->IsPurged() )
return FALSE;
else if( vict->IsPurged() )
ch->send(NOPERSON);
else if(GET_RACE(vict) != GET_RACE(ch) && GET_LEVEL(ch) < LVL_IMMORT && GET_LEVEL(vict) < LVL_IMMORT && !IS_NPC(ch))
ch->send(NOPERSON);
else if (ch == vict)
ch->send("You try to tell yourself something.\r\n");
else if (!IS_NPC(ch) && PRF_FLAGGED(ch, PRF_NOTELL))
ch->send("You can't tell other people while you have notell on.\r\n");
else if ( AFF_FLAGGED(ch, AFF_SILENCE) && GET_LEVEL(ch) <= LVL_IMMORT )
ch->send("You try to speak, but nothing comes out!\r\n");
/*else if(ch->in_room == ch->StartRoom() && GET_LEVEL(ch) < LVL_IMMORT && GET_LEVEL(vict) < LVL_IMMORT &&
GET_LEVEL(ch) > 5)
ch->send("Your attempt to communicate into the Pattern fails.\r\n");*/
// else if(vict->in_room == vict->StartRoom() && GET_LEVEL(vict) < LVL_IMMORT && GET_LEVEL(ch) < LVL_IMMORT)
// ch->send("Your attempt to communicate outside of the Pattern fails.\r\n");
else if (ROOM_FLAGGED(ch->in_room, ROOM_SOUNDPROOF))
ch->send("The walls seem to absorb your words.\r\n");
else if (!IS_NPC(vict) && !vict->desc) /* linkless */
Act("$E's linkless at the moment.", FALSE, ch, 0, vict, TO_CHAR | TO_SLEEP);
else if (PRF_FLAGGED(ch, PRF_TELL_MUTE))
ch->send("You are mute to tells. You need an immortal to remove this.\r\n");
else if (PRF_FLAGGED(vict, PRF_TELL_MUTE))
Act("$E's is mute to tells... Try again later.", FALSE, ch, 0, vict, TO_CHAR | TO_SLEEP);
else if (PLR_FLAGGED(vict, PLR_WRITING))
Act("$E's writing a message right now; try again later.", FALSE, ch, 0, vict, TO_CHAR | TO_SLEEP);
else if ((!IS_NPC(vict) && PRF_FLAGGED(vict, PRF_NOTELL)) || ROOM_FLAGGED(vict->in_room, ROOM_SOUNDPROOF) ||
vict->IsIgnoring(GET_NAME(ch)))
Act("$E can't hear you.", FALSE, ch, 0, vict, TO_CHAR | TO_SLEEP);
else
return TRUE;
return FALSE;
}
display_hw AttachDisplayHW(uldat len, CONST byte *arg, uldat slot, byte flags) {
display_hw D_HW = NULL;
if ((len && len <= 4) || CmpMem("-hw=", arg, Min2(len,4))) {
printk("twin: specified `%.*s\' is not a known option.\n"
" try `twin --help' for usage summary.\n",
Min2((int)len,TW_SMALLBUFF), arg);
return D_HW;
}
if (All->ExclusiveHW) {
printk("twin: exclusive display in use, permission to display denied!\n");
return D_HW;
}
if (IsValidHW(len, arg) && (D_HW = Do(Create,DisplayHW)(FnDisplayHW, len, arg))) {
D_HW->AttachSlot = slot;
if (Act(Init,D_HW)(D_HW)) {
if (flags & TW_ATTACH_HW_EXCLUSIVE) {
/* started exclusive display, kill all others */
display_hw s_HW, n_HW;
All->ExclusiveHW = D_HW;
for (s_HW = All->FirstDisplayHW; s_HW; s_HW = n_HW) {
n_HW = s_HW->Next;
if (s_HW != D_HW)
Delete(s_HW);
}
}
if (ResizeDisplay()) {
QueuedDrawArea2FullScreen = TRUE;
}
return D_HW;
}
/* failed, clean up without calling RunNoHW() or KillSlot() */
D_HW->Quitted = TRUE;
D_HW->AttachSlot = NOSLOT;
D_HW->QuitHW = NoOp;
Delete(D_HW);
D_HW = NULL;
}
return D_HW;
}
void bench_delaunay()
{
Pt2di sz (950,950);
Disc_Pal Pdisc = Disc_Pal::P8COL();
Elise_Set_Of_Palette SOP(NewLElPal(Pdisc));
Video_Display Ecr((char *) NULL);
Ecr.load(SOP);
Video_Win W (Ecr,SOP,Pt2di(50,50),sz);
for (INT nb = 100; nb < 500 ; nb +=50)
{
std::list<PtDelTest> L;
ElFilo<PtDelTest> Pts;
for (INT k= 0; k< nb; k++)
{
PtDelTest pt
(
(INT)( 10 + (sz.x -20) * NRrandom3()),
(INT)( 10 + (sz.y -20) * NRrandom3())
);
// Pts.pushlast(pt);
L.push_back(pt);
//W.draw_circle_loc(pt.pt(),4,Pdisc(P8COL::red));
W.draw_circle_loc(Pt2dr(pt.pt()),4,Pdisc(P8COL::red)); // __NEW
}
DelTestAct Act(W);
Delaunay_Mediatrice
(
L.begin(),
L.end(),
Pt_of_DPT,
Act,
200.0,
(PtDelTest *) 0
);
// W.clik_in();
W.clear();
}
}
static void flush_tty(void) {
byte doupdate = tfalse;
dat i;
/* first, draw on screen whatever changed in the window */
if (dirtyN) {
if (dirtyN == TW_MAXBYTE)
DrawLogicWidget((widget)Win, 0, ScrollBack, SizeX-1, SizeY-1 + ScrollBack);
else for (i=0; i<dirtyN; i++)
DrawLogicWidget((widget)Win, dirty[i][0], dirty[i][1] + ScrollBack, dirty[i][2], dirty[i][3] + ScrollBack);
dirtyN = 0;
}
/* then update cursor */
if (Win->CurX != (ldat)X || Win->CurY != (ldat)Y + ScrollBack) {
Win->CurX = (ldat)X;
Win->CurY = (ldat)Y + ScrollBack;
Pos = Base + Win->CurX + (Win->CurY + Win->USE.C.HSplit) * SizeX;
if (Pos >= Split) Pos -= Split - Base;
doupdate = ttrue;
} else
doupdate = tfalse;
if ((doupdate || (*Flags & TTY_UPDATECURSOR)) && ContainsCursor((widget)Win))
UpdateCursor();
*Flags &= ~TTY_UPDATECURSOR;
/* finally, keyboard focus configuration: */
if (*Flags & TTY_NEEDREFOCUS) {
*Flags &= ~TTY_NEEDREFOCUS;
if (Win == (window)All->FirstScreen->FocusW)
Act(KbdFocus,Win)(Win);
}
}
VecDoub Actions_Spherical::Hessian(const VecDoub &x){
std::cerr<<"Currently not working!!"<<std::endl;
VecDoub Freq(2,0), AF = angles_and_freqs(x);
Freq[0]=AF[3];Freq[1]=AF[4];
double E = Pot->H(x), L = Pot->L(x), Lz = Pot->Lz(x);
double r = sqrt(x[0]*x[0]+x[1]*x[1]+x[2]*x[2]);
VecDoub limits = find_limits(r,E,L);
double taubar = 0.5*(limits[0]+limits[1]);
double Delta = 0.5*(limits[1]-limits[0]);
double drpdH = dr0dH(limits[0],L);
double dradH = dr0dH(limits[1],L);
double dDelta=0.5*(dradH-drpdH);
double dtaubar=0.5*(dradH+drpdH);
Actions_Spherical_data_struct Act(Pot,E,L,Lz,Delta,taubar,dDelta,dtaubar);
double d2JdH = Delta*GaussLegendreQuad(&d2JdH2,-PI/2.,PI/2.,&Act)/PI;
double drpdL = dr0dL(limits[0],L);
double dradL = dr0dL(limits[1],L);
dDelta=0.5*(dradL-drpdL);
dtaubar=0.5*(dradL+drpdL);
// double d2JdHdL2 = Delta*GaussLegendreQuad(&d2JdHdL,-PI/2.,PI/2.,&Act)/PI;
// d2JdH+=Delta*(dr0dH(limits[1])*dJrdH(PI/2.,&Act)-dr0dH(limits[0])*dJrdH(-PI/2.,&Act))/PI;
double dOmegadJR = -Freq[0]*Freq[0]*Freq[0]*d2JdH;
return {dOmegadJR};
}
static void set_mode(byte on_off) {
dat i;
for (i=0; i<=nPar; i++)
/* DEC private modes set/reset */
if (DState & ESques) switch (Par[i]) {
case 1: /* Cursor keys send ^[Ox/^[[x */
CHANGE_BIT(TTY_ALTCURSKEYS, on_off);
*Flags |= TTY_NEEDREFOCUS;
break;
case 3: /* 80/132 mode switch unimplemented */
break;
case 5: /* Inverted screen on/off */
CHANGE_BIT(TTY_INVERTSCR, on_off);
update_eff();
invert_screen();
break;
case 6: /* Origin relative/absolute */
CHANGE_BIT(TTY_RELORIG, on_off);
goto_axy(0,0);
break;
case 7: /* Autowrap on/off */
CHANGE_BIT(TTY_AUTOWRAP, on_off);
break;
case 8: /* Autorepeat on/off */
break;
case 9: /* new style */
CHANGE_BIT(TTY_REPORTMOUSE, on_off);
CHANGE_BIT(TTY_REPORTMOUSE2, tfalse);
Act(ChangeField,Win)
(Win, TWS_window_Attrib, WINDOW_WANT_MOUSE_MOTION|WINDOW_WANT_MOUSE,
on_off ? WINDOW_WANT_MOUSE : 0);
break;
case 25: /* Cursor on/off */
Act(ChangeField,Win)
(Win, TWS_window_Flags, WINDOWFL_CURSOR_ON, on_off ? WINDOWFL_CURSOR_ON : 0);
*Flags |= TTY_UPDATECURSOR;
break;
case 999: /* new style, report also motions */
CHANGE_BIT(TTY_REPORTMOUSE, on_off);
CHANGE_BIT(TTY_REPORTMOUSE2, on_off);
Act(ChangeField,Win)
(Win, TWS_window_Attrib, WINDOW_WANT_MOUSE|WINDOW_WANT_MOUSE_MOTION,
on_off ? WINDOW_WANT_MOUSE|WINDOW_WANT_MOUSE_MOTION : 0);
break;
case 1000: /* classic xterm style */
CHANGE_BIT(TTY_REPORTMOUSE, tfalse);
CHANGE_BIT(TTY_REPORTMOUSE2, on_off);
Act(ChangeField,Win)
(Win, TWS_window_Attrib, WINDOW_WANT_MOUSE|WINDOW_WANT_MOUSE_MOTION,
on_off ? WINDOW_WANT_MOUSE|WINDOW_WANT_MOUSE_MOTION : 0);
break;
/* ANSI modes set/reset */
} else switch (Par[i]) {
case 3: /* Monitor (display ctrls) */
CHANGE_BIT(TTY_DISPCTRL, on_off);
break;
case 4: /* Insert Mode on/off */
CHANGE_BIT(TTY_INSERT, on_off);
break;
case 20: /* Lf, Enter == CrLf/Lf */
CHANGE_BIT(TTY_CRLF, on_off);
break;
}
}
const std::array<AutomatedScreenshotController::SceneSetupFunction, AutomatedScreenshotController::NumScenes> AutomatedScreenshotController::States() const
{
return {{
[this]() {
const PlaceJumps::View::PlaceJumpModel London(
"London",
Eegeo::Space::LatLong::FromDegrees(51.512179, -0.080664),
162.2f,
1780.1f,
"");
m_placeJumpController.JumpTo(London);
m_weatherController.SetTime("Day");
m_weatherController.SetTheme("Summer");
return WaitMs(8000);
},
[this]() {
const long long WaitMsForInteriorToLoad = 4000;
const long long MsToWaitForCameraToEnterInterior = 3000;
const Eegeo::Resources::Interiors::InteriorId WestportHouseInteriorId("westport_house");
const Eegeo::Space::LatLong location(Eegeo::Space::LatLong::FromDegrees(56.460108, -2.978094));
const float distanceFromInterest = 200.f;
const PlaceJumps::View::PlaceJumpModel WestportHouse(
"WestportHouse",
location,
312.8f,
distanceFromInterest,
"");
m_placeJumpController.JumpTo(WestportHouse);
return Seq(WaitMs(WaitMsForInteriorToLoad),
Act([=]() { m_interiorSelectionModel.SelectInteriorId(WestportHouseInteriorId); }),
WaitMs(MsToWaitForCameraToEnterInterior),
Act([=]() {
m_cameraTransitionService.StartTransitionTo(location.ToECEF(), distanceFromInterest, WestportHouseInteriorId, 2, true);
}),
WaitForCameraTransition(&m_cameraTransitionService),
Act([=]() {
m_searchQueryPerformer.PerformSearchQuery("General", true, true);
}),
WaitMs(8000),
Act([=]() {
m_searchQueryPerformer.RequestClear();
m_searchQueryPerformer.RemoveSearchQueryResults();
})
);
},
[this]() {
return IsLandscapeLayout(m_screenProperties)
? TabletVASceneSetup(true)
: PhoneNYCSceneSetup(true);
},
[this]() {
return IsLandscapeLayout(m_screenProperties)
? TabletVASceneSetup(false)
: PhoneNYCSceneSetup(false);
},
[this]() {
return IsLandscapeLayout(m_screenProperties)
? SelectedPinSceneSetup("Victoria and Albert Museum", 2)
: SelectedPinSceneSetup("Empire State Building", 0);
},
[this]() {
static const std::string LightThemesManifestUrlDefault = "https://cdn-resources.wrld3d.com/mobile-themes-new/v883/ambientwhite/manifest.bin.gz";
const long long MsToWaitForSearchQueryToClear = 3000;
const long long MsToWaitForThemeToLoad = 3000;
const PlaceJumps::View::PlaceJumpModel SanFran(
"SanFran",
Eegeo::Space::LatLong::FromDegrees(37.742448, -122.446477),
27.2f,
1914.3f,
"");
m_messageBus.Publish(ClosePoiMessage());
m_messageBus.Publish(SearchMenu::OpenSearchMenuMessage(false));
m_placeJumpController.JumpTo(SanFran);
m_cityThemeLoader.LoadThemes(LightThemesManifestUrlDefault, "Summer", "DayDefault");
return Seq(WaitMs(MsToWaitForSearchQueryToClear),
Act([=]() {
m_searchQueryPerformer.RemoveSearchQueryResults(); }),
WaitForStreaming(&m_cityThemeLoader),
WaitMs(MsToWaitForThemeToLoad));
},
[this]() {
static const std::string SciFiThemesManifestUrlDefault = "https://cdn-resources.wrld3d.com/mobile-themes-new/v883/scifi/manifest.bin.gz";
const long long MsToWaitForSearchResultsToClearAndThemeToLoad = 3000;
const PlaceJumps::View::PlaceJumpModel LA(
"LA",
Eegeo::Space::LatLong::FromDegrees(34.051624, -118.254724),
187.6f,
1885.8f,
"");
m_placeJumpController.JumpTo(LA);
m_searchQueryPerformer.RemoveSearchQueryResults();
m_cityThemeLoader.LoadThemes(SciFiThemesManifestUrlDefault, "Summer", "DayDefault");
return Seq(WaitForStreaming(&m_cityThemeLoader),
WaitMs(MsToWaitForSearchResultsToClearAndThemeToLoad));
}
}};
}
ActionEvent::ActionEvent(Object* origin, ObjectManager* om)
{
source = origin;
manager = om;
Act();
}
int main(int argc, char **argv)
{
//*********************************************
// D I A G N O S T I C S
//Diagnostic used for error and warning!! its possible to create a DiagnosticClient for handling displays of it
llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> DiagOpts = new clang::DiagnosticOptions(); //Options for controlling the compiler diagnostics engine.
//the printing client
clang::TextDiagnosticPrinter *DiagClient = new clang::TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
//Can be used and shared by multiple Diagnostics for multiple translation units.
llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> pDiagIDs;
//Concrete class used by the front-end to report problems and issues.
clang::DiagnosticsEngine Diags(pDiagIDs, &*DiagOpts, DiagClient); //had false at the end??
//ins: _ClangExecutable, _DefaultTargetTriple, _DefaultImageName, _Diags
// std::string Path = "/mnt/storage/workspaces/yuk_dev/llvm_testProject/src/clang_interpreter/aa";
clang::driver::Driver TheDriver("", llvm::sys::getProcessTriple(), "a.out", Diags); // Encapsulate logic for constructing compilation processes from a set of gcc-driver-like command line arguments
TheDriver.setTitle("cppjittest");
llvm::SmallVector<const char *, 16> Args(argv, argv + argc);
Args.push_back("test.cpp");
Args.push_back("-fsyntax-only");
llvm::OwningPtr<clang::driver::Compilation> C(TheDriver.BuildCompilation(Args)); //Construct a compilation object for a command line argument vector.
if (!C)
{
printf("unable to create compiler\n");
return 0;
}
// We expect to get back exactly one command job, if we didn't something
// failed. Extract that job from the compilation.
const clang::driver::JobList &Jobs = C->getJobs();
if (Jobs.size() != 1 || !llvm::isa<clang::driver::Command>(*Jobs.begin()))
{
llvm::SmallString<256> Msg;
llvm::raw_svector_ostream OS(Msg);
Jobs.Print(OS, "; ", true);
Diags.Report(clang::diag::err_fe_expected_compiler_job) << OS.str();
return 1;
}
const clang::driver::Command *Cmd = llvm::cast<clang::driver::Command>(*Jobs.begin());
if (llvm::StringRef(Cmd->getCreator().getName()) != "clang")
{
Diags.Report(clang::diag::err_fe_expected_clang_command);
return 1;
}
// Initialize a compiler invocation object from the clang (-cc1) arguments. helper class for holding the data necessary to invoke the compile
const clang::driver::ArgStringList &CCArgs = Cmd->getArguments();
//nasty fix to remove -disable-free, otherwise leaks
clang::driver::ArgStringList newArgList;
for(unsigned int i = 0; i < CCArgs.size(); ++i)
{
if("-disable-free" == CCArgs[i])
continue;
newArgList.push_back(CCArgs[i]);
}
llvm::OwningPtr<clang::CompilerInvocation> CI(new clang::CompilerInvocation);
clang::CompilerInvocation::CreateFromArgs(*CI, const_cast<const char **>(newArgList.data()),
const_cast<const char **>(newArgList.data()) + newArgList.size(), Diags);
//for now
CI->getHeaderSearchOpts().Verbose = 1;
// Show the invocation, with -v.
if (CI->getHeaderSearchOpts().Verbose)
{
llvm::errs() << "clang invocation:\n";
Jobs.Print(llvm::errs(), "\n", true);
llvm::errs() << "\n";
}
// Create a compiler instance to handle the actual work.
clang::CompilerInstance Clang;
Clang.setInvocation(CI.take());
// Create the compilers actual diagnostics engine.
Clang.createDiagnostics();
if (!Clang.hasDiagnostics())
{
printf("unable to create diagnostics");
return 1;
}
// Infer the builtin include path if unspecified.
if (Clang.getHeaderSearchOpts().UseBuiltinIncludes && Clang.getHeaderSearchOpts().ResourceDir.empty())
{
printf("no resources, should setup resource here i guess??\n");
return 1;
}
//! @warning hardcoded path!!!!
Clang.getHeaderSearchOpts().AddPath("/mnt/storage/development/cpp/llvm/checkout/install/lib/clang/3.4/include", clang::frontend::Angled, false, false);
// ----//
// Create and execute the frontend to generate an LLVM bitcode module.
llvm::OwningPtr<clang::CodeGenAction> Act(new clang::EmitLLVMOnlyAction());
if (!Clang.ExecuteAction(*Act))
return 1;
llvm::Module *Module = Act->takeModule();
// Print all functions in the module
for (llvm::Module::FunctionListType::iterator i = Module->getFunctionList().begin(); i != Module->getFunctionList().end(); ++i)
printf("%s\n", i->getName().str().c_str());
llvm::outs() << *Module;
(void)Execute(Module);
C->getJobs().clear();
llvm::llvm_shutdown();
return 0;
}
void JS_act( flusspferd::array args )
{
if( args.size() < 6 )
return;
Object *vObj=0, *rObj = 0;
Character *vChar=0, *rChar = 0;
flusspferd::object ch, obj, vict_obj;
std::string str;
int hide_invis, type;
if( !args.get_element(0).is_string() )
{
MudLog(NRM, LVL_BUILDER, TRUE, "JSTrigger Error : act() - First argument is not a string.");
return;
}
if( !args.get_element(1).is_boolean() )
{
MudLog(NRM, LVL_BUILDER, TRUE, "JSTrigger Error : act() - Second argument is not a boolean.");
return;
}
if( !args.get_element(2).is_object() )
{
MudLog(NRM, LVL_BUILDER, TRUE, "JSTrigger Error : act() - Third argument is not an object.");
return;
}
if( !args.get_element(3).is_object() )
{
MudLog(NRM, LVL_BUILDER, TRUE, "JSTrigger Error : act() - Fourth argument is not an object.");
return;
}
if( !args.get_element(4).is_object() )
{
MudLog(NRM, LVL_BUILDER, TRUE, "JSTrigger Error : act() - Fifth argument is not an object.");
return;
}
if( !args.get_element(5).is_int() )
{
MudLog(NRM, LVL_BUILDER, TRUE, "JSTrigger Error : act() - Sixth argument is not an integer.");
return;
}
str = args.get_element(0).to_std_string();
hide_invis = args.get_element(1).get_bool() ? 1 : 0;
ch = args.get_element(2).get_object();
obj = args.get_element(3).get_object();
vict_obj = args.get_element(4).get_object();
type = args.get_element(5).get_int();
if( !ch.is_null() )
{
if( is_native<JSCharacter>(ch) )
rChar = flusspferd::get_native<JSCharacter>(ch).toReal();
else //ERROR!
return;
}
if( !obj.is_null() )
{
if( is_native<JSObject>(obj) )
rObj = flusspferd::get_native<JSObject>(obj).toReal();
else //ERROR!
return;
}
if( !vict_obj.is_null() )
{
if( is_native<JSCharacter>(vict_obj) )
vChar = flusspferd::get_native<JSCharacter>(vict_obj).toReal();
else if( is_native<JSObject>(vict_obj) )
vObj = flusspferd::get_native<JSObject>(vict_obj).toReal();
else {
//Report error.
return;
}
}
if( vChar && vChar->IsPurged() )
vChar = 0;
if( vObj && vObj->IsPurged() )
vObj = 0;
Act( str.c_str(), hide_invis, rChar, rObj, (vChar ? (void*)vChar : (void*)vObj), type );
}
