PEBL.cpp File Reference

#include "Globals.h"
#include "../base/Evaluator.h"
#include "../devices/PEventLoop.h"
#include "../base/grammar.tab.hpp"
#include "../base/PNode.h"
#include "../base/Loader.h"
#include "../base/PComplexData.h"
#include "../base/PList.h"
#include "../base/FunctionMap.h"
#include "../base/VariableMap.h"
#include "../base/Variant.h"
#include "../libs/PEBLObjects.h"
#include "../utility/PError.h"
#include "../utility/PEBLPath.h"
#include "../utility/PEBLUtility.h"
#include "../utility/rc_ptrs.h"
#include "../utility/BinReloc.h"
#include <iostream>
#include <signal.h>
#include <list>
#include <string>
#include <algorithm>
#include <fstream>
#include "../platforms/sdl/PlatformEnvironment.h"
#include "../platforms/sdl/SDLUtility.h"

Go to the source code of this file.

Functions
void	SignalTestComplete (const char *status="completed")
PNode *	parse (const char *filename)
std::list< string >	GetFiles (int argc, std::vector< std::string > argv)
void	PrintOptions ()
int	PEBLInterpret (int argc, std::vector< std::string > argv)
void	CaptureSignal (int signal)
int	main (int argc, char *argv[])

Variables
Evaluator *	myEval = NULL
PlatformEnvironment *	myEnv = NULL
Loader *	myLoader
PNode *	head

Function Documentation

CaptureSignal()

void CaptureSignal

(

int

signal

)

Definition at line 930 of file PEBL.cpp.

{
    cerr << "Exiting PEBL because of captured signal.\n";
 
#ifdef WIN32
    // Restore back when going to windowed or shutting down
    AllowAccessibilityShortcutKeys( false );
 
#endif // WIN32
 
    // Signal completion to JavaScript launcher (for test chains)
    SignalTestComplete("signal");
 
    Evaluator::gGlobalVariableMap.Destroy();
 
    if(myLoader)  delete myLoader;
    if(myEnv) delete myEnv;
    Evaluator::mFunctionMap.Destroy();
 
 
    //Evaluator::gGlobalVariableMap.DumpValues();
 
#ifdef PEBL_MOVIES
    //Close the wave player library.
    WV_waaveClose();
#endif
 
 
    //quit SDL here.  It should be killed else
    SDL_Quit();
 
 
    //Something is not being cleaned up still.
    raise(signal);
    exit(1);  // Exit with error code 1 when terminated by signal
}

References FunctionMap::Destroy(), VariableMap::Destroy(), Evaluator::gGlobalVariableMap, Evaluator::mFunctionMap, myEnv, myLoader, and SignalTestComplete().

Referenced by main().

GetFiles()

std::list< std::string > GetFiles	(	int	argc,
		std::vector< std::string >	argv
	)

Definition at line 1185 of file PEBL.cpp.

{
 
    std::list<std::string> tmp;
    std::vector<std::string>::iterator i = argv.begin();
 
 
//    i++;
 
    while(i != argv.end())//int i = 1; i < argc; i++) //skip the first argv, which is just executable name.
        {
            if(i->compare( "-v")==0 ||
               i->compare("-V")==0 ||
               i->compare( "-s")==0 ||
               i->compare( "-S") == 0 ||
               i->compare( "--language")==0 ||
               i->compare("--pfile")==0  ||
               i->compare("--upload")==0)
 
                {
                    //This is the variable switch.  get rid of it and the next argument.
                    i++;
                }
            else if(i->compare("--lsl")==0)
                {
                    // LSL flag - check if next arg is a stream name (not a flag or .pbl file)
                    std::vector<std::string>::iterator next = i;
                    next++;
                    if(next != argv.end() &&
                       next->c_str()[0] != '-' &&
                       next->find(".pbl") == std::string::npos)
                    {
                        // Next arg is stream name, skip it too
                        i++;
                    }
                    // Otherwise just skip the --lsl flag itself
                }
            else if (i->compare("--driver")==0 ||
                     i->compare("--display")==0 ||
                     i->compare("--depth")==0 )
 
                {
                    //This is a video driver switch.
                    i++;
                }
            else if (i->compare("--windowed")==0 ||
                     i->compare("--fullscreen")==0 ||
                     i->compare("--unicode")==0 ||
                     i->compare("--resizeable")==0 ||
                     i->compare("--resizable")==0||
                     i->compare("--vsyncoff")==0||
                     i->compare("--vsyncon")==0 ||
                     i->compare("--softrender")==0 ||
                     i->compare("--help")==0 ||
                     i->compare("--showtestresults")==0
                     )
 
 
                {
                    //Don't bother incrementing 'i'
                }
            else
                {
                    //Any other command line arguments are files to load.
                   // cout << "Adding: [" << *i << "]" << endl;
 
                    tmp.push_back(std::string(*i));
                }
            i++;
        }
    return tmp;
}

Referenced by PEBLInterpret().

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 968 of file PEBL.cpp.

