Boolean
SCDynamicStoreRemoveWatchedKey(SCDynamicStoreRef store, CFStringRef key, Boolean isRegex)
{
SCDynamicStorePrivateRef storePrivate = (SCDynamicStorePrivateRef)store;
kern_return_t status;
CFDataRef utfKey; /* serialized key */
xmlData_t myKeyRef;
CFIndex myKeyLen;
int sc_status;
if (store == NULL) {
/* sorry, you must provide a session */
_SCErrorSet(kSCStatusNoStoreSession);
return FALSE;
}
if (storePrivate->server == MACH_PORT_NULL) {
/* sorry, you must have an open session to play */
_SCErrorSet(kSCStatusNoStoreServer);
return FALSE;
}
/* serialize the key */
if (!_SCSerializeString(key, &utfKey, (void **)&myKeyRef, &myKeyLen)) {
_SCErrorSet(kSCStatusFailed);
return FALSE;
}
retry :
/* send the key to the server */
status = notifyremove(storePrivate->server,
myKeyRef,
myKeyLen,
isRegex,
(int *)&sc_status);
if (__SCDynamicStoreCheckRetryAndHandleError(store,
status,
&sc_status,
"SCDynamicStoreRemoveWatchedKey notifyremove()")) {
goto retry;
}
/* clean up */
CFRelease(utfKey);
if (sc_status != kSCStatusOK) {
_SCErrorSet(sc_status);
return FALSE;
}
if (isRegex) {
removeKey(storePrivate->patterns, key);
} else {
removeKey(storePrivate->keys, key);
}
return TRUE;
}
int main (int argc, const char * argv[]) {
const char* filename;
struct hashMap *hashTable;
int tableSize = 10;
clock_t timer;
FILE *fileptr;
/*
this part is using command line arguments, you can use them if you wish
but it is not required. DO NOT remove this code though, we will use it for
testing your program.
if you wish not to use command line arguments manually type in your
filename and path in the else case.
*/
if(argc == 2)
filename = argv[1];
else
filename = "input2.txt"; /*specify your input text file here*/
printf("opening file: %s\n", filename);
timer = clock();
hashTable = createMap(tableSize);
/*... concordance code goes here ...*/
FILE *ifp;
char *mode = "r";
char *word, key;
ifp = fopen(filename, mode);
assert(ifp);
while((word = getWord(ifp)) != NULL){
if(word)
insertMap(hashTable, word, 1);
}
fclose(ifp);
/*... concordance code ends here ...*/
printMap(hashTable);
timer = clock() - timer;
printf("\nconcordance ran in %f seconds\n", (float)timer / (float)CLOCKS_PER_SEC);
printf("Table emptyBuckets = %d\n", emptyBuckets(hashTable));
printf("Table count = %d\n", size(hashTable));
printf("Table capacity = %d\n", capacity(hashTable));
printf("Table load = %f\n", tableLoad(hashTable));
printf("Deleting keys\n");
removeKey(hashTable, "bitter");
removeKey(hashTable, "me");
removeKey(hashTable, "the");
// printMap(hashTable);
deleteMap(hashTable);
printf("\nDeleted the table\n");
return 0;
}
__private_extern__
int
__SCDynamicStoreRemoveWatchedKey(SCDynamicStoreRef store, CFStringRef key, Boolean isRegex, Boolean internal)
{
int sc_status = kSCStatusOK;
CFNumberRef sessionNum;
SCDynamicStorePrivateRef storePrivate = (SCDynamicStorePrivateRef)store;
if (_configd_trace) {
SCTrace(TRUE, _configd_trace,
CFSTR("%s : %5d : %s : %@\n"),
internal ? "*watch-" : "watch- ",
storePrivate->server,
isRegex ? "pattern" : "key",
key);
}
/*
* remove key from this sessions notifier list after checking that
* it was previously defined.
*/
if (isRegex) {
sc_status = removeKey(storePrivate->patterns, key);
if (sc_status != kSCStatusOK) {
goto done;
}
/* remove this session as a pattern watcher */
sessionNum = CFNumberCreate(NULL, kCFNumberIntType, &storePrivate->server);
patternRemoveSession(key, sessionNum);
CFRelease(sessionNum);
} else {
sc_status = removeKey(storePrivate->keys, key);
if (sc_status != kSCStatusOK) {
goto done;
}
/*
* We are watching a specific key. As such, update the
* store to remove our interest in any changes.
*/
sessionNum = CFNumberCreate(NULL, kCFNumberIntType, &storePrivate->server);
_removeWatcher(sessionNum, key);
CFRelease(sessionNum);
}
done :
return sc_status;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
mainWidget = new QWidget();
mainLayout = new QVBoxLayout();
horizLayout = new QHBoxLayout();
insertButton = new QPushButton("Insert Value");
deleteKeyButton = new QPushButton("Delete Key");
deleteKeyButton->setVisible(false);
sortButton = new QPushButton("Sort Values");
sortButton->setVisible(false);
sortedValues = new QLabel();
sortedValues->setVisible(false);
sortedValues->setAlignment(Qt::AlignBottom | Qt::AlignCenter);
searchButton = new QPushButton("Search!");
searchButton->setVisible(false);
found = false;
foundVal = 0;
valuesSpinBox = new QSpinBox(this);
valuesSpinBox->setMaximum(999);
valuesSpinBox->setMinimum(-999);
valuesSpinBox->setValue(42);
QFont f;
f.setPointSize(17);
f.setBold(true);
titleLabel = new QLabel("Jasper and Samuel David's\n Super-Cool Cartesian Tree Thingy");
titleLabel->setAlignment(Qt::AlignTop | Qt::AlignCenter);
titleLabel->setFont(f);
horizLayout->addWidget(insertButton);
horizLayout->addWidget(valuesSpinBox);
horizLayout->setAlignment(Qt::AlignTop | Qt::AlignCenter);
horizLayout->addWidget(searchButton);
horizLayout->addWidget(deleteKeyButton);
mainLayout->setAlignment(Qt::AlignTop | Qt::AlignCenter);
mainLayout->addWidget(titleLabel);
mainLayout->addLayout(horizLayout);
mainLayout->addWidget(sortButton);
mainWidget->setLayout(mainLayout);
setCentralWidget(mainWidget);
connect(insertButton,SIGNAL(clicked()),this,SLOT(insert()));
connect(deleteKeyButton, SIGNAL(clicked()), this, SLOT(removeKey()));
connect(sortButton, SIGNAL(clicked()), this, SLOT(sortem()));
connect(searchButton, SIGNAL(clicked()), this, SLOT(searchVal()));
treeWidget = new QWidget();
srand (time(NULL));
}
void remProperty(Tree t, Tree key)
{
CTree* pl = t->attribut();
if(pl)
t->attribut(removeKey(pl, key));
}
/*
insert the following values into a hashLink, you must create this hashLink but
only after you confirm that this key does not already exist in the table. For example, you
cannot have two hashLinks for the word "taco".
if a hashLink already exists in the table for the key provided you should
replace that hashLink--this requires freeing up the old memory pointed by hashLink->value
and then pointing hashLink->value to value v.
also, you must monitor the load factor and resize when the load factor is greater than
or equal LOAD_FACTOR_THRESHOLD (defined in hashMap.h).
*/
void insertMap (struct hashMap * ht, KeyType k, ValueType v){
int hashIndex;
struct hashLink * newHashLink = (struct hashLink *) malloc(sizeof(struct hashLink));
char * newKeyType = (char *) malloc(strlen(k) + 1); //Allocate memory for new char string
/* Create hash index using one of two hashing function supplied */
if(HASHING_FUNCTION == 1)
hashIndex = stringHash1(k) % ht->tableSize;
else
hashIndex = stringHash2(k) % ht->tableSize;
/* Ensure hashIndex is positive */
if(hashIndex < 0)
hashIndex += ht->tableSize;
assert(newHashLink);
/* Remove duplicate keys so new key replaces old key */
if(containsKey(ht, k))
removeKey(ht, k);
/* Initialize new hashLink and add to appropriate hash index */
strcpy(newKeyType, k); //copy string stream into allocated memory reserved for this hashLink
newHashLink->key = newKeyType;
newHashLink->value = v;
newHashLink->next = ht->table[hashIndex];
ht->table[hashIndex] = newHashLink;
ht->count++;
/* Test table load and resize if necessary */
if(tableLoad(ht) >= LOAD_FACTOR_THRESHOLD)
_setTableSize(ht, ht->tableSize * 2);
}
static Tree removeKey (Tree pl, Tree key)
{
if (isNil(pl)) return nil;
if (left(hd(pl)) == key) return tl(pl);
if (isBefore(left(hd(pl)),key)) return cons (hd(pl), removeKey(tl(pl), key));
return pl;
}
// remove
struct trie *removeKey(struct trie *root, char key[], int depth)
{
if(!root) return NULL;
if(depth == strlen(key))
{
if(root->leaf) root->leaf = false;
if(isEmpty(root))
{
free(root);
root = NULL;
}
return root;
}
int index = tolower(key[depth]) - 'a';
root->children[index] = removeKey(root->children[index], key, depth+1);
if(isEmpty(root) && !root->leaf)
{
free(root);
root = NULL;
}
return root;
}
void MainWindow2::makeTimeLineConnections()
{
connect(m_pTimeLine, SIGNAL(endplayClick()), editor, SLOT(endPlay()));
connect(m_pTimeLine, SIGNAL(startplayClick()), editor, SLOT(startPlay()));
connect(m_pTimeLine, SIGNAL(duplicateKeyClick()), editor, SLOT(duplicateKey()));
connect(m_pTimeLine, SIGNAL(modification()), editor, SLOT(modification()));
connect(m_pTimeLine, SIGNAL(addKeyClick()), editor, SLOT(addKey()));
connect(m_pTimeLine, SIGNAL(removeKeyClick()), editor, SLOT(removeKey()));
connect(m_pTimeLine, SIGNAL(newBitmapLayer()), editor, SLOT(newBitmapLayer()));
connect(m_pTimeLine, SIGNAL(newVectorLayer()), editor, SLOT(newVectorLayer()));
connect(m_pTimeLine, SIGNAL(newSoundLayer()), editor, SLOT(newSoundLayer()));
connect(m_pTimeLine, SIGNAL(newCameraLayer()), editor, SLOT(newCameraLayer()));
connect(m_pTimeLine, SIGNAL(deleteCurrentLayer()), editor, SLOT(deleteCurrentLayer()));
connect(m_pTimeLine, SIGNAL(playClick()), editor, SLOT(play()));
connect(m_pTimeLine, SIGNAL(loopClick(bool)), editor, SLOT(setLoop(bool)));
connect(m_pTimeLine, SIGNAL(soundClick()), editor, SLOT(setSound()));
connect(m_pTimeLine, SIGNAL(fpsClick(int)), editor, SLOT(changeFps(int)));
connect(editor, SIGNAL(toggleLoop(bool)), m_pTimeLine, SIGNAL(toggleLoop(bool)));
connect(m_pTimeLine, SIGNAL(loopClick(bool)), editor, SIGNAL(loopToggled(bool)));
m_pTimeLine->setFocusPolicy(Qt::NoFocus);
}
KeyWidget::KeyWidget( QWidget *parent, const char *name )
: QWidget( parent, name )
{
QGridLayout *layout = new QGridLayout( this, 4, 2, KDialog::marginHint(),
KDialog::spacingHint() );
QLabel *label = new QLabel( i18n( "Keys:" ), this );
layout->addWidget( label, 0, 0 );
mKeyCombo = new KComboBox( this );
layout->addWidget( mKeyCombo, 0, 1 );
mAddButton = new QPushButton( i18n( "Add..." ), this );
layout->addMultiCellWidget( mAddButton, 1, 1, 0, 1 );
mRemoveButton = new QPushButton( i18n( "Remove" ), this );
mRemoveButton->setEnabled( false );
layout->addMultiCellWidget( mRemoveButton, 2, 2, 0, 1 );
mExportButton = new QPushButton( i18n( "Export..." ), this );
mExportButton->setEnabled( false );
layout->addMultiCellWidget( mExportButton, 3, 3, 0, 1 );
connect( mAddButton, SIGNAL( clicked() ), SLOT( addKey() ) );
connect( mRemoveButton, SIGNAL( clicked() ), SLOT( removeKey() ) );
connect( mExportButton, SIGNAL( clicked() ), SLOT( exportKey() ) );
}
/*
insert the following values into a hashLink, you must create this hashLink but
only after you confirm that this key does not already exist in the table. For example, you
cannot have two hashLinks for the word "taco".
if a hashLink already exists in the table for the key provided you should
replace that hashLink--this requires freeing up the old memory pointed by hashLink->value
and then pointing hashLink->value to value v.
also, you must monitor the load factor and resize when the load factor is greater than
or equal LOAD_FACTOR_THRESHOLD (defined in hashMap.h).
*/
void insertMap(struct hashMap * ht, KeyType k, ValueType v)
{
int hashIndex;
if (HASHING_FUNCTION == 1)
{
hashIndex = stringHash1(k) % ht->tableSize; //reduce the index
}
else if (HASHING_FUNCTION == 2)
{
hashIndex = stringHash2(k) % ht->tableSize;
}
if (hashIndex < 0) //check to make sure indez is not negative
{
hashIndex = hashIndex + ht->tableSize;
}
//Check if hashLink already exists and delete if it does not
if (containsKey(ht, k))
{
removeKey(ht, k);
}
//add a new link in
hashLink *newLink = malloc(sizeof(struct hashLink));
assert(newLink != NULL);
newLink->key = k;
newLink->value = v;
newLink->next = NULL;
if (ht->table[hashIndex] != NULL)
{
hashLink *temp = ht->table[hashIndex];
//find the end of chain
while (temp->next != NULL)
{
temp = temp->next;
}
temp->next = newLink;
}
else
{
ht->table[hashIndex] = newLink;
}
ht->count++;
// monitor the load factor
if (tableLoad(ht) >= LOAD_FACTOR_THRESHOLD)
{
_setTableSize(ht, ht->tableSize * 2);
}
}
void createRestoreOptions(Volume* volume, const char *optionsPlist, int SystemPartitionSize, int UpdateBaseband) {
AbstractFile* plistFile;
Dictionary* info;
char* plist;
HFSPlusCatalogRecord* record;
info = NULL;
record = getRecordFromPath(optionsPlist, volume, NULL, NULL);
if(record != NULL && record->recordType == kHFSPlusFileRecord) {
HFSPlusCatalogFile* file = (HFSPlusCatalogFile*)record;
size_t bufferSize = 512;
plist = malloc(bufferSize);
plistFile = createAbstractFileFromMemory((void**)&plist, bufferSize);
if (plistFile) {
char zero = 0;
writeToFile(file, plistFile, volume);
plistFile->write(plistFile, &zero, sizeof(zero));
plistFile->close(plistFile);
info = createRoot(plist);
removeKey(info, "CreateFilesystemPartitions");
removeKey(info, "SystemPartitionSize");
removeKey(info, "UpdateBaseband");
removeKey(info, "MinimumSystemPartition");
addIntegerToDictionary(info, "MinimumSystemPartition", SystemPartitionSize);
XLOG(0, "got %s from ramdisk\n", optionsPlist);
}
free(plist);
}
XLOG(0, "start create restore options\n");
if (!info) info = createRoot("<dict></dict>");
addBoolToDictionary(info, "CreateFilesystemPartitions", TRUE);
addIntegerToDictionary(info, "SystemPartitionSize", SystemPartitionSize);
addBoolToDictionary(info, "UpdateBaseband", UpdateBaseband);
plist = getXmlFromRoot(info);
releaseDictionary(info);
XLOG(0, "%s", plist);
plistFile = createAbstractFileFromMemory((void**)&plist, sizeof(char) * strlen(plist));
add_hfs(volume, plistFile, optionsPlist);
free(plist);
}
/* InputPrefsPanel::onListKeyDown
* Called when a key is pressed in the keybind list
*******************************************************************/
void InputPrefsPanel::onListKeyDown(wxKeyEvent& e)
{
if (e.GetKeyCode() == WXK_DELETE)
removeKey(list_binds->GetSelection());
else if (e.GetKeyCode() == WXK_INSERT)
addKey();
else
e.Skip();
}
static Tree removeKey(Tree pl, Tree key)
{
if(isNil(pl))
return nil;
if(left(hd(pl)) == key)
return tl(pl);
/* left(hd(pl)) != key */ return cons(hd(pl), removeKey(tl(pl), key));
}
int BTreeRemove(BTree * tree, int key) {
int retorno;
retorno = removeKey(key, tree->root);
if (retorno == UNDERFLOW) { /* Root Underflow! */
rootUnderFlow();
}
return retorno;
}
bool LLWLDayCycle::changeKeyTime(F32 oldTime, F32 newTime)
{
// just remove and add back
std::string name = mTimeMap[oldTime];
bool stat = removeKey(oldTime);
if(stat == false)
{
return stat;
}
return addKey(newTime, name);
}
ArrayData *MapVariant::remove(CVarRef k, bool copy, int64 prehash /* = -1 */) {
int index = getIndex(k, prehash);
if (index >= 0) {
if (size() == 1) {
return StaticEmptyArray::Get();
}
if (copy) {
return NEW(MapVariant)(this, index);
}
m_elems[index]->release();
m_elems.remove(index);
removeKey(k, index, prehash);
if (index < m_pos) m_pos--;
}
return NULL;
}
int insertKey(char *key,int key_len,char *val,int val_len,int ttl)
{
long len_t=val_len;
int count=(val_len/BLOCK_SIZE)+1;
if(global_head->freeBlockNum<count||global_head->freeNodeNum==0)
return -1;
int already=findKey(key,key_len);
if(already!=-1)
removeKey(already);
int index=findFreeNode();
if(index==-1)
return -1;
int i;
int sum=0;
for (i = 0; i < count; ++i)
{
int t=findFreeBlock();
long ttt=len_t;
if(t==-1)
return -1;
(global_head->p[index])->block[i]=t;
if(ttt>BLOCK_SIZE)
ttt=BLOCK_SIZE;
memcpy(AT(t),val+sum,ttt);
//long tt=snprintf(AT(t),ttt+1,"%s",val+sum);
sum+=ttt;
len_t-=ttt;
setBlockUsed(t);
}
(global_head->p[index])->block[i]=-1;
global_head->freeBlockNum-=count;
global_head->usedBlockNum+=count;
global_head->freeNodeNum--;
global_head->usedNodeNum++;
global_head->p[index]->size=val_len;
global_head->p[index]->is_free=0;
global_head->p[index]->ttl=time(0)+ttl;
snprintf(global_head->p[index]->key,key_len+1,"%s",key);
global_head->p[index]->key_len=key_len;
for (i = 0; i < count; ++i)
{
setBlockUsed((global_head->p[index])->block[i]);
}
return 1;
}
int findFreeNode()
{
int i;
for (i = 0; i < KEY_NUM; ++i)
{
int check=(global_head->p[i])->is_free;
if(check)
return i;
else if (global_head->p[i]->ttl<time(0))
{
removeKey(i);
return i;
}
}
return -1;
}
/*
insert the following values into a hashLink, you must create this hashLink but
only after you confirm that this key does not already exist in the table. For example, you
cannot have two hashLinks for the word "taco".
if a hashLink already exists in the table for the key provided you should
replace that hashLink--this requires freeing up the old memory pointed by hashLink->value
and then pointing hashLink->value to value v.
also, you must monitor the load factor and resize when the load factor is greater than
or equal LOAD_FACTOR_THRESHOLD (defined in hashMap.h).
*/
void insertMap (struct hashMap * ht, KeyType k, ValueType v)
{
int index;
if(tableLoad(ht) >= LOAD_FACTOR_THRESHOLD)
{
_setTableSize(ht, (2 * ht -> tableSize));
}
struct hashLink *link = malloc(sizeof(struct hashLink));
index = stringHash2(k) % ht -> tableSize;
if(index < 0)
{
index += ht -> tableSize;
}
assert(link);
link -> next = 0;
link -> key = k;
link -> value = v;
if(containsKey(ht, k))
{
removeKey(ht, k);
}
if(!ht -> table[index])
{
ht -> table[index] = link;
}
else
{
struct hashLink *current = ht -> table[index];
while(current -> next)
{
current = current -> next;
}
current -> next = link;
}
ht -> count++;
}
ArrayData *MapVariant::remove(CVarRef k, bool copy, int64 prehash /* = -1 */) {
int index = getIndex(k, prehash);
if (index >= 0) {
if (copy) {
MapVariant * ret = NEW(MapVariant)(this);
ret->remove(k, false);
return ret;
}
m_elems[index]->release();
m_elems.remove(index);
removeKey(k, index, prehash);
if (index < m_pos) m_pos--;
}
if (copy) {
return NEW(MapVariant)(this);
}
return NULL;
}
void EditorBase::handleInput(InputState p_state, const CL_InputEvent& p_event)
{
m_alt = p_event.alt;
m_ctrl = p_event.ctrl;
m_shift = p_event.shift;
switch (p_state)
{
case Pressed:
addKey(p_event.id);
break;
case Released:
removeKey(p_event.id);
break;
}
onHandleInput();
}
int findKey(char *key,int key_len)
{
int i;
for(i=0;i<KEY_NUM;i++)
{
if(global_head->p[i]->is_free)
continue;
if(!memcmp(global_head->p[i]->key,key,key_len)&&(global_head->p[i]->key_len==key_len))
{
if(global_head->p[i]->ttl<time(0)){
removeKey(i);
return -1;
}
return i;
}
}
return -1;
}
void initShell() {
//clearScreen();
printf("-- WELCOME THE SHELL --\n\n >>");
setTimeZone(-3);
setConsoleSize();
shellBuffer = sbuffer[0];
cleanBuffer();
while(1) {
int c = getc();
if (c != EOF) {
if (c == '\n') {
execute();
} else if (c == '\b') {
removeKey();
} else {
addToShellBuffer(c);
putc(c);
}
}
}
}
int main(int argc, char* argv[]) {
init_libxpwn();
Dictionary* info;
Dictionary* firmwarePatches;
Dictionary* patchDict;
ArrayValue* patchArray;
void* buffer;
StringValue* actionValue;
StringValue* pathValue;
StringValue* fileValue;
StringValue* patchValue;
char* patchPath;
char* rootFSPathInIPSW;
io_func* rootFS;
Volume* rootVolume;
size_t rootSize;
size_t preferredRootSize = 0;
size_t minimumRootSize = 0;
char* ramdiskFSPathInIPSW;
unsigned int ramdiskKey[16];
unsigned int ramdiskIV[16];
unsigned int* pRamdiskKey = NULL;
unsigned int* pRamdiskIV = NULL;
io_func* ramdiskFS;
Volume* ramdiskVolume;
char* updateRamdiskFSPathInIPSW = NULL;
int i;
OutputState* outputState;
char* bundlePath;
char* bundleRoot = "FirmwareBundles/";
int mergePaths;
char* outputIPSW;
void* imageBuffer;
size_t imageSize;
AbstractFile* bootloader39 = NULL;
AbstractFile* bootloader46 = NULL;
AbstractFile* applelogo = NULL;
AbstractFile* recoverymode = NULL;
char noWipe = FALSE;
char unlockBaseband = FALSE;
char selfDestruct = FALSE;
char use39 = FALSE;
char use46 = FALSE;
char doBootNeuter = FALSE;
char updateBB = FALSE;
char useMemory = FALSE;
unsigned int key[16];
unsigned int iv[16];
unsigned int* pKey = NULL;
unsigned int* pIV = NULL;
if(argc < 3) {
XLOG(0, "usage %s <input.ipsw> <target.ipsw> [-b <bootimage.png>] [-r <recoveryimage.png>] [-s <system partition size>] [-memory] [-bbupdate] [-nowipe] [-e \"<action to exclude>\"] [[-unlock] [-use39] [-use46] [-cleanup] -3 <bootloader 3.9 file> -4 <bootloader 4.6 file>] <package1.tar> <package2.tar>...\n", argv[0]);
return 0;
}
outputIPSW = argv[2];
int* toRemove = NULL;
int numToRemove = 0;
for(i = 3; i < argc; i++) {
if(argv[i][0] != '-') {
break;
}
if(strcmp(argv[i], "-memory") == 0) {
useMemory = TRUE;
continue;
}
if(strcmp(argv[i], "-s") == 0) {
int size;
sscanf(argv[i + 1], "%d", &size);
preferredRootSize = size;
i++;
continue;
}
if(strcmp(argv[i], "-nowipe") == 0) {
noWipe = TRUE;
continue;
}
if(strcmp(argv[i], "-bbupdate") == 0) {
updateBB = TRUE;
continue;
}
if(strcmp(argv[i], "-e") == 0) {
numToRemove++;
toRemove = realloc(toRemove, numToRemove * sizeof(int));
toRemove[numToRemove - 1] = i + 1;
i++;
continue;
}
if(strcmp(argv[i], "-unlock") == 0) {
unlockBaseband = TRUE;
continue;
}
if(strcmp(argv[i], "-cleanup") == 0) {
selfDestruct = TRUE;
continue;
}
if(strcmp(argv[i], "-use39") == 0) {
if(use46) {
XLOG(0, "error: select only one of -use39 and -use46\n");
exit(1);
}
use39 = TRUE;
continue;
}
if(strcmp(argv[i], "-use46") == 0) {
if(use39) {
XLOG(0, "error: select only one of -use39 and -use46\n");
exit(1);
}
use46 = TRUE;
continue;
}
if(strcmp(argv[i], "-b") == 0) {
applelogo = createAbstractFileFromFile(fopen(argv[i + 1], "rb"));
if(!applelogo) {
XLOG(0, "cannot open %s\n", argv[i + 1]);
exit(1);
}
i++;
continue;
}
if(strcmp(argv[i], "-r") == 0) {
recoverymode = createAbstractFileFromFile(fopen(argv[i + 1], "rb"));
if(!recoverymode) {
XLOG(0, "cannot open %s\n", argv[i + 1]);
exit(1);
}
i++;
continue;
}
if(strcmp(argv[i], "-3") == 0) {
bootloader39 = createAbstractFileFromFile(fopen(argv[i + 1], "rb"));
if(!bootloader39) {
XLOG(0, "cannot open %s\n", argv[i + 1]);
exit(1);
}
i++;
continue;
}
if(strcmp(argv[i], "-4") == 0) {
bootloader46 = createAbstractFileFromFile(fopen(argv[i + 1], "rb"));
if(!bootloader46) {
XLOG(0, "cannot open %s\n", argv[i + 1]);
exit(1);
}
i++;
continue;
}
}
mergePaths = i;
if(use39 || use46 || unlockBaseband || selfDestruct || bootloader39 || bootloader46) {
if(!(bootloader39) || !(bootloader46)) {
XLOG(0, "error: you must specify both bootloader files.\n");
exit(1);
} else {
doBootNeuter = TRUE;
}
}
info = parseIPSW2(argv[1], bundleRoot, &bundlePath, &outputState, useMemory);
if(info == NULL) {
XLOG(0, "error: Could not load IPSW\n");
exit(1);
}
firmwarePatches = (Dictionary*)getValueByKey(info, "FilesystemPatches");
int j;
for(j = 0; j < numToRemove; j++) {
removeKey(firmwarePatches, argv[toRemove[j]]);
}
free(toRemove);
firmwarePatches = (Dictionary*)getValueByKey(info, "FirmwarePatches");
patchDict = (Dictionary*) firmwarePatches->values;
while(patchDict != NULL) {
fileValue = (StringValue*) getValueByKey(patchDict, "File");
StringValue* keyValue = (StringValue*) getValueByKey(patchDict, "Key");
StringValue* ivValue = (StringValue*) getValueByKey(patchDict, "IV");
pKey = NULL;
pIV = NULL;
if(keyValue) {
sscanf(keyValue->value, "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
&key[0], &key[1], &key[2], &key[3], &key[4], &key[5], &key[6], &key[7], &key[8],
&key[9], &key[10], &key[11], &key[12], &key[13], &key[14], &key[15]);
pKey = key;
}
if(ivValue) {
sscanf(ivValue->value, "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
&iv[0], &iv[1], &iv[2], &iv[3], &iv[4], &iv[5], &iv[6], &iv[7], &iv[8],
&iv[9], &iv[10], &iv[11], &iv[12], &iv[13], &iv[14], &iv[15]);
pIV = iv;
}
if(strcmp(patchDict->dValue.key, "Restore Ramdisk") == 0) {
ramdiskFSPathInIPSW = fileValue->value;
if(pKey) {
memcpy(ramdiskKey, key, sizeof(key));
memcpy(ramdiskIV, iv, sizeof(iv));
pRamdiskKey = ramdiskKey;
pRamdiskIV = ramdiskIV;
} else {
pRamdiskKey = NULL;
pRamdiskIV = NULL;
}
}
if(strcmp(patchDict->dValue.key, "Update Ramdisk") == 0) {
updateRamdiskFSPathInIPSW = fileValue->value;
}
patchValue = (StringValue*) getValueByKey(patchDict, "Patch2");
if(patchValue) {
if(noWipe) {
XLOG(0, "%s: ", patchDict->dValue.key);
fflush(stdout);
doPatch(patchValue, fileValue, bundlePath, &outputState, pKey, pIV, useMemory);
patchDict = (Dictionary*) patchDict->dValue.next;
continue; /* skip over the normal Patch */
}
}
patchValue = (StringValue*) getValueByKey(patchDict, "Patch");
if(patchValue) {
XLOG(0, "%s: ", patchDict->dValue.key);
fflush(stdout);
doPatch(patchValue, fileValue, bundlePath, &outputState, pKey, pIV, useMemory);
}
if(strcmp(patchDict->dValue.key, "AppleLogo") == 0 && applelogo) {
XLOG(0, "replacing %s\n", fileValue->value);
fflush(stdout);
ASSERT((imageBuffer = replaceBootImage(getFileFromOutputState(&outputState, fileValue->value), pKey, pIV, applelogo, &imageSize)) != NULL, "failed to use new image");
addToOutput(&outputState, fileValue->value, imageBuffer, imageSize);
}
if(strcmp(patchDict->dValue.key, "RecoveryMode") == 0 && recoverymode) {
XLOG(0, "replacing %s\n", fileValue->value);
fflush(stdout);
ASSERT((imageBuffer = replaceBootImage(getFileFromOutputState(&outputState, fileValue->value), pKey, pIV, recoverymode, &imageSize)) != NULL, "failed to use new image");
addToOutput(&outputState, fileValue->value, imageBuffer, imageSize);
}
patchDict = (Dictionary*) patchDict->dValue.next;
}
fileValue = (StringValue*) getValueByKey(info, "RootFilesystem");
rootFSPathInIPSW = fileValue->value;
size_t defaultRootSize = ((IntegerValue*) getValueByKey(info, "RootFilesystemSize"))->value;
minimumRootSize = defaultRootSize * 1000 * 1000;
minimumRootSize -= minimumRootSize % 512;
if(preferredRootSize == 0) {
preferredRootSize = defaultRootSize;
}
rootSize = preferredRootSize * 1000 * 1000;
rootSize -= rootSize % 512;
if(useMemory) {
buffer = malloc(rootSize);
} else {
buffer = NULL;
}
if(buffer == NULL) {
XLOG(2, "using filesystem backed temporary storage\n");
}
extractDmg(
createAbstractFileFromFileVault(getFileFromOutputState(&outputState, rootFSPathInIPSW), ((StringValue*)getValueByKey(info, "RootFilesystemKey"))->value),
openRoot((void**)&buffer, &rootSize), -1);
rootFS = IOFuncFromAbstractFile(openRoot((void**)&buffer, &rootSize));
rootVolume = openVolume(rootFS);
XLOG(0, "Growing root to minimum: %ld\n", (long) defaultRootSize);
fflush(stdout);
grow_hfs(rootVolume, minimumRootSize);
if(rootSize > minimumRootSize) {
XLOG(0, "Growing root: %ld\n", (long) preferredRootSize);
fflush(stdout);
grow_hfs(rootVolume, rootSize);
}
firmwarePatches = (Dictionary*)getValueByKey(info, "FilesystemPatches");
patchArray = (ArrayValue*) firmwarePatches->values;
while(patchArray != NULL) {
for(i = 0; i < patchArray->size; i++) {
patchDict = (Dictionary*) patchArray->values[i];
fileValue = (StringValue*) getValueByKey(patchDict, "File");
actionValue = (StringValue*) getValueByKey(patchDict, "Action");
if(strcmp(actionValue->value, "ReplaceKernel") == 0) {
pathValue = (StringValue*) getValueByKey(patchDict, "Path");
XLOG(0, "replacing kernel... %s -> %s\n", fileValue->value, pathValue->value);
fflush(stdout);
add_hfs(rootVolume, getFileFromOutputState(&outputState, fileValue->value), pathValue->value);
}
if(strcmp(actionValue->value, "Patch") == 0) {
patchValue = (StringValue*) getValueByKey(patchDict, "Patch");
patchPath = (char*) malloc(sizeof(char) * (strlen(bundlePath) + strlen(patchValue->value) + 2));
strcpy(patchPath, bundlePath);
strcat(patchPath, "/");
strcat(patchPath, patchValue->value);
XLOG(0, "patching %s (%s)... ", fileValue->value, patchPath);
doPatchInPlace(rootVolume, fileValue->value, patchPath);
free(patchPath);
}
}
patchArray = (ArrayValue*) patchArray->dValue.next;
}
for(; mergePaths < argc; mergePaths++) {
XLOG(0, "merging %s\n", argv[mergePaths]);
AbstractFile* tarFile = createAbstractFileFromFile(fopen(argv[mergePaths], "rb"));
if(tarFile == NULL) {
XLOG(1, "cannot find %s, make sure your slashes are in the right direction\n", argv[mergePaths]);
releaseOutput(&outputState);
closeRoot(buffer);
exit(0);
}
hfs_untar(rootVolume, tarFile);
tarFile->close(tarFile);
}
if(pRamdiskKey) {
ramdiskFS = IOFuncFromAbstractFile(openAbstractFile2(getFileFromOutputStateForOverwrite(&outputState, ramdiskFSPathInIPSW), pRamdiskKey, pRamdiskIV));
} else {
XLOG(0, "unencrypted ramdisk\n");
ramdiskFS = IOFuncFromAbstractFile(openAbstractFile(getFileFromOutputStateForOverwrite(&outputState, ramdiskFSPathInIPSW)));
}
ramdiskVolume = openVolume(ramdiskFS);
XLOG(0, "growing ramdisk: %d -> %d\n", ramdiskVolume->volumeHeader->totalBlocks * ramdiskVolume->volumeHeader->blockSize, (ramdiskVolume->volumeHeader->totalBlocks + 4) * ramdiskVolume->volumeHeader->blockSize);
grow_hfs(ramdiskVolume, (ramdiskVolume->volumeHeader->totalBlocks + 4) * ramdiskVolume->volumeHeader->blockSize);
if(doBootNeuter) {
firmwarePatches = (Dictionary*)getValueByKey(info, "BasebandPatches");
if(firmwarePatches != NULL) {
patchDict = (Dictionary*) firmwarePatches->values;
while(patchDict != NULL) {
pathValue = (StringValue*) getValueByKey(patchDict, "Path");
fileValue = (StringValue*) getValueByKey(patchDict, "File");
if(fileValue) {
XLOG(0, "copying %s -> %s... ", fileValue->value, pathValue->value);
fflush(stdout);
if(copyAcrossVolumes(ramdiskVolume, rootVolume, fileValue->value, pathValue->value)) {
patchValue = (StringValue*) getValueByKey(patchDict, "Patch");
if(patchValue) {
patchPath = malloc(sizeof(char) * (strlen(bundlePath) + strlen(patchValue->value) + 2));
strcpy(patchPath, bundlePath);
strcat(patchPath, "/");
strcat(patchPath, patchValue->value);
XLOG(0, "patching %s (%s)... ", pathValue->value, patchPath);
fflush(stdout);
doPatchInPlace(rootVolume, pathValue->value, patchPath);
free(patchPath);
}
}
}
if(strcmp(patchDict->dValue.key, "Bootloader 3.9") == 0 && bootloader39 != NULL) {
add_hfs(rootVolume, bootloader39, pathValue->value);
}
if(strcmp(patchDict->dValue.key, "Bootloader 4.6") == 0 && bootloader46 != NULL) {
add_hfs(rootVolume, bootloader46, pathValue->value);
}
patchDict = (Dictionary*) patchDict->dValue.next;
}
}
fixupBootNeuterArgs(rootVolume, unlockBaseband, selfDestruct, use39, use46);
}
createRestoreOptions(ramdiskVolume, preferredRootSize, updateBB);
closeVolume(ramdiskVolume);
CLOSE(ramdiskFS);
if(updateRamdiskFSPathInIPSW)
removeFileFromOutputState(&outputState, updateRamdiskFSPathInIPSW);
closeVolume(rootVolume);
CLOSE(rootFS);
buildDmg(openRoot((void**)&buffer, &rootSize), getFileFromOutputStateForReplace(&outputState, rootFSPathInIPSW));
closeRoot(buffer);
writeOutput(&outputState, outputIPSW);
releaseDictionary(info);
free(bundlePath);
return 0;
}
/* InputPrefsPanel::onBtnRemoveKey
* Called when the 'Remove Key' button is clicked
*******************************************************************/
void InputPrefsPanel::onBtnRemoveKey(wxCommandEvent& e)
{
removeKey(list_binds->GetSelection());
}
int main (int argc, const char * argv[]) {
const char* filename;
struct hashMap *hashTable;
int tableSize = 10;
clock_t timer;
FILE *fileptr;
/*
this part is using command line arguments, you can use them if you wish
but it is not required. DO NOT remove this code though, we will use it for
testing your program.
if you wish not to use command line arguments manually type in your
filename and path in the else case.
*/
if(argc == 2)
filename = argv[1];
else
filename = "input1.txt"; /*specify your input text file here*/
printf("opening file: %s\n", filename);
timer = clock();
hashTable = createMap(tableSize);
/*... concordance code goes here ...*/
fileptr = fopen(filename, "r");
if (fileptr != NULL) {
int *val, *x;
char *word;
while ((word = getWord(fileptr))) {
if (containsKey(hashTable, word)) {
val = (int *) atMap(hashTable, word);
(*val) ++;
free(word);
} else {
x = malloc(sizeof(int));
*x = 1;
insertMap(hashTable, word, x);
}
}
fclose(fileptr);
} else printf("Error opening file.\n");
/*... concordance code ends here ...*/
printMap(hashTable, keyPrint, valPrint);
timer = clock() - timer;
printf("\nconcordance ran in %f seconds\n", (float)timer / (float)CLOCKS_PER_SEC);
printf("Table emptyBuckets = %d\n", emptyBuckets(hashTable));
printf("Table count = %d\n", size(hashTable));
printf("Table capacity = %d\n", capacity(hashTable));
printf("Table load = %f\n", tableLoad(hashTable));
printf("Deleting keys\n");
removeKey(hashTable, "and");
removeKey(hashTable, "me");
removeKey(hashTable, "the");
printMap(hashTable, keyPrint, valPrint);
printKeyValues(hashTable, keyPrint, valPrint);
/* Test out the iterator */
#ifdef ITERATOR_IN
struct mapItr *myItr;
myItr = createMapIterator(hashTable);
KeyType key;
/* Free up our keys and values using our iterator!! Also printing them as we go along */
while(hasNextMap(myItr))
{
key = nextMap(myItr);
int *value = atMap(hashTable,key);
printf("Freeing ...Key = %s, value = %d \n", key, *value);
free(value); /* To match the malloc above*/
free(key);
}
#endif
deleteMap(hashTable);
printf("\nDeleted the table\n");
return 0;
}
int main(int argc, const char * argv[]) {
const char* filename;
struct hashMap *hashTable;
int tableSize = 63;
clock_t timer;
FILE *fileptr;
/*
this part is using command line arguments, you can use them if you wish
but it is not required. DO NOT remove this code though, we will use it for
testing your program.
if you wish not to use command line arguments manually type in your
filename and path in the else case.
*/
if (argc == 2)
filename = argv[1];
else
filename = "input1.txt"; /*specify your input text file here*/
printf("opening file: %s\n", filename);
timer = clock();
hashTable = createMap(tableSize);
/*... concordance code goes here ...*/
fileptr = fopen(filename, "r"); //open the given file
if (fileptr != NULL) //if the file was opened sucessfully...
{
/* while the end of the file has not yet been reached, get the next word in the file,
* adding it to the hash table or updating the number of times it has appeared in the document.
* the alogrithm is case sensitive
*/
while (!feof(fileptr))
{
char* word = getWord(fileptr);
if (word != NULL)
{
int* wordCount = atMap(hashTable, word);
if (wordCount == NULL)
{
insertMap(hashTable, word, 1);
}
else
{
insertMap(hashTable, word, (*wordCount) + 1);
}
}
}
}
else
{
fprintf(stderr, "Could not open file."); //print an error message if the file could not be opened
}
fclose(fileptr); //close the file
//print each word in the document along with the number of times it has appeared.
for (int i = 0; i < hashTable->tableSize; i++)
{
hashLink* curLink = hashTable->table[i];
while (curLink != NULL)
{
printf("%s: %d\n", curLink->key, curLink->value);
curLink = curLink->next;
}
}
/*... concordance code ends here ...*/
printMap(hashTable);
timer = clock() - timer;
printf("\nconcordance ran in %f seconds\n", (float)timer / (float)CLOCKS_PER_SEC);
printf("Table emptyBuckets = %d\n", emptyBuckets(hashTable));
printf("Table count = %d\n", size(hashTable));
printf("Table capacity = %d\n", capacity(hashTable));
printf("Table load = %f\n", tableLoad(hashTable));
printf("Deleting keys\n");
removeKey(hashTable, "and");
removeKey(hashTable, "me");
removeKey(hashTable, "the");
printMap(hashTable);
deleteMap(hashTable);
printf("\nDeleted the table\n");
return 0;
}
void MainWindow2::createMenus()
{
// ---------- File Menu -------------
connect(ui->actionNew, SIGNAL(triggered()), this, SLOT(newDocument()));
connect(ui->actionOpen, SIGNAL(triggered()), this, SLOT(openDocument()));
connect(ui->actionSave_as, SIGNAL(triggered()), this, SLOT(saveAsNewDocument()));
connect(ui->actionSave, SIGNAL(triggered()), this, SLOT(saveDocument()));
connect(ui->actionPrint, SIGNAL(triggered()), editor, SLOT(print()));
connect(ui->actionExit, SIGNAL(triggered()), this, SLOT(close()));
/// --- Export Menu ---
connect(ui->actionExport_X_sheet , SIGNAL(triggered()), editor, SLOT(exportX()));
connect(ui->actionExport_Image_Sequence, SIGNAL(triggered()), editor, SLOT(exportSeq()));
connect(ui->actionExport_Image, SIGNAL(triggered()), editor, SLOT(exportImage()));
connect(ui->actionExport_Movie, SIGNAL(triggered()), editor, SLOT(exportMov()));
//exportFlashAct = new QAction(tr("&Flash/SWF..."), this);
//exportFlashAct->setShortcut(tr("Ctrl+Alt+F"));
//connect(exportFlashAct, SIGNAL(triggered()), editor, SLOT(exportFlash()));
connect(ui->actionExport_Palette, SIGNAL(triggered()), this, SLOT(exportPalette()));
/// --- Import Menu ---
connect(ui->actionExport_Svg_Image, SIGNAL(triggered()), editor, SLOT(saveSvg()));
connect(ui->actionImport_Image, SIGNAL(triggered()), editor, SLOT(importImage()));
connect(ui->actionImport_Image_Sequence, SIGNAL(triggered()), editor, SLOT(importImageSequence()));
connect(ui->actionImport_Movie, SIGNAL(triggered()), editor, SLOT(importMov()));
connect(ui->actionImport_Sound, SIGNAL(triggered()), editor, SLOT(importSound()));
connect(ui->actionImport_Palette, SIGNAL(triggered()), this, SLOT(importPalette()));
/// --- Edit Menu ---
connect(ui->actionUndo, SIGNAL(triggered()), editor, SLOT(undo()));
connect(ui->actionRedo, SIGNAL(triggered()), editor, SLOT(redo()));
connect(ui->actionCut, SIGNAL(triggered()), editor, SLOT(cut()));
connect(ui->actionCopy, SIGNAL(triggered()), editor, SLOT(copy()));
connect(ui->actionPaste, SIGNAL(triggered()), editor, SLOT(paste()));
connect(ui->actionDelete, SIGNAL(triggered()), editor, SLOT(clearCurrentFrame()));
connect(ui->actionCrop, SIGNAL(triggered()), editor, SLOT(crop()));
connect(ui->actionCrop_To_Selection, SIGNAL(triggered()), editor, SLOT(croptoselect()));
connect(ui->actionSelect_All, SIGNAL(triggered()), editor, SIGNAL(selectAll()));
connect(ui->actionDeselect_All, SIGNAL(triggered()), editor, SLOT(deselectAll()));
connect(ui->actionPreference, SIGNAL(triggered()), this, SLOT(showPreferences()));
ui->actionRedo->setEnabled(false);
/// --- Layer Menu ---
connect(ui->actionNew_Bitmap_Layer, SIGNAL(triggered()), editor, SLOT(newBitmapLayer()));
connect(ui->actionNew_Vector_Layer, SIGNAL(triggered()), editor, SLOT(newVectorLayer()));
connect(ui->actionNew_Sound_Layer, SIGNAL(triggered()), editor, SLOT(newSoundLayer()));
connect(ui->actionNew_Camera_Layer, SIGNAL(triggered()), editor, SLOT(newCameraLayer()));
connect(ui->actionDelete_Current_Layer, SIGNAL(triggered()), editor, SLOT(deleteCurrentLayer()));
/// --- View Menu ---
connect(ui->actionZoom_In, SIGNAL(triggered()), editor, SLOT(setzoom()));
connect(ui->actionZoom_Out, SIGNAL(triggered()), editor, SLOT(setzoom1()));
connect(ui->actionRotate_Clockwise, SIGNAL(triggered()), editor, SLOT(rotatecw()));
connect(ui->actionRotate_Anticlosewise, SIGNAL(triggered()), editor, SLOT(rotateacw()));
connect(ui->actionReset_Windows, SIGNAL(triggered()), this, SLOT(dockAllPalettes()));
connect(ui->actionReset_View, SIGNAL(triggered()), editor, SLOT(resetView()));
connect(ui->actionHorizontal_Flip, SIGNAL(triggered()), editor, SLOT(toggleMirror()));
connect(ui->actionVertical_Flip, SIGNAL(triggered()), editor, SLOT(toggleMirrorV()));
ui->actionPreview->setEnabled(false);
//# connect(previewAct, SIGNAL(triggered()), editor, SLOT(getCameraLayer()));//TODO: Preview view
ui->actionGrid->setEnabled(false);
connect(ui->actionGrid, SIGNAL(triggered()), editor, SLOT(gridview())); //TODO: Grid view
connect(ui->actionOnionPrevious, SIGNAL(triggered(bool)), editor, SIGNAL(toggleOnionPrev(bool)));
connect(editor, SIGNAL(onionPrevChanged(bool)), ui->actionOnionPrevious, SLOT(setChecked(bool)));
connect(ui->actionOnionNext, SIGNAL(triggered(bool)), editor, SIGNAL(toggleOnionNext(bool)));
connect(editor, SIGNAL(onionNextChanged(bool)), ui->actionOnionNext, SLOT(setChecked(bool)));
/// --- Animation Menu ---
connect(ui->actionPlay, SIGNAL(triggered()), editor, SLOT(play()));
connect(ui->actionLoop, SIGNAL(triggered(bool)), editor, SLOT(setLoop(bool)));
connect(ui->actionLoop, SIGNAL(toggled(bool)), editor, SIGNAL(toggleLoop(bool))); //TODO: WTF?
connect(editor, SIGNAL(loopToggled(bool)), ui->actionLoop, SLOT(setChecked(bool)));
connect(ui->actionAdd_Frame, SIGNAL(triggered()), editor, SLOT(addKey()));
connect(ui->actionRemove_Frame, SIGNAL(triggered()), editor, SLOT(removeKey()));
connect(ui->actionNext_Frame, SIGNAL(triggered()), editor, SLOT(playNextFrame()));
connect(ui->actionPrevious_Frame, SIGNAL(triggered()), editor, SLOT(playPrevFrame()));
connect(ui->actionNext_Keyframe, SIGNAL(triggered()), editor, SLOT(scrubNextKeyframe()));
connect(ui->actionPrev_Keyframe, SIGNAL(triggered()), editor, SLOT(scrubPreviousKeyframe()));
connect(ui->actionDuplicate_Frame, SIGNAL(triggered()), editor, SLOT(duplicateKey()));
/// --- Tool Menu ---
connect(ui->actionClear, SIGNAL(triggered()), editor, SLOT(clearCurrentFrame()));
connect(ui->actionMove, SIGNAL(triggered()), m_toolSet, SLOT(moveOn()));
connect(ui->actionSelect, SIGNAL(triggered()), m_toolSet, SLOT(selectOn()));
connect(ui->actionBrush, SIGNAL(triggered()), m_toolSet, SLOT(brushOn()));
connect(ui->actionPolyline, SIGNAL(triggered()), m_toolSet, SLOT(polylineOn()));
connect(ui->actionSmudge, SIGNAL(triggered()), m_toolSet, SLOT(smudgeOn()));
connect(ui->actionPen, SIGNAL(triggered()), m_toolSet, SLOT(penOn()));
connect(ui->actionHand, SIGNAL(triggered()), m_toolSet, SLOT(handOn()));
connect(ui->actionPencil, SIGNAL(triggered()), m_toolSet, SLOT(pencilOn()));
connect(ui->actionBucket, SIGNAL(triggered()), m_toolSet, SLOT(bucketOn()));
connect(ui->actionEyedropper, SIGNAL(triggered()), m_toolSet, SLOT(eyedropperOn()));
connect(ui->actionEraser, SIGNAL(triggered()), m_toolSet, SLOT(eraserOn()));
connect(ui->actionResetToolsDefault, SIGNAL(triggered()), this, SLOT(resetToolsSettings()));
/// --- Help Menu ---
connect(ui->actionHelp, SIGNAL(triggered()), this, SLOT(helpBox()));
connect(ui->actionAbout, SIGNAL(triggered()), this, SLOT(aboutPencil()));
// --------------- Menus ------------------
openRecentMenu = new QMenu(tr("Open recent"), this);
connect(ui->menuEdit, SIGNAL(aboutToShow()), this, SLOT(undoActSetText()));
connect(ui->menuEdit, SIGNAL(aboutToHide()), this, SLOT(undoActSetEnabled()));
}
int main (int argc, const char * argv[]) {
const char* filename;
struct hashMap *hashTable;
int tableSize = 10;
clock_t timer;
FILE *fileptr;
/*
this part is using command line arguments, you can use them if you wish
but it is not required. DO NOT remove this code though, we will use it for
testing your program.
if you wish not to use command line arguments manually type in your
filename and path in the else case.
*/
if(argc >= 2)
filename = argv[1];
else
filename = "input1.txt"; /*specify your input text file here*/
printf("opening file: %s\n", filename);
fileptr = fopen(filename, "r");
if(fileptr == NULL) {
char err[255];
sprintf(err, "Failure opening file %s; exiting.\n", filename);
perror(err);
exit(EXIT_FAILURE);
}
timer = clock();
hashTable = createMap(tableSize);
char *curr;
ValueType *val;
while((curr = getWord(fileptr)) != NULL) {
if((val = atMap(hashTable, curr)) != NULL)
(*val)++;
//insertMap(hashTable, curr, (*val)+1);
else
insertMap(hashTable, curr, 1);
free(curr);
}
fclose(fileptr);
//fclose(outfileptr);
printMap(hashTable);
timer = clock() - timer;
printf("\nconcordance ran in %f seconds\n", (float)timer / (float)CLOCKS_PER_SEC);
printf("Table emptyBuckets = %d\n", emptyBuckets(hashTable));
printf("Table count = %d\n", size(hashTable));
printf("Table capacity = %d\n", capacity(hashTable));
printf("Table load = %f\n", tableLoad(hashTable));
printf("Deleting keys\n");
removeKey(hashTable, "and");
removeKey(hashTable, "me");
removeKey(hashTable, "the");
//printMap(hashTable);
deleteMap(hashTable);
printf("\nDeleted the table\n");
return 0;
}