id stringlengths 36 36 | text stringlengths 1 1.25M |
|---|---|
2ac5ebd7-1596-4c87-b5de-6b3845e7b9a0 | private void declarations() throws ParserException {
enterRule(NonTerminal.DECLARATIONS);
while (have(NonTerminal.DECLARATIONS)) {
if (accept(TokenKind.CONST)) {
Token ident = expectRetrieve(TokenKind.IDENT);
expect(TokenKind.ASSIGN);
Token tokenNum = expectRetrieve(TokenKind.NUMBER);
Symbol s = Symbol.newConstSymbol(ident.getLexeme(),
Type.newPrimitiveType("int"), tokenNum.getLexeme());
addSymbol(s, ident);
expect(TokenKind.SEMICOLON);
} else if (accept(TokenKind.VAR)) {
ArrayList<Token> idents = new ArrayList<Token>();
idents.add(expectRetrieve(TokenKind.IDENT));
while (accept(TokenKind.COMMA))
idents.add(expectRetrieve(TokenKind.IDENT));
expect(TokenKind.COLON);
Type t = type();
for (Token ident : idents)
addSymbol(Symbol.newVarSymbol(ident.getLexeme(), t), ident);
expect(TokenKind.SEMICOLON);
} else expect(NonTerminal.DECLARATIONS);
}
exitRule(NonTerminal.DECLARATIONS);
} |
c86ded55-e6b6-46f0-9ef0-15ccc6a2f74e | private List<Type> procedureFormalParams(Token functToken) throws ParserException {
enterRule(NonTerminal.PROCEDURE_FORMAL_PARAMS);
List<Type> types = new ArrayList<Type>();
do {
Type t = type();
types.add(t);
Token ident = expectRetrieve(TokenKind.IDENT);
if (t.isArray) prntMismatchInvArg(functToken, ident, t);
Symbol s = Symbol.newVarSymbol(ident.getLexeme(), t);
this.addSymbol(s, ident);
} while (accept(TokenKind.COMMA));
exitRule(NonTerminal.PROCEDURE_FORMAL_PARAMS);
return types;
} |
2ebe78ad-ff2d-4c14-8137-fc0a36cc6c87 | private void procedureDeclarations() throws ParserException {
enterRule(NonTerminal.PROCEDURE_DECLARATIONS);
while (have(NonTerminal.PROCEDURE_DECLARATIONS)) {
Type t = retType();
Token ident = expectRetrieve(TokenKind.IDENT);
expect(TokenKind.L_PAREN);
Symbol sym = Symbol.newProcedureSymbol(ident.getLexeme(), t);
addSymbol(sym, ident);
symbolTable.addScope();
List<Type> params = null;
if (have(NonTerminal.PROCEDURE_FORMAL_PARAMS))
params = procedureFormalParams(ident);
sym.params = params;
symbolTable.putFunction(sym);
expect(TokenKind.R_PAREN);
expect(TokenKind.L_BRACE);
if (have(NonTerminal.DECLARATIONS)) declarations();
if (have(NonTerminal.PROCEDURE_DECLARATIONS)) procedureDeclarations();
statementSequence(sym);
expect(TokenKind.R_BRACE);
symbolTable.decScope();
}
exitRule(NonTerminal.PROCEDURE_DECLARATIONS);
} |
e2760b2c-1785-4c1e-b33d-eaa3509f0831 | private void program() throws ParserException {
enterRule(NonTerminal.PROGRAM);
if (have(NonTerminal.DECLARATIONS)) declarations();
if (have(NonTerminal.PROCEDURE_DECLARATIONS)) procedureDeclarations();
expect(TokenKind.MAIN);
expect(TokenKind.L_PAREN);
symbolTable.addScope();
expect(TokenKind.R_PAREN);
expect(TokenKind.L_BRACE);
if (have(NonTerminal.DECLARATIONS)) declarations();
statementSequence(null);
expect(TokenKind.R_BRACE);
symbolTable.decScope();
expect(TokenKind.EOF);
exitRule(NonTerminal.PROGRAM);
} |
01380a97-44d7-4264-a3ee-b55b71d74806 | SymbolTable() {
scope = 0;
level = new LinkedHashMap<String, Symbol>();
level = new LinkedHashMap<String, Symbol>();
map = new ArrayList<LinkedHashMap<String, Symbol>>();
level.put("int", Symbol.newTypeSymbol("int"));
level.put("char", Symbol.newTypeSymbol("char"));
level.put("string", Symbol.newTypeSymbol("string"));
level.put("void", Symbol.newTypeSymbol("void"));
map.add(level);
} |
1b14d75c-c59b-4d8d-a2dd-419a800c6942 | public boolean addSymbol(Symbol sym) {
map.get(scope).put(sym.getKey(), sym);
return true;
} |
9511895f-cbc5-4e82-856c-bb9c430168cd | @Override
public String toString() {
StringBuilder content = new StringBuilder();
content.append(String.format("%s\n", "***** Symbol Table Contents *****"));
for (int i = 0; i < map.size(); i++) {
ArrayList<Symbol> vals = new ArrayList<Symbol>(map.get(i).values());
for (int j = 0; j < vals.size(); j++) {
Symbol currentEntry = vals.get(j);
for(int k = 0; k < i; k++)
content.append("-->");
content.append("N: " + currentEntry.getName() + " ");
content.append("C: " + currentEntry.getKind() + " ");
if (currentEntry.getType() != null) content.append("T: " + currentEntry.getType() + " ");
if (currentEntry.getValue() != null) content.append("V: " + currentEntry.getValue() + " ");
content.append("\n");
}
}
return content.toString();
} |
e961c092-f334-4924-9d0a-d63615f7d0f2 | public void addScope() {
scope++;
map.add(scope, new LinkedHashMap<String, Symbol>());
} |
9ec6e5e0-acd0-4971-b2b5-ac15afc40505 | public void decScope() {
map.remove(scope);
scope--;
} |
8490c6cb-396a-4b16-ae23-c95a5e15c4a7 | public boolean inParentScopes(Symbol inSym) {
for (int i = scope; i > -1; i--)
if (this.map.get(i).containsKey(inSym.getKey()))
return true;
return false;
} |
c3bb885d-740d-4ee7-9301-407b77b84d83 | public Symbol inParentScopes(String name, String strKind) {
String procSymbolKey = Symbol.GEN_KEY(name, Symbol.Kind.PROCEDURE);
String constSymbolKey = Symbol.GEN_KEY(name, Symbol.Kind.CONST);
String varSymbolKey = Symbol.GEN_KEY(name, Symbol.Kind.VAR);
for (int i = scope; i > -1; i--) {
if (strKind.equals("procedure") && this.map.get(i)
.containsKey(procSymbolKey)) {
return map.get(i).get(procSymbolKey);
}
else if (strKind.equals("selector") &&
(map.get(i).containsKey(constSymbolKey)
|| map.get(i).containsKey(varSymbolKey))) {
if (map.get(i).containsKey(constSymbolKey))
return map.get(i).get(constSymbolKey);
else if (map.get(i).containsKey(varSymbolKey))
return map.get(i).get(varSymbolKey);
}
}
return null;
} |
a5c6eb2a-666c-4daa-8919-7607b9c64c8e | public boolean inCurrentScope(Symbol inSym) {
String name = inSym.getKey().split(Symbol.KEY_DELIMITER)[0];
String kind = inSym.getKey().split(Symbol.KEY_DELIMITER)[1];
if (kind.equals("VAR") || kind.equals("CONST")) {
return (map.get(scope).containsKey(Symbol.GEN_KEY(name, Symbol.Kind.VAR)) ||
map.get(scope).containsKey(Symbol.GEN_KEY(name, Symbol.Kind.CONST)));
}
else
return map.get(scope).containsKey(inSym.getKey());
} |
54212e05-acd6-45f0-b5d4-3ac9d00fdcfd | public Symbol getFunctionSym(String procKey) {
return map.get(0).get(procKey);
} |
5906879d-3898-4c65-aa1b-cfdb25ab8d60 | public void putFunction(Symbol sym) {
map.get(0).put(sym.getKey(), sym);
} |
9fa9fcf8-0bb5-4d21-863b-16565cf07bf4 | public ParserException(int lineNumber, int charPosition, String message, Throwable cause) {
super(message, cause);
this.lineNumber = lineNumber;
this.charPosition = charPosition;
} |
81fd5645-8ecb-4003-8a52-76aebd1b9471 | public ParserException(int lineNumber, int charPosition, String message) {
super(message);
this.lineNumber = lineNumber;
this.charPosition = charPosition;
} |
8cb91712-fb06-49d9-94e3-9db1efb92790 | public ParserException(int lineNumber, int charPosition, Throwable cause) {
super(cause);
this.lineNumber = lineNumber;
this.charPosition = charPosition;
} |
4dd33d57-fdac-4f52-ab95-abadaa0f7d6c | @Override
public String getMessage() {
StringBuilder sb = new StringBuilder();
sb.append("Line ").append(lineNumber).append(" Char ").append(charPosition)
.append(": ").append(super.getMessage());
return sb.toString();
} |
ce82ee5c-564f-4b63-a74c-a9260fa51ab8 | public int getLineNumber() {
return lineNumber;
} |
23d106c7-c6da-46c9-950c-a7ad0f3f3a7b | public int getCharPosition() {
return charPosition;
} |
279b949f-4fbf-4f9b-a599-13b9be7640cc | private Symbol(String name, Type type, Kind kind, String value) {
this.name = name;
this.type = type;
this.kind = kind;
this.value = value;
} |
526591b0-4af4-4f2b-91c9-b96336516d86 | public String getKey() {
return this.name + KEY_DELIMITER + this.kind;
} |
23f12a68-3c0b-4bc9-ada5-8bd639992835 | public static String GEN_KEY(String name, Kind kind) {
return name + KEY_DELIMITER + kind;
} |
f41d5380-7e28-4902-a18b-55de93a1d815 | @Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("N: ").append(name).append(" ");
sb.append("C: ").append(kind).append(" ");
if (type != null) sb.append("T: ").append(type).append(" ");
if (value != null) sb.append("V: ").append(value).append(" ");
return sb.toString();
} |
903355db-1a34-43da-89c2-d3bfa7a80972 | public boolean sameSymbol(Symbol s) {
if (this.name.equals(s.name) && this.kind == s.kind)
return true;
return false;
} |
e0384867-52b8-430e-aff5-1611c2979b85 | public static Symbol newVarSymbol(String name, Type type) {
return new Symbol(name, type, Kind.VAR, null);
} |
462a2fbe-76ad-44eb-8175-87639d4bc70d | public static Symbol newConstSymbol(String name, Type type, String constValue) {
return new Symbol(name, type, Kind.CONST, constValue);
} |
f5df4f4e-d478-4247-a8ba-d0079bd092f0 | public static Symbol newProcedureSymbol(String name, Type retType) {
return new Symbol(name, retType, Kind.PROCEDURE, null);
} |
e00b2ddb-a4fa-41eb-b631-0194a8468c48 | public static Symbol newTypeSymbol(String name) {
return new Symbol(name, null, Kind.TYPE, null);
} |
04dc4d63-34e2-4f72-8c87-f2a6d9c9b3b0 | public String getName() {
return name;
} |
710de1a1-1ee8-43ca-be10-dd9e9049875c | public Type getType() {
return type;
} |
c3d18d24-8f24-4523-b5a7-f435a1bfde6b | public Kind getKind() {
return kind;
} |
9564022d-d568-4d6c-a319-cc746cc2b39b | public String getValue() {
return value;
} |
756d9f3c-b3ae-4dac-befd-9385215f2c58 | public Node(Token to, Type ty) {
super();
this.token = to;
this.type = ty;
} |
bf67a153-ab1e-4694-88bc-083b242e4a60 | public Token(TokenKind tokenKind, String lexeme, int lineNum, int charPos) {
this.tokenKind = tokenKind;
this.lexeme = lexeme;
this.lineNum = lineNum;
this.charPos = charPos;
} |
cc1892cc-2983-436a-9180-dca5fda94ae5 | public TokenKind getTokenKind() {
return tokenKind;
} |
eaf43582-d10e-4b8f-be8b-52ed5b5eb12c | public String getLexeme() {
return lexeme;
} |
f422f067-459d-4c88-983e-44849aa830dd | public int getLineNum() {
return lineNum;
} |
3ba21041-c835-43cf-824a-da2a962edafe | public int getCharPos() {
return charPos;
} |
d92a2cf1-8ef6-43ef-97b7-d1fb08be6bf1 | private static String fileToString(String file) throws IOException {
String result = null;
DataInputStream in = null;
try {
File f = new File(file);
byte[] buffer = new byte[(int) f.length()];
in = new DataInputStream(new FileInputStream(f));
in.readFully(buffer);
result = new String(buffer);
result = result.replaceAll("\r\n", "\n");
result = result.replaceAll("\r", "\n");
} finally {
if (in != null) in.close();
}
return result;
} |
6d772902-edbc-45cc-8a85-0d53759206f0 | private static boolean isCompilerCorrect(File sourceFile, boolean generateOutputs) {
String sourceFilename = sourceFile.getAbsolutePath();
boolean isCorrect = false;
try {
Compiler compiler = new Compiler(sourceFilename);
String result = compiler.compile();
if (generateOutputs) {
PrintStream out = new PrintStream(new File(sourceFilename + ".out"));
out.print(result);
}
String expectedResult = fileToString(sourceFilename + ".exp");
isCorrect = result.equals(expectedResult);
} catch (Exception e) {
e.printStackTrace();
}
return isCorrect;
} |
4e4f6335-4760-4170-a2b3-f01bc2740b06 | public static void main(String[] args) {
if (args.length < 1) {
System.out.println("Usage: java Tester <testFile1> <testFile2> ...");
System.exit(1);
}
int score = 0;
PrintStream out = System.out;
for (String sourceFilename : args) {
File sourceFile = new File(sourceFilename);
if (isCompilerCorrect(sourceFile, GENERATE_OUTPUTS)) {
if (! SUPPRESS_PASS) out.println("Test " + sourceFile.getName() + " PASSED");
score++;
} else {
out.println("Test " + sourceFile.getName() + " ** FAILED **");
}
}
out.println("Score: " + score + "/" + args.length);
} |
63014252-a489-4a3e-99ac-247fedead1bc | protected Type() {} |
27ca6dad-9070-4e80-9112-5fa9024cb8a9 | public static Type newPrimitiveType(String typeName) {
Type res;
if (typeName.equals("int")) res = INT;
else if (typeName.equals("char")) res = CHAR;
else if (typeName.equals("string")) res = STRING;
else if (typeName.equals("void")) res = VOID;
else res = new PrimitiveType(typeName);
return res;
} |
0257e7c2-5fb0-4c54-8bc9-cdb7894fcf7a | public static Type newArrayType(Type baseType, int dimension) {
return new ArrayType(baseType, dimension);
} |
79882560-98dd-4e38-90bd-48087702b1eb | public PrimitiveType(String name) {
this.name = name;
} |
2eeed04c-d8f4-4f32-9189-642e61ee6eba | @Override
public String toString() {
return name;
} |
04101a32-a4d8-4904-9e30-96eaed3cbe6f | public ArrayType(Type baseType, int dimension) {
this.baseType = baseType;
this.dimension = dimension;
this.isArray = true;
this.depth = 1;
Type tempBase = baseType;
while (tempBase.toString().length() > 5 &&
tempBase.toString().subSequence(0, 5).equals("array")) {
this.depth++;
tempBase = tempBase.baseType;
}
} |
20cd89d2-81fa-4eca-af98-3cf87ae70284 | @Override
public String toString() {
return "array " + dimension + " of " + baseType.toString();
} |
1c766f03-a3f2-4fb8-bebe-56f46e1c0a6c | public boolean equals(Type t) {
if ((t.isArray && this.isArray) || (!t.isArray && !t.isArray)) {
if (t.isArray && this.isArray) {
return (t.toString().equals(this.toString()));
}
else {
return (t.name.equals(this.name));
}
}
return false;
} |
70505aa9-cd9c-4ff4-98fe-f995108f3b56 | public ScannerException() {
super();
} |
7b7bdbe8-d74a-4641-b462-844b047050a7 | public ScannerException(String message, Throwable cause, boolean enableSuppression,
boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
} |
54249a2b-23ec-4145-9273-565c4794071e | public ScannerException(String message, Throwable cause) {
super(message, cause);
} |
6d282357-fef5-47ee-b9a1-d247900bf3f8 | public ScannerException(String message) {
super(message);
} |
cbf7b7cb-5815-4922-bbb0-9234ab87b02f | public ScannerException(Throwable cause) {
super(cause);
} |
cca8201c-04bd-4d80-98f9-6a7913f73060 | public Scanner(String sourceFilename) throws ScannerException {
try {
in = new LineNumberReader(new FileReader(sourceFilename));
} catch (IOException e) {
throw new ScannerException("Cannot open " + sourceFilename, e);
}
lexeme = new StringBuilder();
nextLineNum = 1;
nextCharPos = 0;
nextChar = Integer.MAX_VALUE;
readChar();
} |
c482b2a2-de02-4533-a56a-8bd7985213a0 | private void readChar() throws ScannerException {
if (nextChar == '\n') {
nextLineNum++;
nextCharPos = 0;
}
nextCharPos++;
try {
nextChar = in.read();
lexeme.append((char) nextChar);
} catch (IOException e) {
throw new ScannerException("Cannot read next char at line=" + nextLineNum +
", charPos=" + nextCharPos, e);
}
} |
ebed3095-1b23-412d-a30c-261d7a39233a | public TokenKind next() throws ScannerException {
// Strip comments and whitespace
while (nextChar == '#' || Character.isWhitespace(nextChar)) {
if (nextChar == '#') {
while (nextChar != '\n' && nextChar != -1) readChar();
} else {
while (Character.isWhitespace(nextChar)) readChar();
}
}
lexeme.setLength(0); lexeme.append((char) nextChar);
tokenKind = TokenKind.ERROR;
lineNum = nextLineNum;
charPos = nextCharPos;
// Main switch-case
boolean shouldReadChar = true;
switch (nextChar) {
case -1:
tokenKind = TokenKind.EOF;
break;
case ';':
tokenKind = TokenKind.SEMICOLON;
break;
case '.':
tokenKind = TokenKind.PERIOD;
break;
case '(':
tokenKind = TokenKind.L_PAREN;
break;
case ')':
tokenKind = TokenKind.R_PAREN;
break;
case '{':
tokenKind = TokenKind.L_BRACE;
break;
case '}':
tokenKind = TokenKind.R_BRACE;
break;
case '[':
tokenKind = TokenKind.L_BRACKET;
break;
case ']':
tokenKind = TokenKind.R_BRACKET;
break;
case ',':
tokenKind = TokenKind.COMMA;
break;
case '+':
tokenKind = TokenKind.ADD;
break;
case '-':
tokenKind = TokenKind.SUB;
break;
case '*':
tokenKind = TokenKind.MULT;
break;
case '/':
tokenKind = TokenKind.DIV;
break;
case ':':
tokenKind = TokenKind.COLON;
break;
case '=':
readChar();
if (nextChar == '=') tokenKind = TokenKind.EQUAL;
else { tokenKind = TokenKind.ASSIGN; shouldReadChar = false; }
break;
case '<':
readChar();
if (nextChar == '=') tokenKind = TokenKind.LESSER_EQUAL;
else { tokenKind = TokenKind.LESS_THAN; shouldReadChar = false; }
break;
case '>':
readChar();
if (nextChar == '=') tokenKind = TokenKind.GREATER_EQUAL;
else { tokenKind = TokenKind.GREATER_THAN; shouldReadChar = false; }
break;
case '!':
readChar();
if (nextChar == '=') tokenKind = TokenKind.NEQ;
else { tokenKind = TokenKind.ERROR; shouldReadChar = false; }
break;
case '"':
tokenKind = TokenKind.STRING_LITERAL;
lexeme.setLength(0); // remove opening quote
do {
readChar();
} while (nextChar != '"' && nextChar != -1);
if (nextChar == '"') lexeme.deleteCharAt(lexeme.length() - 1); // remove ending quote
else { tokenKind = TokenKind.ERROR; shouldReadChar = false; }
break;
}
// Scan identifier/keyword and number
if (tokenKind == TokenKind.ERROR && shouldReadChar) {
if (Character.isDigit(nextChar)) {
tokenKind = TokenKind.NUMBER;
do {
readChar();
} while (Character.isDigit(nextChar));
shouldReadChar = false;
} else if (Character.isLetter(nextChar)) {
do {
readChar();
} while (Character.isLetterOrDigit(nextChar));
shouldReadChar = false;
// check for keyword
String identifier = lexeme.substring(0, lexeme.length() - 1);
tokenKind = keywords.get(identifier);
if (tokenKind == null) tokenKind = TokenKind.IDENT;
}
}
// Get the next lookahead character
if (shouldReadChar) readChar();
lexeme.deleteCharAt(lexeme.length() - 1);
return tokenKind;
} |
8b24a7f2-287b-4496-8b9b-025716b09b57 | @Override
public String toString() {
return "(L" + getLineNum() + " C" + getCharPos() + ") " + getTokenKind() + getLexeme();
} |
d3812d2f-6624-4948-8f26-6f19b57ecdae | public TokenKind getTokenKind() {
return tokenKind;
} |
d0283c1c-2361-49f3-84c7-eeafa7ade2cd | public String getLexeme() {
if (tokenKind == TokenKind.EOF) return "";
return lexeme.toString();
} |
c393164b-d69b-4acc-bce2-5ba4a34e181e | public int getLineNum() {
return lineNum;
} |
c1d2b82a-263d-48b1-b19a-34607d70f1f5 | public int getCharPos() {
return charPos;
} |
5d31dc25-b6d7-4d3e-8a1a-b2a3922f7e18 | public Token getToken() {
return new Token(getTokenKind(), getLexeme(), getLineNum(), getCharPos());
} |
f80ba2e6-37a8-45ed-b295-6451492fac8d | NonTerminal(String name, Set<TokenKind> firstSet) {
this.name = name;
this.firstSet = firstSet;
} |
1805b62c-8143-493e-a23f-ccbc75b30e3a | private TokenKind(String defaultLexeme) {
this.defaultLexeme = defaultLexeme;
} |
47b90fbd-3624-443c-b247-d5dba37cebf1 | public Compiler(String sourceFilename) throws IOException {
this.sourceFilename = sourceFilename;
} |
cae310c5-9b2c-4769-910b-4c6012ee8ee0 | private String tokenToString(TokenKind token, Scanner scanner) {
if (token.defaultLexeme.length() == 0)
return token.toString().toLowerCase() + ":" + scanner.getLexeme();
else
return token.defaultLexeme;
} |
bdffdf57-deac-4337-9aef-8cdfc5a34cae | private String computeTokens() {
StringBuilder sb = new StringBuilder();
Scanner scanner = new Scanner(sourceFilename);
TokenKind token = scanner.next();
while (token != TokenKind.EOF && token != TokenKind.ERROR) {
sb.append(tokenToString(token, scanner)).append("\n");
token = scanner.next();
}
sb.append(tokenToString(token, scanner)).append("\n"); // append the EOF or ERROR
return sb.toString();
} |
8f81f5f6-6463-4ed8-8fc2-26fbee74b187 | private String computeFullTokens() {
StringBuilder sb = new StringBuilder();
Scanner scanner = new Scanner(sourceFilename);
TokenKind token = scanner.next();
while (token != TokenKind.EOF && token != TokenKind.ERROR) {
sb.append(scanner).append("\n");
token = scanner.next();
}
sb.append(scanner).append("\n"); // append the EOF or ERROR
return sb.toString();
} |
e49e2b2e-add7-429f-af75-c427f9bb1841 | private String computeParseTree() {
Parser parser = new Parser(false);
try {
parser.parse(sourceFilename);
} catch (ParserException e) {
//System.out.println("ParserException: " + e.getMessage());
}
String ret = parser.getParseTree();
for (String error : parser.getErrors()) {
ret += error + "\n";
}
return ret;
} |
a4063bc9-bb6a-46fe-9f0c-470a6bec6846 | private String computeSymbolTable() {
Parser parser = new Parser();
try {
parser.parse(sourceFilename);
} catch (ParserException e) {
//System.out.println("ParserException: " + e.getMessage());
}
// Print the symbol table or error
if (parser.getErrors().isEmpty()) {
return parser.getSymbolTable().toString() + "\n";
} else {
String ret = "";
for (String error : parser.getErrors()) {
ret += error + "\n";
}
return ret;
}
} |
f5d9cd67-51be-48bb-a222-29702de69da3 | public String compile() {
//return computeTokens();
//return computeFullTokens();
//return computeParseTree();
return computeSymbolTable();
} |
f1d73d24-b7a1-4f98-8b98-9f94df77503d | @Override
public void run() {
super.run();
try {
sleep((long) (400 + Math.random()*1000));
System.out.println("Worker Done");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} |
2e1c38a9-9de6-45cb-be53-9935e3fa5795 | public static void main(String[] args) {
MyLoader myLoader = new MyLoader(queue);
MyDispatcher dispatcher = new MyDispatcher(queue);
myLoader.setLoaderDelay(2l);
myLoader.start();
dispatcher.setDispatcherDelay(350l);
dispatcher.start();
} |
b12a1996-5681-4f8f-91ef-fbccb8d77d48 | public Long getLoaderDelay() {
return loaderDelay;
} |
c5b3b089-4591-4158-808f-9486733a7945 | public void setLoaderDelay(Long loaderDelay) {
this.loaderDelay = loaderDelay;
} |
546200e7-1ac4-4fb1-847a-f79fd55eb260 | public int getMax_Qsize() {
return max_Qsize;
} |
90bb0dbc-3fd5-40a3-9171-c8c13d93ffe0 | public void setMax_Qsize(int max_Qsize) {
this.max_Qsize = max_Qsize;
} |
03f9d67c-4727-409b-b5fd-650a7d155869 | public MyLoader(Queue<MyWorker> q) {
this.q = q;
} |
11d596d3-990f-4233-88d6-ceb9e574206b | @Override
public void run() {
Random r = new Random();
super.run();
while (true) {
synchronized (q) {
if (q.size() < max_Qsize) {
q.add(new MyWorker());
}
}
try {
sleep(loaderDelay + r.nextInt(300) );
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("Task Loaded");
System.out.println("Queue size = " + q.size());
}
} |
5c40cc98-8c00-4e87-a983-edcfae3c9f10 | public MyDispatcher(Queue<?> q) {
this.q = q;
} |
c652dc02-66c2-4def-bd59-5f9d94b54050 | @Override
public void run() {
super.run();
Thread thread;
while (true) {
synchronized (q) {
if (!q.isEmpty()) {
thread = (Thread) q.poll();
thread.start();
System.out.println("Dispatcher : Thread Started");
}
}
try {
sleep(dispatcherDelay);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} |
46dec790-1bb5-447d-84df-53caca618d53 | public Long getDispatcherDelay() {
return dispatcherDelay;
} |
fde60cab-8d8c-463c-a289-30c9e93fb66e | public void setDispatcherDelay(Long dispatcherDelay) {
this.dispatcherDelay = dispatcherDelay;
} |
a970b543-4800-490b-98b4-1b32def1c165 | @Override
public int hashCode() {
return name.hashCode();
} |
c9bd6848-4122-43dd-95fd-d77ae7e35fb2 | @Override
public boolean equals(Object obj) {
if(obj.getClass().equals(BaseProduct.class)){
return name.equals( ((BaseProduct) obj).name);
}
return name.equals( ((Product) obj).name);
} |
7a383174-b4f6-489c-89f5-a7454826e2fa | @Override
public String toString() {
return "Item : "+this.name+", Price : "+this.price+", Count : "+this.count+", Savings : "+this.savings;
} |
94098deb-9be0-4f81-827b-4aa5aa1f2e06 | public Product(String name, Float price, OFFER_TYPE offer) {
super(name);
this.offer=offer;
this.price=price;
} |
ccbf74f1-2101-4946-a5b8-11e8d8989f88 | public OFFER_TYPE getOffer() {
return offer;
} |
9fb1e47b-7e0b-4507-9d5e-563334bbde87 | public void setOffer(OFFER_TYPE offer) {
this.offer = offer;
} |
e122613a-5773-4d1a-aaac-a1e4cf70e6d4 | public void increaseCount(){
count++;
} |
2fe64f49-60cb-4a1a-abae-3f6779d93d98 | public BaseProduct(String name) {
this.name = name;
} |
e599c0bc-a8e3-4aa8-88db-712cfad0b12f | public String getName() {
return name;
} |
5dbf7df8-078c-4b81-8bd6-1245da7ed43d | public void setName(String name) {
this.name = name;
} |
3116f62b-3be5-4b8f-bb42-75954cb4264b | public float getPrice() {
return price;
} |
11f1f7d4-f9ef-4743-8549-ac4ae6b23ccc | public void setPrice(float price) {
this.price = price;
} |
4597615d-32c8-4c33-a610-4bcb4709f528 | public float getSavings() {
return savings;
} |
4ba1dfc4-4e17-4848-9b81-fe836786f6dc | public void setSavings(float savings) {
this.savings = savings;
} |
641dc368-89f2-40eb-99d4-da10a149b4e1 | public int getCount() {
return count;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.