{
 
#ifdef PEBL_EMSCRIPTEN
    EM_ASM(console.log("=== main() called in PEBL.cpp ==="));
#endif
 
#ifdef PEBL_WIN32
// With NO_STDIO_REDIRECT defined, SDL doesn't create stdout.txt/stderr.txt
// Don't use freopen - inherit stdout/stderr from parent process
// This allows shell redirection (> stdout.txt 2> stderr.txt) to work
// Note: stdout/stderr may not exist if run from GUI, but will work from terminal
#endif // PEBL_WIN32
 
 
 
  int newargc = argc;
    //  Set up some signals to capture
#ifdef SIGHUP
    signal(SIGHUP, CaptureSignal);
#endif
 
#ifdef SIGKILL
    signal(SIGKILL, CaptureSignal);
#endif
 
#ifdef SIGSTOP
    signal(SIGSTOP, CaptureSignal);
#endif
 
    //#ifdef SIGTERM
    //    signal(SIGTERM, CaptureSignal);
    //#endif
 
    signal(SIGINT, CaptureSignal);
 
 
#ifdef SIGQUIT
    signal(SIGQUIT, CaptureSignal);
#endif
 
 
    signal(SIGTERM, CaptureSignal);
 
    //char** new_argv = NULL;
    std::vector<std::string> newargv;
 
 
//Put code here that runs on only one of the platforms
 
#if defined(PEBL_OSX)
 
    //Find the location of the app bundle; save it to global variables etc.:
    CFBundleRef mainBundle = CFBundleGetMainBundle();
    CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle);
    char resourcepath[PATH_MAX];
    if (!CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8 *)resourcepath, PATH_MAX))
    {
        PError::SignalFatalError("Unable to identify resource location.\n");// error!
    }
    CFRelease(resourcesURL);
 
 
    //Identify location for the launcher script, which should be in the resources path.
    std::string script = "/launcher.pbl";
    std::string basedir = (std::string)resourcepath ;
    std::string launch = basedir + script;
 
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLResourcePath",Variant(resourcepath));
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLBasePath",Variant(basedir));
    std::cerr << "Basedir:" << basedir << endl;
    std::cerr << "launch: " << launch << endl;
 
 
#elif defined(PEBL_WIN32)
 
 
    SystemParametersInfo(SPI_GETSTICKYKEYS, sizeof(STICKYKEYS), &g_StartupStickyKeys, 0);
    SystemParametersInfo(SPI_GETTOGGLEKEYS, sizeof(TOGGLEKEYS), &g_StartupToggleKeys, 0);
    SystemParametersInfo(SPI_GETFILTERKEYS, sizeof(FILTERKEYS), &g_StartupFilterKeys, 0);
 
    // Disable when usuing PEBL (reenable later?)
    AllowAccessibilityShortcutKeys( false );
    string basedir = PEBLUtility::StripFile(argv[0]) + "..\\";
 
 
    std::string resourcepath = basedir;
    std::string launch = "launcher.pbl";
    std::string script = resourcepath+"/pebl-lib/"+launch;
 
 
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLResourcePath",Variant(basedir));
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLBasePath",Variant(basedir));
 
 
#elif defined (PEBL_LINUX)
 
 
    string basedir;
    BrInitError error;
    if (br_init (&error) == 0 && error != BR_INIT_ERROR_DISABLED)
    {
        PError::SignalWarning("Warning: BinReloc failed to initialize.\n Will fallback to current directory.\n");
        basedir = "./";
    } else {
        // Get directory containing the executable
        char* exe_dir = br_find_exe_dir("");
        if (exe_dir != NULL) {
            // Go up one level from bin/ to get base directory
            basedir = string(exe_dir) + string("/../");
            std::cerr << "Executable directory: [" << exe_dir << "]\n";
            free(exe_dir);
        } else {
            basedir = "./";
        }
    }
 
    std::string resourcepath = basedir;
    std::string launch = basedir + "bin/launcher.pbl";
    std::string script = "";
 
//    cout << "resources:  " << resourcepath << endl;
//    cout << "script:     " << script<< endl;
//    cout << "launch:     " << launch << endl;
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLResourcePath",Variant(resourcepath));
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLBasePath",Variant(basedir));
 
 
#elif defined (PEBL_EMSCRIPTEN)
 
    std::string basedir = "/usr/local/share/pebl2";
 
    std::string resourcepath = basedir;
    // For Emscripten, script path should always be passed via Module.callMain()
    // No default launcher - require explicit arguments
    std::string launch = "";
    std::string script = "";
 
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLResourcePath",Variant(resourcepath));
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLBasePath",Variant(basedir));
 
#endif
 
 
      //Identify home directory; it is an environment variable.
      std::string home = "";
      char* val = getenv("HOME");
      if(val)
      {
          home = val;
      }
 
 
    //If there are no command-line arguments (including files),
    //print usage and exit.  The native pebl-launcher handles the GUI on Linux.
 
    if(newargc == 1)
        {
#if defined(PEBL_LINUX)
            // On Linux, pebl2 requires an explicit script argument.
            // The GUI launcher (pebl-launcher) handles the no-argument case.
            PrintOptions();
            cout << "\nTo launch the graphical study manager, run: pebl-launcher\n";
            return 0;
#elif defined(PEBL_WIN32)
            // On Windows, a double-click on pebl2.exe should open the GUI launcher.
            // pebl-launcher.exe lives in the same bin\ directory as pebl2.exe.
            {
                std::string launcherExe = PEBLUtility::StripFile(argv[0]) + "pebl-launcher.exe";
                std::cerr << "No script specified. Launching: " << launcherExe << "\n";
                HINSTANCE result = ShellExecuteA(NULL, "open",
                                                 launcherExe.c_str(),
                                                 NULL,
                                                 PEBLUtility::StripFile(argv[0]).c_str(),
                                                 SW_SHOWNORMAL);
                if ((INT_PTR)result <= 32)
                {
                    // ShellExecute failed (returns value <= 32 on error).
                    // Fall back to printing help so the user knows what to do.
                    PrintOptions();
                    cerr << "\nNote: pebl-launcher.exe not found at " << launcherExe << "\n";
                }
                return 0;
            }
#else
            // macOS / other: just print help.
            PrintOptions();
            return 0;
#endif
 
        } else{
            //This is what happens when argc != 1 (when there ARE arguments), on any platform
            newargc=0;
            for(int i=0; i < argc; i++)
            {
                newargv.push_back(argv[i]);
                newargc++;
                //cout << argv[i] << endl;
            }
        }
 
 
 
    Evaluator::gGlobalVariableMap.AddVariable("gWorkingDirectory",
                                            PEBLUtility::GetWorkingDirectory());
 
 
     std::cerr<< "Working directory: " << PEBLUtility::GetWorkingDirectory() << endl;
 
 
 
 
    return PEBLInterpret(newargc, newargv);
}

