Exemple #1
0
void parse_options() {
    // Parse command line options, and update the environment to match the
    // specified options.
    argp->usage(
        "Usage: jgdoc [OPTIONS] FILE...\n"
        "Generates documentation from comments found in Jogo source files.\n\n"
        "   -o, --output DIR     Write output to DIR.\n"
        "   -i, --include DIR    Add the directory DIR to the search path.\n"
        "   -h, --help           Print this help message.\n"
        "   -f, --format FORMAT  Set output format to FORMAT.\n"
        "   -v, --verbose        Print extra information.\n"
        "   --version            Print the compiler version number.\n");

    for (ArgToken tok = argp->next(); tok; tok = argp->next()) {
        // Convert abbreviated flags into the longer descriptive form (e.g.,
        // convert -p to --path)
        if (ArgToken::SHORT == tok.type()) {
            parse_short_option(tok.value());
        } else if (ArgToken::LONG == tok.type()) {
            parse_option(tok.value());
        } else {
            env->input(tok.value());
        }
    }

    std::string gen = env->generator();
    if (gen != "Markdown") {
        argp->error("Invalid output format (options: Markdown");
    }
}
Exemple #2
0
void load_options() {
    // Loads options from the options file.  FIXME: This settings file loader
    // is pretty haggard.  It should be replaced with JSON.
    std::ifstream opts(".jgmake");
    int c = opts.get();
    while (c != '\n' && !opts.fail()) {
        std::string include;
        while (c != ',' && c != '\n' && !opts.fail()) {
            include += c;
            c = opts.get();
        }
        env->include(include);
        c = opts.get(); 
    }
    c = opts.get();
    while (c != '\n' && !opts.fail()) {
        std::string lib;
        while (c != ',' && c != '\n' && !opts.fail()) {
            lib += c;
            c = opts.get();
        }
        env->lib(lib);
        c = opts.get(); 
    }
}
SchemeObject* SchemeObjectCreator::make_environment() {
    Environment::Ptr env = std::make_shared<Environment>();
    setup_environment(env.get());

    SchemeObject* obj = new SchemeEnvironment(env);
    SchemeGarbageCollector::the_gc().add(obj);

    return obj;
}
Exemple #4
0
void save_options() {
    // Saves options to the options file.
    std::ofstream opts(".jgmake");
    for (int i = 0; i < env->includes(); ++i) {
        opts << env->include(i) << ",";
    }
    opts << std::endl;
    for (int i = 0; i < env->libs(); ++i) {
        opts << env->lib(i) << ",";
    }
    opts << std::endl;
}
Exemple #5
0
void parse_option(std::string const& flag) {
    if ("output" == flag) {
        env->output(argp->required_arg());
    } else if ("include" == flag) {
        env->include(argp->required_arg());
    } else if ("format" == flag) {
        env->generator(argp->required_arg());
    } else if ("verbose" == flag) {
        env->verbose(true);
    } else {
        argp->bad_option(flag);
    }
}
Exemple #6
0
int main(int argc, char** argv) {
    // This program recursively finds and builds all files in the source
    // directory, and then generates the output in the lib/bin directory.
    env->workspace_load();
    env->output(".");
    env->make(true);
    env->monolithic_build(false);

    argp = new ArgParser(env, argc, argv);
    load_options(); 
    parse_options();
    save_options();

    Builder::Ptr builder(new Builder(env));
    return builder->errors();
}
Exemple #7
0
void parse_options() {
    // Parse command line options, and update the environment to match the 
    // specified options.
    argp->usage(
        "Usage: jogo [OPTIONS] FILE...\n\n"
        "Compiles Jogo source files into a library or executable.\n\n"
        "   -a, --assembly       Compile, but do not assemble or link.\n"
        "   -c, --compile        Compile and assemble, but do not link.\n"
        "   -e, --execute        Execute program as a script.\n"
        "   -d, --debug          Emit debug information.\n"
        "   -l, --library LIB    Compile and link with native library LIB.\n"
        "   -i, --include DIR    Add the directory DIR to the search path.\n"
        "   -o, --output FILE    Write compiler output to FILE.\n"
        "   -m, --make           Compile input files and out-of-date dependencies.\n"
        "   -h, --help           Print this help message.\n"
        "   -v, --verbose        Print extra information during compilation.\n"
        "   -g, --generator GEN  Use code generator GEN.\n"
        "   --build-dir DIR      Output directory for object files.\n"
        "   --dump-ir            Output the intermediate representation.\n"
        "   --dump-ast           Output the abstract syntax tree.\n"
        "   --dump-liveness      Output liveness info when printing the IR.\n"
        "   --dump-regalloc      Dump register allocations.\n"
        "   --dump-reggraph      Dump register interference graphs.\n"
        "   --version            Print the compiler version number.\n");

    for (ArgToken tok = argp->next(); tok; tok = argp->next()) {
        // Convert abbreviated flags into the longer descriptive form (e.g.,
        // convert -p to --path)
        if (ArgToken::SHORT == tok.type()) {
            parse_short_option(tok.value());
        } else if (ArgToken::LONG == tok.type()) {
            parse_option(tok.value());
        } else {
            env->input(tok.value());
        }
    } 

    std::string gen = env->generator();
    if (gen != "Intel64" && gen != "C" && gen != "Nasm64") {
        argp->error("Invalid code generator (options: Intel64, NAsm64, C)"); 
    }
    if (!env->inputs()) {
        argp->error("No input files.");
    }
}
Exemple #8
0
void parse_option(std::string const& flag) {
    if ("library" == flag) {
        env->lib(argp->required_arg());
    } else if ("include" == flag) {
        env->include(argp->required_arg()); 
    } else if ("generator" == flag) {
        env->generator(argp->required_arg());
    } else if ("debug" == flag) {
        env->debug(true);
    } else if ("optimize" == flag) {
        env->optimize(true);
    } else if ("verbose" == flag) {
        env->verbose(true);
    } else if ("clean" == flag) {
        clean(env->build_dir());
        clean("bin");
        clean("lib");
        exit(0);
    } else if ("reset" == flag) {
        File::unlink(".jgmake");
        exit(0);
    } else {
        argp->bad_option(flag);
    }
}
Exemple #9
0
int main(int argc, char** argv) {
    // Create a new empty environment to store the AST and symbols tables, and
    // set the options for compilation.
    argp = new ArgParser(env, argc, argv);
    env->output("doc");
    env->generator("Markdown");

    parse_options();
    File::mkdir(env->output());
    env->workspace_load();

    // Run the compiler.  Output to a temporary file if the compiler will
    // continue on to another stage; otherwise, output the file directly.
    Parser::Ptr parser(new Parser(env));
    SemanticAnalyzer::Ptr semant(new SemanticAnalyzer(env));
    MarkdownGenerator::Ptr md(new MarkdownGenerator(env));

    return 0;
}
Exemple #10
0
void parse_options() {
    // Parse command line options, and update the environment to match the 
    // specified options.
    argp->usage(
        "Usage: jgmake [OPTIONS] PACKAGE...\n\n"
        "Builds a Jogo project from the current working directory.  Source files should\n"
        "be under ./src; output files go to ./build, ./lib, ./bin, and ./doc.  Options\n"
        "given to jgmake are recorded.  After an option is set, it will remain set the\n"
        "next time jgmake is run.\n\n"
        "   -l, --library LIB    Compile and link with native library LIB.\n"
        "   -i, --include DIR    Add the directory DIR to the search path.\n"
        "   -d, --debug          Emit debug information.\n"
        "   -o, --optimize       Enable compiler optimizations.\n"
        "   -g, --generator GEN  Use code generator GEN.\n"
        "   -h, --help           Print this help message.\n"
        "   -v, --verbose        Print extra information during compilation.\n"
        "   -r, --reset          Erase all build options.\n"
        "   -c, --clean          Remove all output directories.\n"
        "   --version            Print the program version number.\n");

    for (ArgToken tok = argp->next(); tok; tok = argp->next()) {
        // Convert abbreviated flags into the longer descriptive form (e.g.,
        // convert -p to --path)
        if (ArgToken::SHORT == tok.type()) {
            parse_short_option(tok.value());
        } else if (ArgToken::LONG == tok.type()) {
            parse_option(tok.value());
        } else {
            env->input(tok.value());
        }
    } 

    std::string gen = env->generator();
    if (gen != "Intel64" && gen != "C" && gen != "Nasm64") {
        argp->error("Invalid code generator (options: Intel64, Nasm64, C)"); 
    }
}
Exemple #11
0
void clean(std::string const& dir) {
    for(File::Iterator i(dir);i;++i) {
        std::string const path = dir + FILE_SEPARATOR + (*i);
        if((*i) == "." || (*i) == "..") {
            // Do nothing
        } else if(File::is_dir(path)) {
            clean(path);
        } else {
            if (env->verbose()) {
                std::cout << "Removing " << path << std::endl;
            }
            File::unlink(path); 
        }
    }
}
Exemple #12
0
void parse_option(std::string const& flag) {
    // Parses an option and all the corresponding arguments to that option.
    if ("verbose" == flag) {
        env->verbose(true);
    } else if ("optimize" == flag) {
        env->optimize(true);
    } else if ("assembly" == flag) {
        env->assemble(false);
        env->link(false);
    } else if ("compile" == flag) {
        env->link(false);
    } else if ("make" == flag) {
        env->make(true);
    } else if ("debug" == flag) {
        env->debug(true);
    } else if ("dump-ir" == flag) {
        env->dump_ir(true);
    } else if ("dump-ast" == flag) {
        env->dump_ast(true);
    } else if ("dump-lex" == flag) {
        env->dump_lex(true);
    } else if ("dump-liveness" == flag) {
        env->dump_liveness(true);
    } else if ("dump-regalloc" == flag) {
        env->dump_regalloc(true);
    } else if ("dump-reggraph" == flag) {
        env->dump_reggraph(true);
    } else if ("execute" == flag) {
        env->execute(true);
    } else if ("no-default-libs" == flag) {
        env->no_default_libs(true);
        // Debugger flag that prevents default modules from getting
        // loaded automatically by the parser.
    } else if ("include" == flag) {
        env->include(argp->required_arg()); 
    } else if ("output" == flag) {
        env->output(argp->required_arg());
    } else if ("build-dir" == flag) {
        env->build_dir(argp->required_arg());
    } else if ("library" == flag) {
        env->lib(argp->required_arg());
    } else if ("generator" == flag) {
        env->generator(argp->required_arg());
    } else {
        argp->bad_option(flag);
    }
}
Exemple #13
0
/**
 * @brief main function
 * 
 * Uses boost program options to read file
 * Outputs to _sol.txt file
 */
