int performIRET() {
if (mode == USER_MODE) {
raiseException(newException(EX_ILLINSTR, "Call to Privileged Instruction IRET in USER mode", 0));
return 0;
}
Exception e = isSafeState2();
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
mode = USER_MODE;
Address T = translateAddress(getInteger(reg[SP_REG]));
if (T.page == -1 && T.word == -1) {
mode = KERNEL_MODE;
return 0;
}
char * value = getWordFromAddress(T);
if (getType(value) == TYPE_STR) {
mode = KERNEL_MODE;
raiseException(newException(EX_ILLMEM, "Illegal return address", 0));
return 0;
}
int result = getInteger(value);
if (result < 0 || result >= getInteger(reg[PTLR_REG]) * PAGE_SIZE) {
mode = KERNEL_MODE;
raiseException(newException(EX_ILLMEM, "Illegal return address", 0));
return 0;
}
storeInteger(reg[IP_REG], result);
storeInteger(reg[SP_REG], getInteger(reg[SP_REG]) - 1);
return 1;
}
/*
This function runs the scheduler which is the INT 0 code.
*/
void runInt0Code()
{
struct address translated_addr;
if(getType(reg[SP_REG]) == TYPE_STR || getType(reg[PTLR_REG]) == TYPE_STR)
{
exception("Illegal Register value", EX_ILLMEM, 0);
return;
}
if(getInteger(reg[SP_REG]) + 1 < 0)
{
exception("Stack underflow\n", EX_ILLMEM, 0);
return;
}
if(getInteger(reg[SP_REG]) + 1 >= getInteger(reg[PTLR_REG]) * PAGE_SIZE)
{
exception("Stack overflow\n", EX_ILLMEM, 0);
return;
}
translated_addr = translate(getInteger(reg[SP_REG])+1);
if(translated_addr.page_no == -1 && translated_addr.word_no == -1)
return;
storeInteger(reg[SP_REG], getInteger(reg[SP_REG])+1);
storeInteger(page[translated_addr.page_no].word[translated_addr.word_no], getInteger(reg[IP_REG]));
// printf("Pushing %d into %d\n",getInteger(reg[IP_REG]),getInteger(reg[SP_REG]));
mode = KERNEL_MODE;
storeInteger(reg[IP_REG], INT0 * PAGE_SIZE);
}
void raiseException(Exception e) {
if (mode == KERNEL_MODE) {
printf("<ERROR:%d:%s> %s\n",getInteger(reg[IP_REG]), instruction, e.message);
if (isDebugModeOn()) debugInterface();
exit(0);
} else {
int ex_flag;
ex_flag = getInteger(reg[IP_REG]) * 1000;
ex_flag += e.fault_page * 10;
ex_flag += e.code;
mode = KERNEL_MODE;
storeInteger(reg[EFR_REG], ex_flag);
storeInteger(reg[IP_REG], EXCEPTION_HANDLER * PAGE_SIZE);
}
}
int performPop(int X, int flagX) {
char * value;
Exception e;
Address T = translateAddress(getInteger(reg[SP_REG]));
if (T.page == -1 && T.word == -1) return 0;
switch (flagX) {
case REG:
e = isRegisterInaccessible(X);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
value = getWordFromAddress(T);
strcpy(reg[X], value);
storeInteger(reg[SP_REG], getInteger(reg[SP_REG]) - 1);
return 1;
break;
case IP:
raiseException(newException(EX_ILLOPERAND, "Illegal operand IP. Cannot alter readonly register", 0));
return 0;
break;
case EFR:
raiseException(newException(EX_ILLOPERAND, "Illegal operand EFR. Cannot alter readonly register", 0));
return 0;
break;
default:
raiseException(newException(EX_ILLOPERAND, "Illegal Operand", 0));
return 0;
break;
}
}
int performPush(int X, int flagX) {
Address T = translateAddress(getInteger(reg[SP_REG]) + 1);
if (T.page == -1 && T.word == -1) return 0;
Exception e;
switch (flagX) {
case REG:
case SP:
case BP:
case IP:
case PTBR:
case PTLR:
case EFR:
e = isRegisterInaccessible(X);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
if (storeWordToAddress(T, reg[X])) {
storeInteger(reg[SP_REG], getInteger(reg[SP_REG]) + 1);
return 1;
} else return 0;
break;
default:
raiseException(newException(EX_ILLOPERAND, "Illegal Operand", 0));
return 0;
break;
}
}
int performCall(int X, int flagX) {
Exception e = isSafeState2();
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
if (flagX != NUM) {
raiseException(newException(EX_ILLOPERAND, "Illegal operand", 0));
return 0;
}
e = isRestrictedMemoryLocation(X);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
Address T = translateAddress(getInteger(reg[SP_REG]) + 1);
if (T.page == -1 && T.word == -1) return;
storeInteger(reg[SP_REG], getInteger(reg[SP_REG]) + 1);
storeInteger(page[T.page].word[T.word], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
storeInteger(reg[IP_REG], X);
return 1;
}
int performRet() {
Exception e = isSafeState2();
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
Address T = translateAddress(getInteger(reg[SP_REG]));
if (T.page == -1 && T.word == -1) return;
char * value = getWordFromAddress(T);
if (value == NULL || getType(value) == TYPE_STR) {
raiseException(newException(EX_ILLMEM, "Illegal return address", 0));
return 0;
}
int result = getInteger(value);
e = isRestrictedMemoryLocation(result);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
storeInteger(reg[IP_REG], result);
storeInteger(reg[SP_REG], getInteger(reg[SP_REG]) - 1);
return 1;
}
/*
createDisk creates the disk file if not present.
if format is equal to zero then the function creates the disk but does not format it.
if format is not equal to zero then the function will create and format the disk.
Formatting is done as follows:
1. A memory copy of the disk is maintained. This copy contains NO_BLOCKS_TO_COPY + EXTRA_BLOCKS (in this case 13 + 1) blocks.
The extra block is a temporary block. This memory copy is called the virtual disk. This is first cleared.
2. Then the memory freelist is initialised.
3. The fat blocks are also initialised. The basic block entries are all set to -1. The memory copy is then committed to the
disk file.
4. Finally the entry for init process is made.
*/
void createDisk(int format){
int fd;
if(format){
fd = open(DISK_NAME, O_CREAT | O_TRUNC | O_SYNC, 0666);
clearVirtDisk();
close(fd);
// loadFileToVirtualDisk(); note: commented this line
int i=0,j=0;
for(j=0; j<NO_OF_FREE_LIST_BLOCKS; j++){
if(j == 0)
for(i=0;i<DATA_START_BLOCK + INIT_SIZE ;i++)
storeInteger(disk[FREE_LIST_START_BLOCK].word[i], 1);
else
i=0;
for( ;i<BLOCK_SIZE;i++)
storeInteger(disk[FREE_LIST_START_BLOCK + j].word[i], 0);
writeToDisk(FREE_LIST_START_BLOCK + j, FREE_LIST_START_BLOCK+j);
}
for(j=0; j<NO_OF_FAT_BLOCKS; j++){
for(i=FAT_BASICBLOCK; i<BLOCK_SIZE; i=i+FAT_ENTRY_SIZE){
storeInteger(disk[FAT_START_BLOCK + j].word[i], -1);
}
writeToDisk(FAT_START_BLOCK+j, FAT_START_BLOCK+j);
}
initializeINIT();
}
else
{
fd = open(DISK_NAME, O_CREAT, 0666);
close(fd);
}
}
void IpeEnv::storeFoo(LcnSymbol* sym, IpeValue value)
{
#if 0
if (sym->type == dtBools[BOOL_SIZE_SYS])
{
storeBool(sym, value.boolGet());
}
else if (sym->type == dtInt[INT_SIZE_64])
{
storeInteger(sym, value.integerGet());
}
else if (sym->type == dtReal[FLOAT_SIZE_64])
{
storeReal(sym, value.realGet());
}
else
{
AstDumpToNode logger(stdout, 3);
printf("\n\n");
printf(" IpeEnv::store(LcnSymbol*) Unsupported\n");
printf(" ");
sym->accept(&logger);
printf("\n\n");
INT_ASSERT(false);
}
#endif
INT_ASSERT(false);
}
/*
* This code is used to execute each instruction.
*/
void executeOneInstruction(int instr) {
int X, Y, flagX1, flagX2, flagY1, flagY2, operation;
char string[WORD_SIZE];
bzero(string, 16);
switch (instr) {
case START:
storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR); //increment IP
break;
case MOV: //1st phase:get the value 2nd phase:store the value
X = yylex();
flagX1 = yylval.flag;
flagX2 = yylval.flag2;
Y = yylex();
flagY1 = yylval.flag;
flagY2 = yylval.flag2;
strcpy(string, yylval.data);
if (!performMOV(X, flagX1, flagX2, Y, flagY1, flagY2, string)) return;
storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
break;
case ARITH:
operation = yylval.flag;
X = yylex();
flagX1 = yylval.flag;
if (operation != INR && operation != DCR) {
Y = yylex();
flagY1 = yylval.flag;
}
if (!performArithmetic(X, flagX1, Y, flagY1, operation)) return;
storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
break;
case LOGIC:
operation = yylval.flag;
X = yylex();
flagX1 = yylval.flag;
Y = yylex();
flagY1 = yylval.flag;
if (!performLogic(X, flagX1, Y, flagY1, operation)) return;
storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
break;
case BRANCH:
operation = yylval.flag;
X = yylex();
flagX1 = yylval.flag;
if (operation != JMP) {
Y = yylex();
flagY1 = yylval.flag;
}
if (!performBranching(X, flagX1, Y, flagY1, operation)) return;
break;
case PUSH:
X = yylex();
flagX1 = yylval.flag;
if (!performPush(X, flagX1)) return;
storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
break;
case POP:
X = yylex();
flagX1 = yylval.flag;
if (!performPop(X, flagX1)) return;
storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
break;
case CALL:
X = yylex();
flagX1 = yylval.flag;
if (!performCall(X, flagX1)) return;
break;
case RET:
if (!performRet()) return;
break;
case INT:
X = yylex();
flagX1 = yylval.flag;
if (!performINT(X, flagX1)) return;
break;
case IRET:
if (!performIRET()) return;
break;
case IN:
X = yylex();
flagX1 = yylval.flag;
if (!performIN(X, flagX1)) return;
storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
break;
case OUT:
X = yylex();
flagX1 = yylval.flag;
if (!performOUT(X, flagX1)) return;
storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
break;
case LOAD:
case STORE:
X = yylex();
flagX1 = yylval.flag;
Y = yylex();
flagY1 = yylval.flag;
if (!performLoadStore(X, flagX1, Y, flagY1, instr)) return;
storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
break;
case HALT:
if (mode == USER_MODE) {
raiseException(newException(EX_ILLINSTR, "Call to Privileged Instruction HALT in USER mode", 0));
return;
}
printf("Machine is halting\n");
exit(0);
break;
case END:
break;
case BRKP:
if (isDebugModeOn()) {
step_flag = 1;
printf("\nXSM Debug Environment\nType \"help\" for getting a list of commands\n");
}
storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
break;
default:
raiseException(newException(EX_ILLINSTR, "Illegal Instruction", 0));
return;
}
}
void
Tags::c_store( MP4Tags*& tags, MP4FileHandle hFile )
{
MP4Tags& c = *tags;
MP4File& file = *static_cast<MP4File*>(hFile);
storeString( file, CODE_NAME, name, c.name );
storeString( file, CODE_ARTIST, artist, c.artist );
storeString( file, CODE_ALBUMARTIST, albumArtist, c.albumArtist );
storeString( file, CODE_ALBUM, album, c.album );
storeString( file, CODE_GROUPING, grouping, c.grouping );
storeString( file, CODE_COMPOSER, composer, c.composer );
storeString( file, CODE_COMMENTS, comments, c.comments );
storeString( file, CODE_GENRE, genre, c.genre );
storeGenre( file, genreType, c.genreType );
storeString( file, CODE_RELEASEDATE, releaseDate, c.releaseDate );
storeTrack( file, track, c.track );
storeDisk( file, disk, c.disk );
storeInteger( file, CODE_TEMPO, tempo, c.tempo );
storeInteger( file, CODE_COMPILATION, compilation, c.compilation );
storeString( file, CODE_TVSHOW, tvShow, c.tvShow );
storeString( file, CODE_TVNETWORK, tvNetwork, c.tvNetwork );
storeString( file, CODE_TVEPISODEID, tvEpisodeID, c.tvEpisodeID );
storeInteger( file, CODE_TVSEASON, tvSeason, c.tvSeason );
storeInteger( file, CODE_TVEPISODE, tvEpisode, c.tvEpisode );
storeString( file, CODE_SORTNAME, sortName, c.sortName );
storeString( file, CODE_SORTARTIST, sortArtist, c.sortArtist );
storeString( file, CODE_SORTALBUMARTIST, sortAlbumArtist, c.sortAlbumArtist );
storeString( file, CODE_SORTALBUM, sortAlbum, c.sortAlbum );
storeString( file, CODE_SORTCOMPOSER, sortComposer, c.sortComposer );
storeString( file, CODE_SORTTVSHOW, sortTVShow, c.sortTVShow );
storeString( file, CODE_DESCRIPTION, description, c.description );
storeString( file, CODE_LONGDESCRIPTION, longDescription, c.longDescription );
storeString( file, CODE_LYRICS, lyrics, c.lyrics );
storeString( file, CODE_COPYRIGHT, copyright, c.copyright );
storeString( file, CODE_ENCODINGTOOL, encodingTool, c.encodingTool );
storeString( file, CODE_ENCODEDBY, encodedBy, c.encodedBy );
storeString( file, CODE_PURCHASEDATE, purchaseDate, c.purchaseDate );
storeInteger( file, CODE_PODCAST, podcast, c.podcast );
storeString( file, CODE_KEYWORDS, keywords, c.keywords );
storeString( file, CODE_CATEGORY, category, c.category );
storeInteger( file, CODE_HDVIDEO, hdVideo, c.hdVideo );
storeInteger( file, CODE_MEDIATYPE, mediaType, c.mediaType );
storeInteger( file, CODE_CONTENTRATING, contentRating, c.contentRating );
storeInteger( file, CODE_GAPLESS, gapless, c.gapless );
storeString( file, CODE_ITUNESACCOUNT, iTunesAccount, c.iTunesAccount );
storeInteger( file, CODE_ITUNESACCOUNTTYPE, iTunesAccountType, c.iTunesAccountType );
storeInteger( file, CODE_ITUNESCOUNTRY, iTunesCountry, c.iTunesCountry );
storeInteger( file, CODE_CNID, cnID, c.cnID );
storeInteger( file, CODE_ATID, atID, c.atID );
storeInteger( file, CODE_PLID, plID, c.plID );
storeInteger( file, CODE_GEID, geID, c.geID );
// destroy all cover-art then add each
{
CoverArtBox::remove( hFile );
const CoverArtBox::ItemList::size_type max = artwork.size();
for( CoverArtBox::ItemList::size_type i = 0; i < max; i++ )
CoverArtBox::add( hFile, artwork[i] );
}
}
int performBranching(int X, int flagX, int Y, int flagY, int operation) {
int valueX, valueY;
Exception e = isSafeState2();
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
switch (operation) {
case JZ:
case JNZ:
switch (flagX) {
case REG:
case SP:
case BP:
case IP:
case PTBR:
case PTLR:
case EFR:
e = isRegisterInaccessible(X);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
break;
default:
raiseException(newException(EX_ILLOPERAND, "Illegal operand", 0));
return 0;
break;
}
if (flagY != NUM) {
raiseException(newException(EX_ILLOPERAND, "Illegal operand", 0));
return 0;
}
e = isRestrictedMemoryLocation(Y);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
if ((getType(reg[X]) == TYPE_INT && operation == JZ && getInteger(reg[X]) == 0)
|| ((getType(reg[X]) == TYPE_STR) || (operation == JNZ && getInteger(reg[X])))) storeInteger(reg[IP_REG], Y);
else storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
break;
case JMP:
if (flagX != NUM) {
raiseException(newException(EX_ILLOPERAND, "Illegal operand", 0));
return 0;
}
e = isRestrictedMemoryLocation(X);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
storeInteger(reg[IP_REG], X);
break;
default:
raiseException(newException(EX_ILLINSTR, "Illegal Instruction", 0));
return 0;
break;
}
return 1;
}
int performLogic(int X, int flagX, int Y, int flagY, int operation) {
int valueX, valueY;
Exception e = isSafeState2();
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
switch (flagX) {
case REG:
case SP:
case BP:
case PTBR:
case PTLR:
e = isRegisterInaccessible(X);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
break;
case IP:
raiseException(newException(EX_ILLOPERAND, "Illegal operand IP. Cannot alter readonly register", 0));
return 0;
break;
case EFR:
raiseException(newException(EX_ILLOPERAND, "Illegal operand EFR. Cannot alter readonly register", 0));
return 0;
break;
default:
raiseException(newException(EX_ILLOPERAND, "Illegal operand", 0));
return 0;
break;
}
switch (flagY) {
case REG:
case SP:
case BP:
case PTBR:
case PTLR:
e = isRegisterInaccessible(Y);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
break;
case IP:
raiseException(newException(EX_ILLOPERAND, "Illegal operand IP. Cannot alter readonly register", 0));
return 0;
break;
case EFR:
raiseException(newException(EX_ILLOPERAND, "Illegal operand EFR. Cannot alter readonly register", 0));
return 0;
break;
default:
raiseException(newException(EX_ILLOPERAND, "Illegal operand", 0));
return 0;
break;
}
if (getType(reg[X]) != getType(reg[Y])) {
raiseException(newException(EX_ILLOPERAND, "Operand Type Mismatch to logical expression", 0));
return 0;
}
switch (operation) {
case LT:
valueX = (getType(reg[X]) == TYPE_INT) ? (getInteger(reg[X]) < getInteger(reg[Y])) : (strcmp(reg[X], reg[Y]) < 0);
break;
case GT:
valueX = (getType(reg[X]) == TYPE_INT) ? (getInteger(reg[X]) > getInteger(reg[Y])) : (strcmp(reg[X], reg[Y]) > 0);
break;
case EQ:
valueX = (getType(reg[X]) == TYPE_INT) ? (getInteger(reg[X]) == getInteger(reg[Y])) : (!strcmp(reg[X], reg[Y]));
break;
case NE:
valueX = (getType(reg[X]) == TYPE_INT) ? (getInteger(reg[X]) != getInteger(reg[Y])) : (!!strcmp(reg[X], reg[Y]));
break;
case LE:
valueX = (getType(reg[X]) == TYPE_INT) ? (getInteger(reg[X]) <= getInteger(reg[Y])) : (strcmp(reg[X], reg[Y]) >= 0);
break;
case GE:
valueX = (getType(reg[X]) == TYPE_INT) ? (getInteger(reg[X]) >= getInteger(reg[Y])) : (strcmp(reg[X], reg[Y]) >= 0);
break;
default:
raiseException(newException(EX_ILLINSTR, "Illegal Instruction", 0));
return;
break;
}
storeInteger(reg[X], valueX);
return 1;
}
int performArithmetic(int X, int flagX, int Y, int flagY, int operation) {
int valueX, valueY;
Exception e = isSafeState2();
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
switch (flagX) {
case REG:
case SP:
case BP:
case PTBR:
case PTLR:
e = isRegisterInaccessible(X);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
if (getType(reg[X]) == TYPE_STR) {
raiseException(newException(EX_ILLOPERAND, "Illegal operand", 0));
return 0;
}
valueX = X;
break;
case IP:
raiseException(newException(EX_ILLOPERAND, "Illegal operand IP. Cannot alter readonly register", 0));
return 0;
break;
case EFR:
raiseException(newException(EX_ILLOPERAND, "Illegal operand EFR. Cannot alter readonly register", 0));
return 0;
break;
default:
raiseException(newException(EX_ILLOPERAND, "Illegal operand", 0));
return 0;
break;
}
if (operation != INR && operation != DCR) {
switch (flagY) {
case REG:
case SP:
case BP:
case PTBR:
case PTLR:
e = isRegisterInaccessible(Y);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
if (getType(reg[Y]) == TYPE_STR) {
raiseException(newException(EX_ILLOPERAND, "Illegal operand", 0));
return 0;
}
valueY = getInteger(reg[Y]);
break;
case NUM:
valueY = Y;
break;
case IP:
raiseException(newException(EX_ILLOPERAND, "Illegal operand IP. Cannot alter readonly register", 0));
return 0;
break;
case EFR:
raiseException(newException(EX_ILLOPERAND, "Illegal operand EFR. Cannot alter readonly register", 0));
return 0;
break;
default:
raiseException(newException(EX_ILLOPERAND, "Illegal operand", 0));
return 0;
break;
}
}
switch (operation) {
case ADD:
storeInteger(reg[valueX], getInteger(reg[valueX]) + valueY);
break;
case SUB:
storeInteger(reg[valueX], getInteger(reg[valueX]) - valueY);
break;
case MUL:
storeInteger(reg[valueX], getInteger(reg[valueX]) * valueY);
break;
case DIV:
if (valueY == 0) {
raiseException(newException(EX_ILLOPERAND, "Divide by ZERO", 0));
return 0;
}
storeInteger(reg[valueX], getInteger(reg[valueX]) / valueY);
break;
case MOD:
if (valueY == 0) {
raiseException(newException(EX_ILLOPERAND, "Divide by ZERO", 0));
return 0;
}
storeInteger(reg[valueX], getInteger(reg[valueX]) % valueY);
break;
case INR:
storeInteger(reg[valueX], getInteger(reg[valueX]) + 1);
break;
case DCR:
storeInteger(reg[valueX], getInteger(reg[valueX]) - 1);
break;
default:
raiseException(newException(EX_ILLINSTR, "Illegal Instruction", 0));
return 0;
break;
}
return 1;
}