References VariableMap::AddVariable(), br_find_exe_dir(), br_init(), BR_INIT_ERROR_DISABLED, CaptureSignal(), PEBLUtility::GetWorkingDirectory(), Evaluator::gGlobalVariableMap, NULL, PEBLInterpret(), PrintOptions(), PError::SignalFatalError(), PError::SignalWarning(), and PEBLUtility::StripFile().

parse()

PNode * parse

(

const char *

filename

)

This is the main PEBL interpreter program. It takes files as command-line arguments, which it parses with the bison parser, creating a single tree of PNodes. Then, it feeds this tree into the loader, which loads the individual functions into a function map. Then, it sets up any global entities: a graphical environment, a timer, a global variable map. Finally, it locates the 'Start' function and executes it.

PEBLInterpret()

int PEBLInterpret	(	int	argc,
		std::vector< std::string >	argv
	)

Definition at line 229 of file PEBL.cpp.

{
 
#ifdef PEBL_EMSCRIPTEN
   EM_ASM(console.log("=== PEBLInterpret() called ==="));
#endif
 
   std::cerr << "**************Starting PEBLInterpret\n";
   std::cerr << "**************argc:" << argc << endl;
 
#if defined(PEBL_UNIX) and not defined(PEBL_OSX)
    if(argc==2 && strcmp(argv[1].c_str(), "--install")==0)
        {
            string basedir;
            BrInitError error;
            if (br_init (&error) == 0 && error != BR_INIT_ERROR_DISABLED)
                {
                    PError::SignalWarning("Warning: BinReloc failed to initialize.\n Will fallback to hardcoded default path.\n");
                    //basedir = "/usr/local/share/pebl/";
                    basedir = "/usr/local/share/pebl2";
                }
 
            string prefix = br_find_prefix("/usr/local/");
            basedir = prefix + string("/share/pebl2/battery/");
            string destdir = string("~/Documents/pebl-exp.") + PEBL_VERSION;
 
            //Now, copy everything in 'battery' to your documents directory.
            //std::cerr << "Creating Documents/pebl-exp.0.14 Directory\n";
            PEBLUtility::SystemCall("mkdir ~/Documents","");
            PEBLUtility::SystemCall("mkdir "+destdir,"");
            std::cerr << "Copying files to ["+destdir+ "]\n";
            PEBLUtility::SystemCall("cp -R "+ basedir + " " + destdir,"");
            exit(0);
        }
#endif
 
    PNode * tmp = NULL;
 
    //Cycle through command-line parameters extracting the files.
    //This does not check for file validity, it just removes any other command-line options,
    //i.e. ones that are of the form <-flag> <option> or whatever.
   //
 
#if 1
    //THis is just for debugging purposes.
    cerr << "************Arguments: "<< argv.size()<<"\n";
    std::vector<std::string>::iterator ii = argv.begin();
     while(ii != argv.end())
     {
         cerr << *ii << endl;
         ii++;
         cerr << "********\n";
     }
#endif
 
 
     //get the test file from the command line:
    std::list<std::string> files = GetFiles(argc, argv);
 
    //Set up the search path.
    Evaluator::gPath.Initialize(files);
 
    cerr << "PATH:"  << Evaluator::gPath;
 
    //Add the built-in PEBL libraries to the files list.
    files.push_back("Design.pbl");
    files.push_back("Utility.pbl");
    files.push_back("Math.pbl");
    files.push_back("Graphics.pbl");
    files.push_back("UI.pbl");
    files.push_back("HTML.pbl");
    files.push_back("Transfer.pbl");  // Network/HTTP file transfer functions
    files.push_back("Layout.pbl");    // Layout & response system with nested properties
 
#ifdef PEBL_EMSCRIPTEN
   files.push_back("EM.pbl");
 
#endif
    //    files.push_back("Taguchi.pbl"); //not ready
 
   //this was already loaded on the command-line.
   //load/run test.pbl here.
#ifdef PEBL_EMSCRIPTEN
    //std::cout << "Loading filename:[test.pbl]\n";
    //files.push_back("test.pbl");
#endif
 
 
    //Process the first command-line argument.
    std::list<std::string>::iterator i = files.begin();
    i++;
 
    //-----------------------------------------------------------
    //        Process all files on the command-line
    //-----------------------------------------------------------
 
        std::cerr << "Loading filename:[" << *i << "]\n";
        string inputfilename = Evaluator::gPath.FindFile(*i);
    string otherfilename;
 
    head = NULL;
    if(inputfilename != "")
        {
            cerr << "Processing PEBL Source File1: " <<  inputfilename << endl;
            head  = parse(inputfilename.c_str());
        }
    else
        {
            PError::SignalFatalError("Unable to find file: [" + inputfilename + "].");
        }
    i++;
    //If there are any more arguments, process them by accomodating them
    //inside a function list.
 
    //Increment the iterator to move to the second command-line
   // i++;
    while(i != files.end())
        {
            std::cerr << "********************\n";
                std::cerr << "Loading file name: ["      << *i <<"]"<< endl;
            otherfilename = Evaluator::gPath.FindFile(*i);
            std::cerr << "Resolved as: [" <<otherfilename <<"]"<< endl;
            if(inputfilename != "")
                {
                    cerr << "Processing PEBL Source File2: " <<  otherfilename << endl;
 
                    //A filename could be a directory (e.g., with media in it.)
                    //If so, don't parse it.
                    if(!Evaluator::gPath.IsDirectory(otherfilename))
                        {
                            //Make a new node.
                            tmp = parse(otherfilename.c_str());
 
                            //Now, make a new node that contains head and tmp.
                            head = new OpNode(PEBL_FUNCTIONS, head, tmp, "INTERNAL PEBL STRUCTURE", -1);
                        }
                }
            else
                {
                    PError::SignalFatalError("Unable to find file: ["+*i+"] at [" + otherfilename + "]");
                        //ignore mis-loaded files after the first; this is causing us
                            //problems on osx
                }
            i++;
       }
 
    //       Done processing files.
    //-----------------------------------------------------
 
    cerr << "---------Loading Program---------" << endl;
    //Now, load it into the environment:
 
    // Create a loader that will load functions into the functionmap
    myLoader = new Loader();
    myLoader->LoadUserFunctions((OpNode*)head);
 
 
    cerr <<"Analyzing code for functions." << endl;
    myLoader->FindFunctions(head);
 
 
    cerr << "Loading Library functions." << endl;
    myLoader->LoadLibraryFunctions();
 
    //This just destroys the function tree, not the
    //parsed node structure that is contained within
    //mFunctionMap.
    //cerr << "Removing residual function tree\n";
    ((OpNode*)head)->DestroyFunctionTree();
    delete head;
    head = NULL;
 
#if 0
    cerr << "\n\n--------------------------------\n";
    cerr << "Functions used in program: " << endl;
    cerr << "--------------------------------\n";
    Evaluator::mFunctionMap.DumpValues();
    cerr << "--------------------------------\n\n";
#endif
 
    //Parse command-line arguments.
 
    PList *  pList =  new PList();
    PList *  arglist = new PList();
 
 
    //Use the current screen resolution as a startingp
 
 
    //Initialize display size here with a non-interesting one.
    //It may get set by a command-line argument later.
    std::string displaySize="0x0";
 
 
    std::string depth = "32";  //used to be 16; does this matter?
    enum PEBLVideoMode displayMode;
    enum PEBLVideoDepth displayDepth;
    bool windowed = true;
    bool vsync = false;    //default vsync to false.  This is reliant on hardware that might not work well on all systems.
    bool  softrender = false;
    bool resizeable = false;
    bool unicode = true;
    bool upload = false;
    bool showHelp = false;
    bool showTestResults = false;
    bool lslEnabled = false;
 
    Variant uploadConfigFile = "";
    Variant lslStreamName = "";  // Optional custom stream name
 
    Variant lang = "";
    Variant subnum = 0;
 
 
    std::string parpath = PEBLUtility::StripFile(inputfilename);
    std::string pname = PEBLUtility::GetBaseFileName(inputfilename);
 
    //default the parameter file to ./params/SCRIPTNAME.par.json, but normally this will get overwritten below
    Variant pfile = Variant(parpath) + Variant("params/") + Variant(pname)+Variant(".par.json");
 
    //Extract the command-line variables to bind
    for(int j = 1; j < argc; j++)
        {
 
            if(strcmp(argv[j].c_str(), "-v")==0 ||
                    strcmp(argv[j].c_str(), "-V")==0)
                {
                    Variant tmp = argv[++j];
                                        //cout <<"Content of passed-in variable " << j << ":" << tmp << endl;
                    arglist->PushBack(tmp);
                }
 
            else if(strcmp(argv[j].c_str(), "-s")==0 ||
                    strcmp(argv[j].c_str(), "-S")==0)
                {
                    subnum  = argv[++j];
                                        //cout << "collecting Subject Number "<< subnum << endl;
                                }
            //set the driver directly from the command-line, if necessary.
            else if(strcmp(argv[j].c_str(),"--driver")==0)
                {
                    if(j+1 < argc)
                        {
                            j++;
                            Evaluator::gGlobalVariableMap.AddVariable("gDriverHint",argv[j].c_str());
                        }
                }
            else if(strcmp(argv[j].c_str(),"--display")==0)
                {
                    displaySize = argv[++j];
                }
 
            else if(strcmp(argv[j].c_str(),"--depth")==0)
                {
                    depth = argv[++j];
 
                }
 
            else if (strcmp(argv[j].c_str(),"--fullscreen")==0)
                {
                    windowed = false;
                }
            else if(strcmp(argv[j].c_str(),"--windowed")==0)
                {
                    windowed = true;
                }
            else if(strcmp(argv[j].c_str(),"--unicode")==0)
                {
                    unicode = true;
                }
            else if(strcmp(argv[j].c_str(),"--language")==0)
                {
                    lang = argv[++j];
                }
 
            else if(strcmp(argv[j].c_str(),"--pfile")==0)
                {
                    std::string pfileArg = argv[++j];
                    // Check if it's a URL - if so, use it directly without prepending "params/"
                    if(pfileArg.compare(0, 7, "http://") == 0 || pfileArg.compare(0, 8, "https://") == 0)
                    {
                        pfile = Variant(pfileArg);
                    }
                    else
                    {
                        pfile = Variant("params/") + Variant(pfileArg);
                    }
                }
 
            else if(strcmp(argv[j].c_str(),"--upload")==0)
                {
 
                    upload = true;
                    uploadConfigFile = Variant(argv[++j]);  //Pass the upload config file in
                    cerr << "setting upload file: [" << uploadConfigFile << "]\n";
                }
 
            else if(strcmp(argv[j].c_str(),"--lsl")==0)
                {
                    lslEnabled = true;
                    // Check if next argument is a stream name (not another flag)
                    if(j+1 < argc && argv[j+1].c_str()[0] != '-')
                    {
                        lslStreamName = Variant(argv[++j]);
                        cerr << "LSL enabled with stream name: [" << lslStreamName << "]\n";
                    }
                    else
                    {
                        cerr << "LSL enabled (auto-generate stream name)\n";
                    }
                }
 
            else if(strcmp(argv[j].c_str(),"--resizeable")==0 ||
                    strcmp(argv[j].c_str(),"--resizable")==0  )
                {
                    if(windowed)
                        resizeable = true;
                }
            else if(strcmp(argv[j].c_str(),"--vsyncon")==0)
                {
                    vsync = true;
                }
 
            else if(strcmp(argv[j].c_str(),"--vsyncoff")==0)
                {
                    vsync = false;
                }
            else if(strcmp(argv[j].c_str(),"--softrender")==0)
                {
                    softrender = true;
                }
            else if(strcmp(argv[j].c_str(),"--help")==0)
                {
                    showHelp = true;
                }
            else if(strcmp(argv[j].c_str(),"--showtestresults")==0)
                {
                    showTestResults = true;
                }
 
 
 
        }
 
 
    //Now, set the display modes variables based on the command-line options.
    displayMode = PEBLUtility::GetVideoMode(displaySize);
    displayDepth = PEBLUtility::GetVideoDepth(depth);
 
 
 
    //This sets the video driver, and other platform-specific stuff.
#if defined(PEBL_UNIX)
 
 
 
    //Now, set the priority to the highest it can go.
 
    cerr << "Priority set here**************************\n";
     int priority = getpriority(PRIO_PROCESS,0);
    cerr << "Process running at a nice value of " << priority << endl;
    cerr << "attempting to set priority to: " << PRIO_MIN << endl;
    //setpriority(PRIO_PROCESS,0,0);
    setpriority(PRIO_PROCESS,0,PRIO_MIN);
    priority = getpriority(PRIO_PROCESS,0);
 
     cerr << "Process running at a nice value of " << priority << endl;
 
    /*
      struct sched_param mysched;
      mysched.sched_priority = sched_get_priority_max(SCHED_FIFO) - 1;
      if( sched_setscheduler( 0, SCHED_RR, &mysched ) == -1 )
      {
      cout << "Unable to enable round-robin scheduling.  Must have root priviledges.\n";
      }
      else
      {
      cout << "Round-robin scheduling enabled.\n";
      }
 
      struct timespec interval;
      if(sched_rr_get_interval(0,&interval)== -1)
      {
      cout << "Unable to get Round-robin scheduling interval.\n";
      }
      else
      {
      cout << "Round Robin Scheduling Interval: [" <<interval.tv_sec * 1000 + interval.tv_nsec / 1000 <<"] ms.\n";
      }
 
    */
 
 
#elif defined(PEBL_WIN32)
     //Do specific win32 stuff here.
 
    //SetPriorityClass(GetCurrentProcess(),REALTIME_PRIORITY_CLASS);
    //REALTIME causes program to hang on keyboard input.
    SetPriorityClass(GetCurrentProcess(),HIGH_PRIORITY_CLASS);
 
    //setenv()
#endif
 
    //cout <<"About to create environment\n";
 
    // We can't use any SDL-related functions before this function is called.
    // But we may want to know current screen resolution before we set displaymode
 
    PEBLObjects::MakeEnvironment(displayMode, displayDepth, windowed,resizeable,unicode);
 
    cerr << "Environment created\n";
 
 
    //Seed the random number generator with time of day.
    srand((unsigned int)time(0));
 
    cerr << "---------Creating Evaluator-----" << endl;
    //Create evaluator, because it contains a function map as a static member variable.
    //Create it with the command-line -v parameters as a list  bound to the argument.
 
#if defined(PEBL_EMSCRIPTEN)
    std::cerr <<"--------o-o-o-o-o-o--\n";
    arglist->PushBack(Variant(0));
    PComplexData * pcd = new PComplexData(counted_ptr<PEBLObjectBase>(arglist));
    pList->PushBack(Variant(pcd));
#else
 
 
    //Now, arglist should contain any values specified with the -v flag.
    if(arglist->Length()==0)
        {
            cerr <<"No command line arguments given\n";
            arglist->PushBack(Variant(0));
            PComplexData * pcd = new PComplexData(counted_ptr<PEBLObjectBase>(arglist));
            pList->PushBack(Variant(pcd));
        }
    else
        {
            PComplexData * pcd = new PComplexData(counted_ptr<PEBLObjectBase>(arglist));
            pList->PushBack(Variant(pcd));
        }
#endif
 
    PComplexData * pcd2 = new PComplexData(counted_ptr<PEBLObjectBase>(pList));
    Variant v = Variant(pcd2);
 
    if(showHelp)
        {
            PrintOptions();
        }
 
 
    
    std::list<PNode> tmpcallstack;
 
    //myEval is now a global, because we have moved to a single-evaluator model:
    myEval = new Evaluator(v,"Start");
 
    //Set the executable name here:
#if defined(PEBL_LINUX) || defined(PEBL_UNIX)
    // Check for AppImage first (special case - need .AppImage path, not extracted binary)
    const char* appimage_path = getenv("APPIMAGE");
    if (appimage_path != NULL) {
        // Running from AppImage - use APPIMAGE env var
        myEval->gGlobalVariableMap.AddVariable("gExecutableName", appimage_path);
        cerr << "Running from AppImage: " << appimage_path << endl;
    } else {
        // Standard Linux installation or local build - use BinReloc
        char* exe_path = br_find_exe(argv[0].c_str());
        if (exe_path != NULL) {
            // br_find_exe succeeded - use absolute path
            myEval->gGlobalVariableMap.AddVariable("gExecutableName", exe_path);
            cerr << "Executable path: " << exe_path << endl;
            free(exe_path);  // br_find_exe allocates memory
        } else {
            // Fallback: use argv[0] as-is (shouldn't happen on Linux)
            myEval->gGlobalVariableMap.AddVariable("gExecutableName", argv[0]);
            PError::SignalWarning("Warning: br_find_exe failed, using argv[0]");
        }
    }
#else
    // Windows, macOS, Emscripten - use argv[0]
    myEval->gGlobalVariableMap.AddVariable("gExecutableName", argv[0]);
#endif
    myEval->gGlobalVariableMap.AddVariable("gScriptName", Variant(inputfilename));
    //Set the default screen resolution based on the current one.
    Variant cursize = SDLUtility::GetCurrentScreenResolution();
 
    // Extract width and height from SDL display mode for both native and Emscripten builds
    PList * plist = cursize.GetComplexData()->GetList();
    Variant width = plist->First();
    Variant height = plist->Nth(2);
 
    delete plist;
    cursize = 0;
 
    myEval->gGlobalVariableMap.AddVariable("gVideoWidth", width);
    myEval->gGlobalVariableMap.AddVariable("gVideoHeight", height);
 
 
    myEval->gGlobalVariableMap.AddVariable("gShowTestResults",Variant(showTestResults));
    //displaysize may have been set at the command line.  If so, we will need to
    //override it.  It is currently a string called displaysize.
 
 
    size_t found = displaySize.find("x");
    if(found == string::npos)
        {
            //Nothing is found.  Use 0s to indicate an invalid displaysize
            width = 0;
            height = 0;
        } else
        {
            cerr <<"Size from command line argument: "  << displaySize.substr(0,found)<< "|"<< displaySize.substr(found+1) <<endl;
            //something was found.
            width =  atoi(displaySize.substr(0,found).c_str());
            height = atoi(displaySize.substr(found+1).c_str());
        }
 
 
    if((pInt)width>0  & (pInt)height>0)
        {
            Evaluator::gGlobalVariableMap.AddVariable("gVideoWidth",width);
            Evaluator::gGlobalVariableMap.AddVariable("gVideoHeight",height);
        }
 
 
    //This lets you change vsync within the script.
    Evaluator::gGlobalVariableMap.AddVariable("gVSync",Variant(vsync));
 
 
    Evaluator::gGlobalVariableMap.AddVariable("gSoftRender",Variant(softrender));
 
    //Add the subject identifier.
    Evaluator::gGlobalVariableMap.AddVariable("gSubNum",subnum);
    //If this is set to 1, we have reset the subject code, and
    //it is presumably good for all future resets.
    Evaluator::gGlobalVariableMap.AddVariable("gResetSubNum",0);
 
    //whether to automatically attempt upload.
    //if 0 it doesn't upload.
    //if non-0, that specifies the upload config file
    Evaluator::gGlobalVariableMap.AddVariable("gUpload",Variant(upload));
    Evaluator::gGlobalVariableMap.AddVariable("gUploadFile",uploadConfigFile); //"" if upload is false
 
    //LSL (Lab Streaming Layer) configuration
    //Set by --lsl command-line flag
    //If enabled but no custom name, PEBL wrapper will auto-generate: "PEBL_" + gScriptName
    Evaluator::gGlobalVariableMap.AddVariable("gLSLEnabled",Variant(lslEnabled));
    Evaluator::gGlobalVariableMap.AddVariable("gLSLStreamName",lslStreamName);  // "" means auto-generate
 
    //Translate lang to the uppercase 2-letter code
    std::string tmps =lang;
    transform(tmps.begin(),tmps.end(),tmps.begin(),toupper);
    Evaluator::gGlobalVariableMap.AddVariable("gLanguage",Variant(tmps));
 
 
    //this global can't be set in-script; changing it will have no impact.
    Evaluator::gGlobalVariableMap.AddVariable("gFullscreen",Variant(1-windowed));
 
    //Add a special 'quote' character.
    Evaluator::gGlobalVariableMap.AddVariable("gQuote",Variant("\""));
 
 
    // Set default base fonts based on language using centralized font selection logic
    // This ensures consistency with GetFontForLanguageOrScript() utility function
    std::string baseFont = PEBLUtility::GetFontForLanguageOrScript(tmps, 0);  // 0 = sans-serif
    std::string monoFont = PEBLUtility::GetFontForLanguageOrScript(tmps, 1);  // 1 = monospace
    std::string serifFont = PEBLUtility::GetFontForLanguageOrScript(tmps, 2); // 2 = serif
 
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLBaseFont", Variant(baseFont));
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLBaseFontMono", Variant(monoFont));
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLBaseFontSerif", Variant(serifFont));
 
    // Always set fallback fonts to DejaVu (optimal for Western/Latin scripts)
    // These are used when translations aren't available, avoiding issues like:
    // - RTL languages (AR/HE) right-justifying English text
    // - CJK languages rendering Latin text in CJK fonts
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLBaseFontFallback",Variant("DejaVuSans.ttf"));
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLBaseFontMonoFallback",Variant("DejaVuSansMono.ttf"));
    Evaluator::gGlobalVariableMap.AddVariable("gPEBLBaseFontSerifFallback",Variant("DejaVuSerif.ttf"));
 
    //load the parameter file into a global variable
    Evaluator::gGlobalVariableMap.AddVariable("gParamFile",Variant(pfile));
 
 
    //Do easy-sleep by default:
    Evaluator::gGlobalVariableMap.AddVariable("gSleepEasy",Variant(1));
    //Now, everything should be F-I-N-E fine.
    head = myLoader->GetMainPEBLFunction();
 
    if(head)
        {
            cerr << "---------Evaluating Program-----" << endl;
            //Execute everything
 
 
#ifdef PEBL_ITERATIVE_EVAL
            // Iterative evaluator - start at head node and run until stack is empty
            cerr << "Starting evaluation with iterative evaluator\n";
 
            // Wrap Start() call in proper PEBL_FUNCTION node to ensure call stack is managed correctly
            // This matches how all other lambda function calls work (PEBL_FUNCTION -> PEBL_FUNCTION_TAIL1 -> PEBL_FUNCTION_TAIL2 -> PEBL_LAMBDAFUNCTION)
            // Without this wrapper, the call stack push in PEBL_FUNCTION_TAIL2 (line 1103) is skipped,
            // causing gCallStack to be empty when PEBL_FUNCTION_TAIL_LIBFUNCTION tries to pop (line 1134)
 
            // Create argument for Start() - pass the command-line arguments list (same as recursive evaluator)
            // If no args, this will be a list containing 0
            DataNode* argNode = new DataNode(v, "", 0);  // v is the Variant created above (pcd2 containing pList)
            OpNode* argList = new OpNode(PEBL_LISTITEM, argNode, NULL, "", 0);
            OpNode* args = new OpNode(PEBL_ARGLIST, argList, NULL, "", 0);
 
            DataNode* funcNameNode = new DataNode(Variant("START", P_DATA_FUNCTION), "", 0);
            OpNode* startCall = new OpNode(PEBL_FUNCTION, funcNameNode, args, "", 0);
 
            myEval->Evaluate1(startCall);
 
            cerr << "Running evaluator loop\n";
            while(myEval->GetNodeStackDepth() > 0)
            {
                myEval->Evaluate1();
            }
#else
            // Recursive evaluator - traditional single-call evaluation
            cerr << "Starting evaluation with recursive evaluator\n";
            ::myEval->Evaluate(head);
#endif
 
            // Capture return value from Start() before cleanup
            // The return value should be on the evaluator's stack
            int scriptReturnCode = 0;
            if (myEval->GetStackDepth() > 0) {
                Variant returnVal = myEval->Pop();
                // If the return value is a number, use it as the exit code
                if (returnVal.IsNumber()) {
                    scriptReturnCode = (int)returnVal;
                    cerr << "Script returned: " << scriptReturnCode << endl;
                }
            }
 
#ifdef PEBL_EMSCRIPTEN
            // Emscripten: Early return without cleanup (browser manages lifecycle)
            cerr << "========================================" << endl;
            cerr << "PEBL program completed successfully." << endl;
            cerr << "========================================" << endl;
 
            // Signal completion to JavaScript launcher (for test chains)
            SignalTestComplete("completed");
 
            return 0;
#else
            // Native platforms: Perform full cleanup
            // IMPORTANT: Delete myEval FIRST to clean up local variables (child widgets)
            // before destroying global variables (parent window gWin).
            // This prevents child widgets from trying to access already-deleted parents.
            delete ::myEval;
            ::myEval = NULL;
 
            Evaluator::gGlobalVariableMap.Destroy();
 
            if(myLoader) delete myLoader;
            if(myEnv) delete myEnv;
            Evaluator::mFunctionMap.Destroy();
            //Evaluator::gGlobalVariableMap.DumpValues();
 
#ifdef PEBL_MOVIES
            //Close the wave player library.
            WV_waaveClose();
#endif
 
            //Be sure SDL quits.  We need to be sure everything is tidied up,
            //or SDL_Quit will segfault.
 
            SDL_Quit();
 
            // Use _exit() to terminate immediately with the script's return code
            // This avoids running any remaining destructors which can crash due to cleanup order issues
            cerr << "Exiting with code: " << scriptReturnCode << endl;
            _exit(scriptReturnCode);
#endif
 
 
          //Let's clean up any remaining counted pointers here.
 
            v = 0;
 
            return scriptReturnCode;
        }
    else
        {
            cerr << "Error: Can't evaluate program" << endl;
 
            if(myLoader) delete myLoader;
            return 1;
 
        }
 
    return 0;
 
}