int main(int argc, char** argv){

  //some program options boilerplate
  namespace po = boost::program_options; 
  po::options_description desc("Vanilla Navigation Planner Usage"); 
  desc.add_options() 
    ("vis,v","mode to rewrite the json files into readable format for matlab")
    ("env,e",po::value<string>()->required(),"input environment json file"); 
  po::variables_map vm;
  po::store(po::command_line_parser(argc, argv).options(desc).run(), vm);
  po::notify(vm);

  //open the json
  boost::filesystem::path json_file( vm["env"].as<string>() );
  ifstream input_json_file;
  if(boost::filesystem::exists(json_file)){
     input_json_file.open( json_file.string().c_str() );
  }
  else{
      printf("File \"%s\" does not exist to be read!\n", json_file.string().c_str());
  }

  if( input_json_file ){
    //use the json file to construct the environment
    Environment::Ptr env = boost::make_shared<Environment>();
    env->readDescription( input_json_file );

    input_json_file.close();
    if(vm.count("vis")){
        boost::filesystem::path parent_dir = json_file.parent_path();
        boost::filesystem::path solution_filename(json_file.stem().string()+"_vis.txt");
        boost::filesystem::path solution_filepath = parent_dir / solution_filename;
        
        ofstream ofs;
        ofs.open( solution_filepath.string().c_str() );
        ofs << *env; 
        ofs.close();
    }
    else{
        //plan on the environment
        Graph::Ptr graph = boost::make_shared<Graph>(env);
        Planner::Ptr plnr = boost::make_shared<Planner>(env, graph);

        vector<GraphState::Ptr> path;

        //call planner
        bool plannerResult = plnr->plan(path);

        if(plannerResult){
            //output plan to file
            boost::filesystem::path parent_dir = json_file.parent_path();
            boost::filesystem::path solution_filename(json_file.stem().string()+"_sol.txt");
            boost::filesystem::path solution_filepath = parent_dir / solution_filename;

            printf("Writing out solution to: %s\n", solution_filepath.string().c_str());
            ofstream ofs;
            ofs.open( solution_filepath.string().c_str() );

            for(size_t i=0; i<path.size(); i++){
                ofs << *(path[i]) << endl;
            }
            ofs.close();
        }
        else{
            //
            cout << "No plan found!" << endl;
        }
    }
  }

  return 0;
}
Fork::Fork(const Environment::Ptr parentEnv_, const RaveInstancePtr rave_, BulletInstance::Ptr bullet, OSGInstance::Ptr osg) :
    parentEnv(parentEnv_.get()), env(new Environment(bullet, osg)),
    rave(rave_) {
  copyObjects();
}