int main (int argc, char ** argv)
{
char* moduleName = 0;
validateArgs(argc, argv, moduleName);
assert(moduleName);
doFile(moduleName);
return 0;
}
int main(int argc, char **argv)
{
const int on = 1;
int sock, i;
struct sockaddr_in addr[MAX_CONNECT], server;
P_socket p_sock[MAX_CONNECT];
validateArgs(argc, argv);
if (interface)
{
server.sin_addr.s_addr = inet_addr(szAddress);
if (server.sin_addr.s_addr == INADDR_NONE)
usage();
}
else
server.sin_addr.s_addr = htonl(INADDR_ANY);
server.sin_family = AF_INET;
server.sin_port = htons(port);
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
perror("Socket is not created");
exit(1);
}
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
for (i = 0; i < MAX_CONNECT; i++)
{
bzero(&addr[i], sizeof(addr[i]));
p_sock[i].socket_fd = sock;
p_sock[i].ptr_addr = &addr[i];
}
if (bind(sock, (struct sockaddr *)&server, sizeof(server)) < 0)
{
perror("Socket is not bound");
exit(1);
}
for(i = 0;i < MAX_CONNECT;i++)
{
if (pthread_create(&t1[i], NULL, (void *)&pthread_handler, (void *)&p_sock[i]) != 0)
{
perror("Thread creating");
exit(1);
}
pthread_join(t1[i], NULL);
}
close(sock);
return 0;
}
int main(int argc, char **argv)
{
int ret = validateArgs(argc, argv);
if(ret == 0){
printf("Argument's not supported\n");
return 1;
}
else if(ret == 2){
return 0;
}
else if(ret == 1){
transportLayer();
}
return 0;
}
int main(int argc, char * argv[]){
ARGS args;
pid_t *pid;
int i = 0;
char buf[4096];
parseArgs(argc, argv, &args);
validateArgs(&args);
init(args.n_proc);
pid = (pid_t*)malloc(sizeof(pid_t) * args.n_proc);
createProc(args.n_proc, pid);
//KILLOVANIE deti
sigset_t set;
int sig_num;
sigemptyset(&set);
sigaddset(&set, SIGINT);
CHECK(sigprocmask(/*SIG_BLOCK*/ SIG_SETMASK, &set, NULL) == 0);
CHECK(sigwait(&set, &sig_num) == 0);
for(i = 0; i < args.n_proc; i++){
CHECK(kill(pid[i], SIGUSR1) == 0 );
}
for(i = 0; i < args.n_proc; i++){
CHECK(wait(NULL) != -1);
}
read_((char*)&buf);
fprintf(stderr, "%s\n", buf);
teardown();
free(pid);
printf("detske procesy ukoncene\n");
return EXIT_SUCCESS;
}
int main( int argc, char *argv[] )
{
int err;
/* Parse command line */
if ( !validateArgs( argc, argv ) ) {
err = GDIFF_ERR_ARGS;
}
else {
err = openFiles();
}
#ifdef XP_PC
/* unbind windows executables if requested */
if ( bUnbind )
bUnbind = (err == GDIFF_OK) ? unbind( oldfile ) : FALSE;
#endif /* XP_PC */
/* Calculate block checksums in old file */
if ( err == GDIFF_OK ) {
htbl = chunkOldFile( oldfile, blocksize );
if ( htbl == NULL )
err = GDIFF_ERR_MEM;
}
/* Do the diff */
if ( err == GDIFF_OK ) {
writeHeader( oldfile, newfile, outfile );
diff( oldfile, newfile, outfile );
}
/* Cleanup */
cleanup();
/* Report status */
if ( err != GDIFF_OK ) {
switch (err) {
case GDIFF_ERR_ARGS:
fprintf( stderr, "Invalid arguments\n" );
usage();
break;
case GDIFF_ERR_ACCESS:
fprintf( stderr, "Error opening file\n" );
break;
case GDIFF_ERR_MEM:
fprintf( stderr, "Insufficient memory\n" );
break;
default:
fprintf( stderr, "Unknown error %d\n", err );
break;
}
}
else if ( bDebug ) {
fprintf( stderr, "\nHashed %ld blocks into %ld slots (out of %ld)\n",
blockshashed, slotsused, HTBLSIZE );
fprintf( stderr, "Blocks found: %ld\n", blocksfound );
fprintf( stderr, "Hashtable hits: %ld\n", hashhits );
fprintf( stderr, "memcmps failed: %ld\n", cmpfailed );
fprintf( stderr, "partial matches: %ld\n", partialmatch );
fprintf( stderr, "\n%ld bytes in %ld ADDs (%ld in largest)\n", addtotal, addnum, addmax );
fprintf( stderr, "%ld bytes in %ld COPYs (%ld in largest)\n", copytotal, copynum, copymax );
}
return (err);
}
int main(int argc, const char *argv[])
{
// Init Default
RegistrationConfig reg_cfg;
reg_cfg.configFile3D_.clear();
reg_cfg.initTrans_.clear();
reg_cfg.initTrans_.append("0,0,0");
ConvertOctomapConfig co_cfg;
co_cfg.octomap_resolution = 0.1; // was always 0.1 for mav and atlas
co_cfg.blur_sigma = 0.1; // default was .5
co_cfg.blur_map = false;
AppConfig app_cfg;
const int ret = validateArgs(argc, argv, reg_cfg, co_cfg);
if (ret == -1)
return ret;
if (reg_cfg.cloud_name_A.empty())
{
reg_cfg.cloud_name_A.append(reg_cfg.homedir);
reg_cfg.cloud_name_A.append("/logs/multisenselog__2015-11-16/pointclouds/multisense_00.vtk");
}
if (reg_cfg.cloud_name_B.empty())
{
reg_cfg.cloud_name_B.append(reg_cfg.homedir);
reg_cfg.cloud_name_B.append("/logs/multisenselog__2015-11-16/pointclouds/multisense_01.vtk");
}
//std::cout << "Blur sigma: " << co_cfg.blur_sigma << "\n";
//Set up LCM channel for visualization
boost::shared_ptr<lcm::LCM> lcm(new lcm::LCM);
if(!lcm->good()){
std::cerr <<"ERROR: lcm is not good()" <<std::endl;
}
App* app = new App(lcm, reg_cfg, co_cfg, app_cfg);
// Load point clouds from file
DP ref = DP::load(reg_cfg.cloud_name_A);
DP data = DP::load(reg_cfg.cloud_name_B);
//=================================
// TRANSFORM 3D CLOUD
//=================================
app->registr_->getICPTransform(data, ref);
PM::TransformationParameters T = app->registr_->getTransform();
cout << "3D Transformation:" << endl << T << endl;
//=================================
// CONVERT CLOUD TO OCTREE
//=================================
app->do_convert_cloud_ = true;
if ( app->do_convert_cloud_ ) {
ColorOcTree* treeA = doConversion(app, 0);
//cout << "Pruned tree A size: " << treeA->size() <<" nodes." << endl;
cout << "Changes A:" << endl;
app->convert_->printChangesAndActual(*treeA);
// Uncomment for visualization of matching results one by one:
cout << "Press ENTER to continue..." << endl;
cin.get();
ColorOcTree* treeB = doConversion(app, 1);
//cout << "Pruned tree B size: " << treeB->size() <<" nodes." << endl;
cout << "Changes B:" << endl;
app->convert_->printChangesByColor(*treeB);
}
return 0;
}
// This function evaluates the parse tree given by expr within the given environment.
Value* eval(Value *expr, Environment *env){
Value* operator;
Value* args;
//printf("Here is expression: ");
//printValue(expr);
//printf("\n");
if (!expr){
return NULL;
}
switch (expr->type)
{
case symbolType:
//printf("unknown identifier");
args = envLookup(expr->symbolValue, env);
if (args){
//printf("going here\n");
//printValue(expr);
//printf("\nending here\n");
return args;
}
else{
printf("syntax error: unknown identifier");
return NULL;
}
break;
case cellType:
if (expr->cons->car->type == nullType) {
return expr->cons->car;
}
//printf("Here is expression: ");
//printValue(getFirst(expr));
//printf("\n");
if (getFirst(expr) != NULL && getFirst(expr)->type == openType) {
operator = car(expr);
if (!operator){
printf("syntax error, missing components here");
return NULL;
}
if (operator->type == cellType){
operator = eval(operator, env);
}
if (operator->type == symbolType){
args = getTail(getTail(expr));
//printf("checking args?: ");
//printValue(args);
//printf("\n"); //if (args == NULL){
//return eval(operator,env); // }else
if (strcmp(operator->symbolValue,"define")==0){
return evalDefine(args, env);
}else if (strcmp(operator->symbolValue,"lambda")==0){
/*eval lambda goes here*/
return evalLambda(args, env);
}else if (strcmp(operator->symbolValue,"if")== 0){
return evalIf(args, env);
/*eval if goes here*/
}else if (strcmp(operator->symbolValue,"quote")==0){
/*eval quote goes here*/
return evalQuote(args);
}else if (strcmp(operator->symbolValue,"let")==0){
/*eval let goes here*/
return evalLet(args, env);
}else{
//printf("validation result is shown: %d\n",validateArgs(args, env));
if (validateArgs(args, env)==-1){
printf("Syntax error! Invalid arguments for the procedure: ");
printValue(operator);
printf("\n");
return NULL;
}
Value *evaledOperator = eval(operator, env);
Value *evaledArgs = evalEach(args, env);
if (!evaledOperator){
printf("Unknown procedure: ");
printValue(operator);
printf("\n");
}
//printValue(evaledArgs);
//printf("\n");
return apply(evaledOperator, evaledArgs);
}
}else if (typeCheck(operator)==1){
printf("A literal ");
printValue(operator);
printf(" cannot be a procedure.\n");
return NULL;
}
} else if (typeCheck(getFirst(expr))==1){
//printValue(expr);
//printf("\n");
return evalEach(expr,env);
}else if (getFirst(expr) && getFirst(expr)->type ==cellType && getFirst(getTail(expr)) && getFirst(getTail(expr))->type==closeType){
return eval(getFirst(expr),env);
}else if (getFirst(expr) && getFirst(expr)->type == symbolType){
operator = getFirst(expr);
Value *returnValue = envLookup(operator->symbolValue, env);
if (returnValue){
return returnValue;
}else{
if (strcmp(operator->symbolValue,"define")==0){
printf("define: bad syntax in ");
printValue(expr);
printf("\n");
}else if (strcmp(operator->symbolValue,"lambda")==0){
printf("lambda: bad syntax in ");
printValue(expr);
printf("\n");
}else if (strcmp(operator->symbolValue,"if")==0){
printf("if: bad syntax in ");
printValue(expr);
printf("\n");
}else if (strcmp(operator->symbolValue,"quote")==0){
printf("quote: bad syntax in ");
printValue(expr);
printf("\n");
}else if (strcmp(operator->symbolValue,"let")==0){
printf("let: bad syntax in ");
printValue(expr);
printf("\n");
}else{
printf("Unknown identifier %s.\n",operator->symbolValue);
}
return NULL;
}
}
case closeType:
//printValue(expr);
//printf("\n");
return NULL;
break;
default:
//printValue(expr);
//printf("\n");
if (getTail(expr)){
assert(getFirst(getTail(expr))!=NULL);
assert(getFirst(getTail(expr))->type==closeType);
Value *toRemove = getTail(expr);
free(toRemove->cons->car);
free(toRemove->cons);
free(toRemove);
expr->cons->cdr = NULL;
//assert(1==2);
}
return expr;
}
}
int main(int argc, char* argv[])
{
int current_depth;
int input_max_depth;
char* targetDir;
char seedURL[MAX_URL_LENGTH];
char* page;
char* nextURLVisit;
//char** URLList;
//check for proper command line arguments
validateArgs(argc, argv);
dict = initDictionary();
current_depth = 0;
strcpy(seedURL, argv[1]);
targetDir = argv[2];
input_max_depth = atoi(argv[argc - 1]);
addElement(dict, seedURL, current_depth +1);
updateListLinkToBeVisited(dict, url_list, current_depth);
//installDNODE(seedURL, hash1(seedURL) % MAX_HASH_SLOT, 1);
page = getPage(seedURL, current_depth, targetDir);
if(page == NULL)
{
printf("Whoops, Cannot Crawl seed URL: %s ABORT ABORT! \n", seedURL);
exit(1);
}
//URLsList......
extractURLs(page, seedURL);
free(page);
updateListLinkToBeVisited(dict, url_list, current_depth + 1);
//all the URLs parsed that dont exist, put in dict with DNODE and have thsi point to URLNODE
visited(dict, seedURL);
//pointer to interger without a cast?
while((nextURLVisit = getAddressFromLinksToBeVisited(dict, ¤t_depth)) !=NULL)
{
if (current_depth > input_max_depth)
{
printf("[crawler]: URL %s exceeds specified depth of %d \n", nextURLVisit, input_max_depth);
visited(dict, nextURLVisit);
continue;
}
page = getPage(nextURLVisit, current_depth, targetDir);
if (page == NULL)
{
printf("[crawler:] cannot Crawl URL: %s \n Marking as visited and trying again\n", nextURLVisit);
visited(dict, nextURLVisit);
continue;
}
//need to malloc url list if going to update it, no?
extractURLs(page, nextURLVisit);
free(page);
//load into hash
//if in url and not in dict add dnode
updateListLinkToBeVisited(dict, url_list, current_depth + 1); // this is where insert and install is called
visited(dict, nextURLVisit);
}
//free(url_list);
//freeList(URLList);
printf("[crawler]: we out, time for cleans \n");
cleanDict(dict);
free(dict);
//dict = NULL;
//cleanList(dict);
// cleanDNodes(dict);
printCrawlStats();
return 0;
}
