int main(int argc, char* argv[]){
Dictionary A = newDictionary();
printf("got jere");
FILE* in = fopen("DictionaryClient2.c", "r");
FILE* out = fopen("DictionaryClient2-out", "w");
char* key;
char* value;
char* keyBuffer = NULL;
char* valBuffer = NULL;
int keyBufferOffset = 0, valBufferOffset = 0;
int keyBufferLength = 0, valBufferLength = 0;
char line[MAX_LEN+1];
char label[MAX_LEN+1];
int i, labelLength, lineLength, lineNumber = 0;
// read input files
while( fgets(line, MAX_LEN, in)!=NULL ){
// put line in valBuffer
lineNumber++;
lineLength = strlen(line)-1;
line[lineLength] = '\0'; // overwrite newline '\n' with null '\0'
valBufferLength += (lineLength+1);
valBuffer = realloc(valBuffer, valBufferLength*sizeof(char) );
value = &valBuffer[valBufferOffset];
strcpy(value, line);
valBufferOffset = valBufferLength;
// put label in keyBuffer
sprintf(label, "line %d:\t", lineNumber);
labelLength = strlen(label);
keyBufferLength += (labelLength+1);
keyBuffer = realloc(keyBuffer, keyBufferLength*sizeof(char) );
key = &keyBuffer[keyBufferOffset];
strcpy(key, label);
keyBufferOffset = keyBufferLength;
}
// put keys and values in dictionary A
keyBufferOffset = valBufferOffset = 0;
for(i=0; i<lineNumber; i++){
key = &keyBuffer[keyBufferOffset];
value = &valBuffer[valBufferOffset];
insert(A, key, value);
keyBufferOffset += (strlen(key) + 1);
valBufferOffset += (strlen(value) + 1);
}
printDictionary(out, A);
// free memory and close files
freeDictionary(&A);
free(keyBuffer);
free(valBuffer);
fclose(in);
fclose(out);
return(EXIT_SUCCESS);
}
/*
readDeclaration reads a declaration of a class
*/
static void readClassDeclaration()
{
ObjectHandle classObj, metaObj, vars;
std::string className, superName;
int i, size, instanceTop;
// todo: fixed length variables array!
ObjectHandle instanceVariables[15];
// todo: horrible fixed length arrays!
char metaClassName[100];
char metaSuperClassName[100];
if (ll.nextToken() != nameconst)
sysError("bad file format","no name in declaration");
className = ll.strToken();
if (ll.nextToken() == nameconst)
{ /* read superclass name */
superName = ll.strToken();
ll.nextToken();
}
// todo: sprintf eradication!
sprintf(metaClassName, "Meta%s", className.c_str());
if(!superName.empty())
sprintf(metaSuperClassName, "Meta%s", superName.c_str());
else
sprintf(metaSuperClassName, "Class");
metaObj = createRawClass(metaClassName, "Class", metaSuperClassName);
classObj = createRawClass(className.c_str(), metaClassName, superName.c_str());
classObj->_class = metaObj;
// Get the current class size, we'll build on this as
// we add instance variables.
size = getInteger(classObj->basicAt(sizeInClass));
if (ll.currentToken() == nameconst)
{ /* read instance var names */
instanceTop = 0;
while (ll.currentToken() == nameconst)
{
instanceVariables[instanceTop++] = createSymbol(ll.strToken().c_str());
size++;
ll.nextToken();
}
vars = newArray(instanceTop);
for (i = 0; i < instanceTop; i++)
{
vars->basicAtPut(i+1, instanceVariables[i]);
}
classObj->basicAtPut(variablesInClass, vars);
}
classObj->basicAtPut(sizeInClass, newInteger(size));
classObj->basicAtPut(methodsInClass, newDictionary(39));
}
/*
readRawDeclaration reads a declaration of a class
*/
static void readRawClassDeclaration()
{
ObjectHandle classObj, vars;
std::string className, metaName, superName;
int i, size, instanceTop;
// todo: fixed length variables array!
ObjectHandle instanceVariables[15];
if (ll.nextToken() != nameconst)
sysError("bad file format","no name in declaration");
className = ll.strToken();
size = 0;
if (ll.nextToken() == nameconst)
{ /* read metaclass name */
metaName = ll.strToken();
ll.nextToken();
}
if (ll.currentToken() == nameconst)
{ /* read superclass name */
superName = ll.strToken();
ll.nextToken();
}
classObj = createRawClass(className.c_str(), metaName.c_str(), superName.c_str());
// Get the current class size, we'll build on this as
// we add instance variables.
size = getInteger(classObj->basicAt(sizeInClass));
if (ll.currentToken() == nameconst)
{ /* read instance var names */
instanceTop = 0;
while (ll.currentToken() == nameconst)
{
instanceVariables[instanceTop++] = createSymbol(ll.strToken().c_str());
size++;
ll.nextToken();
}
vars = newArray(instanceTop);
for (i = 0; i < instanceTop; i++)
{
vars->basicAtPut(i+1, instanceVariables[i]);
}
classObj->basicAtPut(variablesInClass, vars);
}
classObj->basicAtPut(sizeInClass, newInteger(size));
classObj->basicAtPut(methodsInClass, newDictionary(39));
}
zHttpRequest * parseRequest(int connectfd){
int br;
char socket_buffer[SOCKET_BUFFER_SIZE];
zHttpRequest *newRequest = (zHttpRequest *)malloc(sizeof(struct zHttpRequest));
//grab contents of stream, store fd
newRequest->outfd = connectfd;
br = read(connectfd, socket_buffer, SOCKET_BUFFER_SIZE);
socket_buffer[br] = '\0';
printf("%s\n[%d bytes read]\n", (char*)socket_buffer, br);
//build header dict, fill with header fields
newRequest->header = newDictionary();
int index = 0; //necessary for newNextLine to keep parsing socket_buffer
//get first line of HTTP Request, store method & location
char * line = newNextLine(socket_buffer, &index);
char * method_type = newIndexToChar(line, 0, ' ');
addValueForKey(newRequest->header, newString("method"), method_type);
int start = strlen(method_type)+1;
char * location_req = newIndexToChar(line, start, ' ');
addValueForKey(newRequest->header, newString("location"), location_req);
free(line);
//parse out rest of header fields, add to dict
for(;;){
line = newNextLine(socket_buffer, &index);
int len = strlen(line);
if(len <= 1)
break;
char * key_string = mutateToLower(newIndexToChar(line, 0, ':'));
start = strlen(key_string)+2;
char * val_string = newIndexToChar(line, start, '\r');
//printf("key: '%s', val: [%s]\n", key_string, val_string);
addValueForKey(newRequest->header, key_string, val_string);
free(line);
}
//parse and store body
newRequest->body = newIndexToChar(socket_buffer, index, '\0');
//printDict(newRequest->header);
//printf("Body::\n%s\n::end Body\n", newRequest->body);
return newRequest;
}
int main(int argc, char* argv[]){
Dictionary A = newDictionary();
char* k;
char* v;
char* word1[] = {"one","two","three","four","five","six","seven"};
char* word2[] = {"foo","bar","blah","galumph","happy","sad","blue"};
int i;
for(i=0; i<7; i++){
insert(A, word1[i], word2[i]);
}
printDictionary(stdout, A);
for(i=0; i<7; i++){
k = word1[i];
v = lookup(A, k);
printf("key=\"%s\" %s\"%s\"\n", k, (v==NULL?"not found ":"value="), v);
}
// insert(A, "five", "glow"); // error: duplicate keys
delete(A, "one");
delete(A, "three");
delete(A, "seven");
printDictionary(stdout, A);
for(i=0; i<7; i++){
k = word1[i];
v = lookup(A, k);
printf("key=\"%s\" %s\"%s\"\n", k, (v==NULL?"not found ":"value="), v);
}
// delete(A, "one"); // error: key not found
printf("%s\n", (isEmpty(A)?"true":"false"));
printf("%d\n", size(A));
makeEmpty(A);
printf("%s\n", (isEmpty(A)?"true":"false"));
freeDictionary(&A);
return(EXIT_SUCCESS);
}
int main(int argc, char* argv[]){
int v;
DictionaryRef A = newDictionary();
insert(A, 1, 111);
insert(A, 2, 222);
insert(A, 3, 333);
insert(A, 4, 444);
insert(A, 5, 555);
insert(A, 6, 666);
insert(A, 7, 777);
printDictionary(A, stdout);
v = lookup(A, 1);
printf("key=1 "); v==UNDEF?printf("not found\n"):printf("value=%d\n", v);
v = lookup(A, 3);
printf("key=3 "); v==UNDEF?printf("not found\n"):printf("value=%d\n", v);
v = lookup(A, 7);
printf("key=7 "); v==UNDEF?printf("not found\n"):printf("value=%d\n", v);
v = lookup(A, 8);
printf("key=8 "); v==UNDEF?printf("not found\n"):printf("value=%d\n", v);
printf("\n");
/* insert(A, 2, 666); */ /* causes insert() duplicate keys error */
delete(A, 1);
delete(A, 3);
delete(A, 7);
printDictionary(A, stdout);
/* delete(A, 8); */ /* causes delete() non-existent key error */
printf("%s\n", isEmpty(A)?"true":"false");
printf("%d\n", size(A));
makeEmpty(A);
printf("%s\n", isEmpty(A)?"true":"false");
printDictionary(A, stdout);
freeDictionary(&A);
return(EXIT_SUCCESS);
}
static ObjectHandle findClassWithMeta(const char* name, ObjectHandle metaObj)
{
ObjectHandle newObj, nameObj, methTable;
int size;
newObj = globalSymbol(name);
if (newObj == nilobj)
{
size = getInteger(metaObj->basicAt(sizeInClass));
newObj = MemoryManager::Instance()->allocObject(size);
newObj->_class = metaObj;
/* now make name */
nameObj = createSymbol(name);
newObj->basicAtPut(nameInClass, nameObj);
methTable = newDictionary(39);
newObj->basicAtPut(methodsInClass, methTable);
newObj->basicAtPut(sizeInClass, newInteger(size));
/* now put in global symbols table */
nameTableInsert(symbols, strHash(name), nameObj, newObj);
}
return newObj;
}
char * newSpeak(const char * text, const char * (*replace)[2]) {
TNODE * dictionary;
if (NULL == (dictionary = newDictionary(replace))) return NULL;
unsigned int frontIndex = 0, tailIndex = 0, translationLenght = 0, maxLenght = DEFAULT_LENGHT;
const char * match;
char * translation = (char *) malloc(maxLenght + 1);
translation[0] = '\0';
for (frontIndex = 0; text[frontIndex] != '\0'; frontIndex++) {
if (NULL != (match = findTranslation(dictionary, text + frontIndex, &tailIndex))) {
frontIndex += tailIndex;
translationLenght += strlen(match);
while (translationLenght >= maxLenght) translation = reallocString(translation, maxLenght *= 2);
strcat(translation, match);
} else {
if(translationLenght + 1 >= maxLenght) translation = reallocString(translation, maxLenght *= 2);
translation[translationLenght++] = text[frontIndex];
translation[translationLenght] = '\0';
}
}
freeDictionary(dictionary);
return translation;
}
int test_newDictionary(){
dict = newDictionary();
return 0;
}
/*
readClass reads a class method description
*/
static void readMethods(FILE* fd, bool printit)
{
ObjectHandle classObj, methTable, theMethod, selector;
# define LINEBUFFERSIZE 16384
char *cp, *eoftest, lineBuffer[LINEBUFFERSIZE];
ObjectHandle protocol;
Parser pp;
lineBuffer[0] = '\0';
protocol = nilobj;
if (ll.nextToken() != nameconst)
sysError("missing name","following Method keyword");
classObj = findClass(ll.strToken().c_str());
pp.setInstanceVariables(classObj);
if (printit)
cp = objectRef(classObj->basicAt(nameInClass)).charPtr();
/* now find or create a method table */
methTable = classObj->basicAt(methodsInClass);
if (methTable == nilobj)
{ /* must make */
methTable = newDictionary(MethodTableSize);
classObj->basicAtPut(methodsInClass, methTable);
}
if(ll.nextToken() == strconst)
{
protocol = newStString(ll.strToken().c_str());
}
/* now go read the methods */
do {
if (lineBuffer[0] == '|') /* get any left over text */
strcpy(textBuffer,&lineBuffer[1]);
else
textBuffer[0] = '\0';
while((eoftest = fgets(lineBuffer, LINEBUFFERSIZE, fd)) != NULL) {
if ((lineBuffer[0] == '|') || (lineBuffer[0] == ']'))
break;
strcat(textBuffer, lineBuffer);
}
if (eoftest == NULL) {
sysError("unexpected end of file","while reading method");
break;
}
/* now we have a method */
theMethod = newMethod();
pp.setLexer(Lexer(textBuffer));
if (pp.parseMessageHandler(theMethod, savetext)) {
selector = theMethod->basicAt(messageInMethod);
theMethod->basicAtPut(methodClassInMethod, classObj);
theMethod->basicAtPut(protocolInMethod, protocol);
if (printit)
dspMethod(cp, selector->charPtr());
nameTableInsert(methTable, selector.hash(), selector, theMethod);
}
else {
/* get rid of unwanted method */
givepause();
}
} while (lineBuffer[0] != ']');
}
int main(int argc, char* argv[]){
if ( argc != 3 ) // argc should be 3 for correct execution
{
printf( "usage: %s input_filename output_filename\n", argv[0] );
}
//read text file into input array
OriginalData* orig = readOriginalData(argv[1]);
//allocate the same amount of compressed data (lets hope it is enough)
CompressedData* compressed = newCompressedData(orig->dataLength, 8);
//initializez the dictionary and the symbols in the dictionary
Dictionary* dict = newDictionary(8);
initDictionary(dict);
printf("Compressing...\n");
writeToCompressedData(compressed, dict->clearCode);
MyString* S = newString();
int codeword;
int dictReturn;
while(hasNextSymbol(orig)){
appendString(S, (uint8_t) nextSymbol(orig));
if(getCodeword(dict, S) != -1){
;
} else {
//output S minus the last char
S->length--;
codeword = getCodeword(dict, S);
writeToCompressedData(compressed, codeword);
S->length++;
//great for debugging :
// printf("wrote a %d bit codeword: %d\n", compressed->bitWidth, codeword);
// printf("Saved new word: %d \t", dict->wordCount);
// printString(S);
// printf("\n");
//add S to the dictionary
dictReturn = addToDictionary(dict, S);
if(dictReturn == -2){
//for debugging :
// printf("--------------------------Increased Bit Width\n");
//increase the bit width by one
compressed->bitWidth++;
dict->bitWidth *= 2;
}
if(dictReturn == -1){
//dictionary is full, clear it and write a clearCode
clearDictionary(dict);
writeToCompressedData(compressed, dict->clearCode);
compressed->bitWidth = compressed->rootBitWidth+1;
//step one symbol back in original data
orig->nextSymbol--;
orig->dataLeft++;
//make S empty
S->length = 0;
}else{
//"delete" the last character (it will still be in the data)
S->length--;
S->data[0] = S->data[S->length];//make S start with the "deleted" character
S->length = 1; //make the length of S 1, now S is the earlier last character
}
}
}
//write the last codeword
codeword = getCodeword(dict, S);
writeToCompressedData(compressed, codeword);
//write EOI
writeToCompressedData(compressed, dict->endOfInformation);
writeCompressedDataToFile(compressed, argv[2]);
printf("File %s compressed succesfully to %s\n", argv[1], argv[2]);
return 0;
}
int main(int argc, char* argv[]){
Dictionary A = newDictionary();
Dictionary B = newDictionary();
Dictionary C = newDictionary();
//insert() test-------------------------------------------------------
insert(A,"1","Dan");
insert(A,"2","brad");
insert(A,"4","Richard");
insert(A,"100","Matt");
insert(B,"A","Tasha");
insert(B,"G","Tammy");
//to invoke exception
//insert(D,"AS","rachel");
//insert(B,"A","Tase");
//size() test---------------------------------------------------------
printf("%d\n",size(A));
printf("%d\n",size(B));
printf("%d\n",size(C));
printf("\n");
//to invoke exception
//printf("%d", size(D));
//isEmpty() test------------------------------------------------------
printf("%s\n", isEmpty(A)?"true":"false");
printf("%s\n", isEmpty(C)?"true":"false");
printf("\n");
//to invoke exception
//printf("%s/n", isEmpty(D)?"true":"false");
//lookup() test-------------------------------------------------------
printf("%s\n",lookup(A,"1"));
//printf("%s\n",lookup(A,"A"));
printf("%s\n",lookup(A,"4"));
printf("%s\n",lookup(A,"100"));
printf("%s\n",lookup(B,"A"));
//printf("%s\n",lookup(C,"2"));
printf("\n");
//makeEmpty() test----------------------------------------------------
makeEmpty(B);
//makeEmpty(D);
//printDictionary() test----------------------------------------------
printDictionary(stdout,A);
printDictionary(stdout,B);
//delete() test-------------------------------------------------------
delete(A,"1");
delete(A,"4");
delete(A,"100");
printDictionary(stdout,A);
freeDictionary(&A);
freeDictionary(&B);
freeDictionary(&C);
return(EXIT_SUCCESS);
}
/*
readClass reads a class method description
*/
static void readMethods(FILE *fd, boolean printit)
{
object classObj, methTable, theMethod, selector;
# define LINEBUFFERSIZE 512
char *cp, *eoftest, lineBuffer[LINEBUFFERSIZE];
if (nextToken() != nameconst)
sysError("missing name", "following Method keyword");
classObj = findClass(tokenString);
setInstanceVariables(classObj);
if (printit)
cp = charPtr(basicAt(classObj, nameInClass));
/* now find or create a method table */
methTable = basicAt(classObj, methodsInClass);
if (methTable == nilobj) /* must make */
{
methTable = newDictionary(MethodTableSize);
basicAtPut(classObj, methodsInClass, methTable);
}
/* now go read the methods */
do
{
if (lineBuffer[0] == '|') /* get any left over text */
strcpy(textBuffer, &lineBuffer[1]);
else
textBuffer[0] = '\0';
while ((eoftest = fgets(lineBuffer, LINEBUFFERSIZE, fd)) != NULL)
{
if ((lineBuffer[0] == '|') || (lineBuffer[0] == ']'))
break;
strcat(textBuffer, lineBuffer);
}
if (eoftest == NULL)
{
sysError("unexpected end of file", "while reading method");
break;
}
/* now we have a method */
theMethod = newMethod();
if (parse(theMethod, textBuffer, savetext))
{
selector = basicAt(theMethod, messageInMethod);
basicAtPut(theMethod, methodClassInMethod, classObj);
if (printit)
dspMethod(cp, charPtr(selector));
nameTableInsert(methTable, (int) selector, selector, theMethod);
}
else
{
/* get rid of unwanted method */
incr(theMethod);
decr(theMethod);
givepause();
}
}
while (lineBuffer[0] != ']');
}