References VariableMap::AddVariable(), br_find_exe(), br_find_prefix(), br_init(), BR_INIT_ERROR_DISABLED, FunctionMap::Destroy(), VariableMap::Destroy(), FunctionMap::DumpValues(), Evaluator::Evaluate(), Evaluator::Evaluate1(), PEBLPath::FindFile(), Loader::FindFunctions(), PList::First(), PEBLUtility::GetBaseFileName(), Variant::GetComplexData(), SDLUtility::GetCurrentScreenResolution(), GetFiles(), PEBLUtility::GetFontForLanguageOrScript(), PComplexData::GetList(), Loader::GetMainPEBLFunction(), Evaluator::GetNodeStackDepth(), Evaluator::GetStackDepth(), PEBLUtility::GetVideoDepth(), PEBLUtility::GetVideoMode(), Evaluator::gGlobalVariableMap, Evaluator::gPath, head, PEBLPath::Initialize(), Variant::IsNumber(), PList::Length(), Loader::LoadLibraryFunctions(), Loader::LoadUserFunctions(), PEBLObjects::MakeEnvironment(), Evaluator::mFunctionMap, myEnv, myEval, myLoader, PList::Nth(), NULL, P_DATA_FUNCTION, parse(), PEBL_VERSION, pInt, Evaluator::Pop(), PrintOptions(), PList::PushBack(), PError::SignalFatalError(), SignalTestComplete(), PError::SignalWarning(), PEBLUtility::StripFile(), and PEBLUtility::SystemCall().

