The Big Programming Thread - Page 805

TOKEN* set_up_global(NODE* tree, FRAME* theFrame) {
	TOKEN* main;
	if (tree->left-> type == '~') {
		printf("got BRANCH\n");
		set_up_global(tree->right, theFrame);
		set_up_global(tree->left, theFrame);
	}
	else if (tree->type == 'D') {
		printf("got DECLARATION\n");
		//print_tree(tree->left->left);//return type
		//print_tree(tree->left->right->left);//function name
		TOKEN* nameToken = (TOKEN*)tree->left->right->left->left;
		
		char testString[5];
		sprintf(testString, nameToken->lexeme);
		if (strcmp(testString, "main") == 0) {
			printf("MAIN FOUND\n");
			main = nameToken;
		}
		printf("nameToken name is: ");
		printf(nameToken->lexeme);
		printf("\n");
		//printf("name: %s\n", nameToken->lexeme);
		//print_tree(tree->left->right->right);//formals
		//print_tree(tree->right);//body
		add_function_binding(theFrame, nameToken,
			(NODE *)tree->left->right->right, (NODE *)tree->right);
		printf("making mainClosure\n");
		struct closure mainClosure = get_func_binding(theFrame, main);
		print_tree(mainClosure.body);
		
	} else if (tree->type == '~') {
		printf("got VAR\n");
		TOKEN* val = (TOKEN*)tree->right->right->left;
		printf("bindingtest=%d\n", val->value);
		int theVal = val->value;
		print_tree(tree->right->right);

		if (tree->right->right->type == '+' || tree->right->right->type == '-' ||
			tree->right->right->type == '*' || tree->right->right->type == '/') {
			printf("PLUS\n");
			int l = interpret(tree->right->right, theFrame);
			printf("l=%d\n", l);
			theVal = l;
		}

		add_binding(theFrame, (TOKEN*)tree->right->left->left, theVal);
		//print_tree(tree->right->right);//value
		//print_tree(tree->right->left);//var name
	}

	return main;
}


int main(int argc, char** argv)
{
	if (argc>1 && strcmp(argv[1],"-d")==0) yydebug = 1;
    init_symbtable();

	// head = (listnode*)malloc(sizeof(listnode));
	// FRAME* main = (FRAME*)malloc(sizeof(FRAME)); 	//setup main scope
	// main->next = global; 							//link main and global frames
	
	// TOKEN* testtoken = lookup_token("z");			//testing to see if frames work
	// add_binding(main,testtoken,5);
	
    NODE* tree;

	int r;
    printf("--C COMPILER\n");
    yyparse();
    tree = ans;
    printf("parse finished with %p\n", tree);
    print_tree(tree);
	printf("\n\n-----\n\n");
	print_tree(tree->right->right);

	FRAME* g = (FRAME*)malloc(sizeof(FRAME));
	TOKEN* mainToken = set_up_global(tree ,g);
	//printf(mainToken->lexeme);
	struct closure mainClosure = get_func_binding(g, mainToken);
	printf("PRINTING MAIN\n");
	//print_tree(mainClosure.formals);
	//print_tree(mainClosure.body);
	//r = interpret(,g);
	// printf("%d\n",r);
	//compile(tree->right);
    return 0;
}

public class MathWithMultipleThreads {

	private static Random random = new Random();
	
	private static double[][] makeArray(int height, int width) {
		double[][] answer = new double[height][width];
		for (int row = 0; row < height; row++) {
			for (int col = 0; col < width; col++) {
				answer[row][col] = random.nextDouble();
			}
		}
		return answer;
	}
	
	public static void main(String[] args) throws InterruptedException {
		double[][] array = makeArray(1000, 1000);
		long start = System.nanoTime();
		
		//do stuff here
		
		
		
		long end = System.nanoTime();
		System.out.println((end - start)/1000000000.0);
	}
	
	class ProcessRow implements Runnable {
		
	double[] arrayRow;
	
	public ProcessRow(double[] rows) {
		arrayRow = rows;
	}

	@Override
	public void run() {
		
			for (int col = 0; col < arrayRow.length; col++){
				arrayRow[col] = Math.sqrt(arrayRow[col]);
			}
		
		
	}

}
}

public class MathWithMultipleThreads {

	private static Random random = new Random();
	
	private static double[][] makeArray(int height, int width) {
		double[][] answer = new double[height][width];
		for (int row = 0; row < height; row++) {
			for (int col = 0; col < width; col++) {
				answer[row][col] = random.nextDouble();
			}
		}
		return answer;
	}
	
	public static void main(String[] args) throws InterruptedException {
		double[][] array = makeArray(1000, 1000);
		long start = System.nanoTime();
		
		//do stuff here
		
		
		
		long end = System.nanoTime();
		System.out.println((end - start)/1000000000.0);
	}
}