Referenced by main().

PrintOptions()

void PrintOptions

(

)

Definition at line 1258 of file PEBL.cpp.

{
    cout << "-------------------------------------------------------------------------------\n";
    cout << "PEBL: The Psychology Experiment Building Language\n";
    cout << "Version " << PEBL_VERSION << "\n";
    cout << "(c) 2003-2026 Shane T. Mueller, Ph.D.\n";
    cout << "smueller@obereed.net   http://pebl.sf.net\n";
    cout << "-------------------------------------------------------------------------------\n";
 
    cout << "Usage:  Invoke pebl with the experiment script files (.pbl) and command-line\n";
    cout << "arguments.\n\n";
    cout << "example: pebl experiment.pbl -v sub1 --fullscreen --display 800x600 --driver opengl\n\n";
    cout << "COMMAND-LINE OPTIONS:\n";
    cout << "-v VALUE1 -v VALUE2\n";
    cout << "  Invokes script and passes VALUE1 and VALUE2 (and any text immediately\n" ;
    cout << "  following -v) to a list in the argument of the Start() function.\n\n";
    cout << "-s IDENTIFIER\n";
    cout << "  Initiates the global variable gSubNum to IDENTIFIER.  If not set here,\n";
    cout << " gSubNum is initiated to 0.\n\n";
    cout << "--driver <drivername>\n";
    cout << "  Sets the preferred video driver via a hint, alternatives include direct3d opengl\n";
    cout << "  opengles2 opengles and software\n";
    cout << "--display  <widthxheight>\n";
    cout << "  Controls the screen width and height (in pixels). Screen resolution defaults\n";
    cout << "  to the current screen resolution. In fullscreen mode, PEBL will check whether \n";
    cout << "  the resolution is available for the video screen, and use the default mode if not\n";
    cout << "  Note: Custom screen dimensions can be controlled in-script.\n\n";
    cout << "--depth\n";
    cout << "  Controls the pixel depth.  Depends on your video card.  Currently,\n";
    cout << "  depths of 2,8,15,16,24, and 32 are allowed on the command-line.\n";
    cout << "--language <2 char lang code>\n";
    cout << "  Allows you to specify at the command line a language to enable \n selecting different text labels.\n";
    cout << "--windowed\n";
    cout << "--fullscreen\n";
    cout << "  Controls whether the script will run in a window or fullscreen.\n\n";
    cout << "--resizeable\n";
    cout << "--resizable\n";
    cout << "  Controls whether the window will be resizeable (only in windowed mode)\n\n";
    cout << "--unicode\n";
    cout << "  Turns on unicode handling, with slight overhead\n";
    cout << "--pfile <filename>\n";
    cout << "  Specifies which parameter file to use, gets bound to variable gParamFile.\n";
    cout << " --upload <fname>\n";
    cout << "   specifies an upload.json file to use to sync with data server\n";
    cout << " --vsyncon\n";
    cout << "  Turns Vsync ON (for special tasks where you need precise control of video refresh, but may be tfussy on some hardware.\n";
 
    cout << " --softrender\n";
    cout << " Uses software renderer instead of accelerated hardware fallback.  Disables vsync setting\n";
 
    cout << " --lsl [streamname]\n";
    cout << "  Enables Lab Streaming Layer (LSL) output for EEG/eye-tracker synchronization.\n";
    cout << "  Optional streamname overrides the auto-generated stream name (PEBL_<scriptname>).\n";
    cout << "  Use InitializeLSL(), LSLMarker(), and FinalizeLSL() in your script.\n";
 
    cout << " --help\n";
    cout << "  Display this output screen\n";
 
    cout << " --showtestresults\n";
    cout << "  Sets global variable gShowTestResults to 1 vs 0. Allows a test to automatically show a screen with results at the end.\n";
 
 
}

References PEBL_VERSION.

Referenced by main(), and PEBLInterpret().

SignalTestComplete()

void SignalTestComplete ( const char *  status = "completed" )

inline

Definition at line 61 of file PEBL.cpp.

                                                                 {
    // Native PEBL doesn't need completion signaling
}

Referenced by CaptureSignal(), and PEBLInterpret().

Variable Documentation

head

PNode* head

Definition at line 220 of file PEBL.cpp.

Referenced by main(), PEBLInterpret(), and PEBLInterpret().

myEnv

PlatformEnvironment* myEnv = NULL

Definition at line 189 of file PEBL.cpp.

Referenced by CaptureSignal(), main(), PEBLInterpret(), and PlatformEventQueue::Prime().

myEval

Evaluator* myEval = NULL

Definition at line 188 of file PEBL.cpp.

Referenced by PEBLInterpret().

myLoader

Loader* myLoader

Definition at line 219 of file PEBL.cpp.

Referenced by CaptureSignal(), main(), PEBLInterpret(), and PEBLInterpret().