void ztxt::home()
{
unsuspend();
if (bInit)
inflateEnd(&zstream);
bInit = true;
size_t reclen = recordlength(1);
gotorecordnumber(1);
fread(compressedtextbuffer, reclen, sizeof(char), fin);
zstream.next_in = compressedtextbuffer;
zstream.next_out = expandedtextbuffer;
zstream.avail_out = buffersize;
zstream.avail_in = reclen;
zstream.zalloc = Z_NULL;
zstream.zfree = Z_NULL;
zstream.opaque = Z_NULL;
// printf("Initialising\n");
inflateInit(&zstream);
int ret = inflate(&zstream, Z_SYNC_FLUSH);
// printf("Inflate : %d\n", ret);
bufferpos = 0;
bufferrec = 1;
currentpos = 0;
buffercontent = buffersize - zstream.avail_out;
// printf("buffercontent:%u\n", buffercontent);
}
CList<Bkmk>* ztxt::getbkmklist()
{
UInt16 recno = ntohs(hdr0.bookmarkRecord);
// printf("Bookmarks - record %d contains %d\n", recno, ntohs(hdr0.numBookmarks));
if (recno == 0)
return 0;
unsuspend();
long cur = ftell(fin);
if (cur == -1)
return 0;
CList<Bkmk>* t = new CList<Bkmk>;
gotorecordnumber(recno);
for (int i = 0; i < ntohs(hdr0.numBookmarks); i++)
{
zTXTbkmk bkmk;
if (fread(&bkmk, sizeof(bkmk), 1, fin) != 1) break;
// printf("Bookmark number:%d:%.20s\n", i, bkmk.title);
tchar title[MAX_BMRK_LENGTH];
for (int j = 0; j < MAX_BMRK_LENGTH; j++)
{
title[j] = bkmk.title[j];
}
t->push_back(Bkmk(title, NULL, ntohl(bkmk.offset)));
}
fseek(fin, cur, SEEK_SET);
return t;
}
/// Resume the task if it was previously running; otherwise start it.
///
/// \post #task_state is set correctly.
///
/// \param[in] first_time Set this to true if the app
/// will be started for the first time.
/// \return 0 on success, nonzero otherwise.
int ACTIVE_TASK::resume_or_start(bool first_time) {
const char* str = "??";
int retval;
switch (task_state()) {
case PROCESS_UNINITIALIZED:
if (first_time) {
retval = start();
str = "Starting";
} else {
retval = start();
str = "Restarting";
}
if (task_state() == PROCESS_UNINITIALIZED) {
// Starting failed because of missing files. Don't treat this
// as an error because this would terminate the result. Just
// return here to suppress the start-message.
return 0;
}
if ((retval == ERR_SHMGET) || (retval == ERR_SHMAT)) {
return retval;
}
if (retval) {
set_task_state(PROCESS_COULDNT_START, "resume_or_start1");
return retval;
}
break;
case PROCESS_SUSPENDED:
retval = unsuspend();
if (retval) {
msg_printf(wup->project, MSG_INTERNAL_ERROR,
"Couldn't resume task %s", result->name
);
set_task_state(PROCESS_COULDNT_START, "resume_or_start2");
return retval;
}
str = "Resuming";
break;
default:
msg_printf(result->project, MSG_INTERNAL_ERROR,
"Unexpected state %d for task %s", task_state(), result->name
);
return 0;
}
if (log_flags.task) {
msg_printf(result->project, MSG_INFO,
"%s task %s using %s version %d",
str,
result->name,
app_version->app->name,
app_version->version_num
);
}
return 0;
}
static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
struct userdata *u = PA_SINK(o)->userdata;
switch (code) {
case PA_SINK_MESSAGE_GET_LATENCY:
*((pa_usec_t*) data) = sink_get_latency(u, &PA_SINK(o)->sample_spec);
return 0;
case PA_SINK_MESSAGE_SET_STATE:
switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
case PA_SINK_SUSPENDED:
pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
pa_smoother_pause(u->smoother, pa_rtclock_now());
if (!u->source || u->source_suspended) {
if (suspend(u) < 0)
return -1;
}
u->sink_suspended = true;
break;
case PA_SINK_IDLE:
case PA_SINK_RUNNING:
if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
pa_smoother_resume(u->smoother, pa_rtclock_now(), true);
if (!u->source || u->source_suspended) {
if (unsuspend(u) < 0)
return -1;
u->sink->get_volume(u->sink);
u->sink->get_mute(u->sink);
}
u->sink_suspended = false;
}
break;
case PA_SINK_INVALID_STATE:
case PA_SINK_UNLINKED:
case PA_SINK_INIT:
;
}
break;
}
return pa_sink_process_msg(o, code, data, offset, chunk);
}
void CReb::locate(unsigned int n)
{
UInt32 jl = 0,jh = nopages-1,jm = (jl+jh)/2;
while (jh > jl+1)
{
if (m_pagedetails[jm].pagestart > n)
{
jh = jm;
}
else
{
jl = jm;
}
jm = (jl+jh)/2;
}
unsuspend();
Page_detail rs = m_pagedetails[jl];
UInt32 val = n - rs.pagestart;
if (jl != currentpage.pageno()) readindex(jl);
currentpage.setoffset(page2pos(jl), jl, ((rs.flags & 8) != 0), rs.len, val);
if (noparas > 0)
{
UInt32 jl = 0,jh = noparas-1,jm = (jl+jh)/2;
while (jh > jl+1)
{
if (paras[jm].pos > val)
{
jh = jm;
}
else
{
jl = jm;
}
jm = (jl+jh)/2;
}
qDebug("TAGS:%s", (const char*)tags[paras[jl].tag]);
tagstring = tags[paras[jl].tag]+"<br>"; // Add br to set extra space to 0
tagoffset = 0;
}
unsigned long current = locate();
if (m_currentstart > current || current > m_currentend)
{
start2endSection();
}
if (current != n) qDebug("ERROR:Ended up at %u", current);
}
void ztxt::locate(unsigned int n)
{
if (hasrandomaccess())
{
unsuspend();
bufferrec = n / ntohs(hdr0.recordSize) + 1;
if (bufferrec == 1)
{
inflateEnd(&zstream);
}
size_t reclen = recordlength(bufferrec);
if (reclen == 0) return;
gotorecordnumber(bufferrec);
fread(compressedtextbuffer, reclen, sizeof(char), fin);
zstream.next_in = compressedtextbuffer;
zstream.next_out = expandedtextbuffer;
zstream.avail_out = buffersize;
zstream.avail_in = reclen;
if (bufferrec == 1)
{
zstream.zalloc = Z_NULL;
zstream.zfree = Z_NULL;
zstream.opaque = Z_NULL;
inflateInit(&zstream);
}
int ret = inflate(&zstream, Z_SYNC_FLUSH);
buffercontent = buffersize - zstream.avail_out;
bufferpos = 0;
currentpos = n - n % ntohs(hdr0.recordSize);
while (currentpos < n) getch();
}
else
{
home();
while (currentpos < n && getch() != EOF);
}
}
QImage* CReb::getPicture(const QString& ref)
{
QMap<QString, UInt32>::Iterator iter = m_index.find(ref);
if (iter != m_index.end())
{
unsuspend();
Page_detail rs = m_pagedetails[iter.data()];
char* imgbuffer = new char[rs.len];
fseek(fin, page2pos(iter.data()), SEEK_SET);
fread(imgbuffer, rs.len, 1, fin);
QByteArray arr;
arr.assign((const char*)imgbuffer, rs.len);
QImage* qimage = new QImage(arr);
return qimage;
}
else
{
return NULL;
}
}
//********************************************
// function name: ExeCmd
// Description: interperts and executes built-in commands
// Parameters: pointer to jobs, command string
// Returns: 0 - success,1 - failure
//**************************************************************************************
int ExeCmd(pJob* head, char* lineSize, char* cmdString)
{
char* cmd;
char* args[MAX_ARG];
char pwd[MAX_LINE_SIZE];
static char last_dir[MAX_LINE_SIZE];
char* delimiters = " \t\n";
int i = 0;
/*========used in kill command=======*/
int signal_number, Job_number, signal_sent;
int found_job_pid;
char found_job_name[MAX_LINE_SIZE];
/*===================================*/
/*========used in fg command=========*/
int child_done_id, fg_runner_pid, fg_req_JID;
/*===================================*/
/*========used in bg command=========*/
int bg_runner_pid;
/*===================================*/
bool illegal_cmd = FALSE; // illegal command
cmd = strtok(lineSize, delimiters);
if (cmd == NULL)
return 0;
args[0] = cmd;
L_Fg_Cmd = cmd;
for (i=1; i<MAX_ARG; i++)
{
args[i] = strtok(NULL, delimiters);
}
/*************************************************/
// Built in Commands
/*************************************************/
if (!strcmp(cmd, "cd") )
{
getcwd(pwd,sizeof(pwd));
if(!strcmp(args[1], "-"))
{
if(last_dir[0]!=0)
{
chdir(last_dir);
}
else
{
perror("smash error: > no previous path exists\n");
}
}
else
{
if(!chdir(args[1]))
{
strcpy(last_dir,pwd);
}
else
{
printf("smash error: > \"%s\" -path not found\n",args[1]);
illegal_cmd = TRUE;
}
}
}
/*************************************************/
else if (!strcmp(cmd, "pwd"))
{
if(getcwd(pwd,sizeof(pwd))!= NULL)
{
fprintf(stdout,"%s\n",pwd);
}
else
{
perror("smash error: > pwd error\n");
}
}
/*************************************************/
else if (!strcmp(cmd, "mkdir"))
{
if(mkdir(args[1], 0755))
{
if(EEXIST == errno)
{
printf("smash error: > \"%s\" -directory already exists\n",args[1]);
}
else
{
printf("smash error: > \"%s\" -cannot create directory\n",args[1]);
}
}
}
/*************************************************/
else if (!strcmp(cmd, "jobs"))
{
print_jobs(*head);
}
/*************************************************/
else if (!strcmp(cmd, "kill"))
{
if(args[1][0] != '-')
{
printf("smash error: > \"%s\"",cmdString);
return -1;
}
signal_number=atoi(args[1]+1);
Job_number=atoi(args[2]);
//search requested job
found_job_pid=find_job_PID(*head,Job_number);
if(found_job_pid==-1)
{
printf("smash error: > kill %d - job does not exist\n",Job_number);
return -1;
}
else
{
switch (signal_number)
{
case SIGTSTP:
signal_sent=kill(found_job_pid,SIGTSTP);
printf("signal SIGTSTP was sent to pid %d\n",found_job_pid);
if(signal_sent!=0)
{
printf("smash error: > kill %d - cannot send signal\n",Job_number);
}
strcpy(found_job_name,find_job_name(*head,found_job_pid));
remove_job(head,found_job_pid);
insert_job(head, found_job_pid, found_job_name, SUSPENDED);
break;
case SIGINT:
signal_sent=kill(found_job_pid,SIGINT);
printf("signal SIGINT was sent to pid %d\n",found_job_pid);
if(signal_sent!=0)
{
printf("smash error: > kill %d - cannot send signal\n",Job_number);
}
remove_job(head,found_job_pid);
break;
case SIGTERM:
signal_sent=kill(found_job_pid,SIGTERM);
printf("signal SIGTERM was sent to pid %d\n",found_job_pid);
if(signal_sent!=0)
{
printf("smash error: > kill %d - cannot send signal\n",Job_number);
}
remove_job(head,found_job_pid);
break;
default:
signal_sent=kill(found_job_pid,signal_number);
if(signal_sent!=0)
{
printf("smash error: > kill %d - cannot send signal\n",Job_number);
}
printf("signal %d was sent to pid %d\n",signal_number,found_job_pid);
}
}
}
/*************************************************/
else if (!strcmp(cmd, "showpid"))
{
printf("smash pid is %d\n",getpid());
}
/*************************************************/
else if (!strcmp(cmd, "fg"))
{
if(args[1]==NULL)
{
Last_Bg_Pid=get_last_job_pid(*head);
fg_runner_pid=Last_Bg_Pid;
}
else
{
fg_req_JID=atoi(args[1]);
fg_runner_pid=find_job_PID(*head,fg_req_JID);
}
if (fg_runner_pid== -1)// No jobs in the Bg
{
perror("smash error: requested process not found\n");
}
else if(is_suspended(*head,fg_runner_pid)== SUSPENDED)
{
kill(fg_runner_pid,SIGCONT);
printf("signal SIGCONT was sent to pid %d\n",fg_runner_pid);
unsuspend(*head,fg_runner_pid);
Susp_Bg_Pid=get_last_suspended_job_pid(*head);
}
GPid=fg_runner_pid;
L_Fg_Cmd = find_job_name(*head,fg_runner_pid);
do
{
child_done_id = wait(NULL);
if((child_done_id==-1)&&(errno==EINTR)) //child is gone due to inerrupt
{
break;
}
}
while((child_done_id != fg_runner_pid) && (fg_runner_pid != Susp_Bg_Pid));
remove_job(head,fg_runner_pid);
GPid= -1;
}
/*************************************************/
else if (!strcmp(cmd, "bg"))
{
if(args[1]==NULL)
{
bg_runner_pid=get_last_suspended_job_pid(*head);
}
else
{
fg_req_JID=atoi(args[1]);
bg_runner_pid=find_job_PID(*head, fg_req_JID);
if(is_suspended(*head,bg_runner_pid)==NOT_SUSPENDED)
{
perror("smash error: > bg called on un-suspended job\n");
return -1;
}
}
strcpy(found_job_name,find_job_name(*head,bg_runner_pid));
printf("%s",found_job_name);
kill(bg_runner_pid,SIGCONT);
printf("signal SIGCONT was sent to pid %d\n",bg_runner_pid);
unsuspend(*head,bg_runner_pid);
Susp_Bg_Pid=get_last_suspended_job_pid(*head);
}
/*************************************************/
else if (!strcmp(cmd, "quit"))
{
if(args[1]==NULL)
{
destroy_list(head);
exit(0);
}
else if (!strcmp(args[1], "kill"))
{
if (kill_jobs(*head) != -1) {
destroy_list(head);
exit(0);
}
else {
exit (-1);
}
}
else
perror("smash error: > quit called with illegal argument\n");
return -1;
}
/*************************************************/
else // external command
{
ExeExternal(args, cmdString);
return 0;
}
if (illegal_cmd == TRUE)
{
printf("smash error: > \"%s\"\n", cmdString);
return 1;
}
return 0;
}
static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
struct userdata *u = PA_SOURCE(o)->userdata;
int ret;
int do_trigger = FALSE, quick = TRUE;
switch (code) {
case PA_SOURCE_MESSAGE_GET_LATENCY: {
pa_usec_t r = 0;
if (u->fd >= 0) {
if (u->use_mmap)
r = mmap_source_get_latency(u);
else
r = io_source_get_latency(u);
}
*((pa_usec_t*) data) = r;
return 0;
}
case PA_SOURCE_MESSAGE_SET_STATE:
switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
case PA_SOURCE_SUSPENDED:
pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
if (!u->sink || u->sink_suspended) {
if (suspend(u) < 0)
return -1;
}
do_trigger = TRUE;
u->source_suspended = TRUE;
break;
case PA_SOURCE_IDLE:
case PA_SOURCE_RUNNING:
if (u->source->thread_info.state == PA_SOURCE_INIT) {
do_trigger = TRUE;
quick = u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state);
}
if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
if (!u->sink || u->sink_suspended) {
if (unsuspend(u) < 0)
return -1;
quick = FALSE;
}
do_trigger = TRUE;
u->in_mmap_current = 0;
u->in_mmap_saved_nfrags = 0;
u->source_suspended = FALSE;
}
break;
case PA_SOURCE_UNLINKED:
case PA_SOURCE_INIT:
case PA_SOURCE_INVALID_STATE:
;
}
break;
}
ret = pa_source_process_msg(o, code, data, offset, chunk);
if (ret >= 0 && do_trigger) {
if (trigger(u, quick) < 0)
return -1;
}
return ret;
}
/* Called from the IO thread. */
static int source_set_state_in_io_thread_cb(pa_source *s, pa_source_state_t new_state, pa_suspend_cause_t new_suspend_cause) {
struct userdata *u;
bool do_trigger = false;
bool quick = true;
pa_assert(s);
pa_assert_se(u = s->userdata);
/* It may be that only the suspend cause is changing, in which case there's
* nothing to do. */
if (new_state == s->thread_info.state)
return 0;
switch (new_state) {
case PA_SOURCE_SUSPENDED:
pa_assert(PA_SOURCE_IS_OPENED(s->thread_info.state));
if (!u->sink || u->sink_suspended)
suspend(u);
do_trigger = true;
u->source_suspended = true;
break;
case PA_SOURCE_IDLE:
case PA_SOURCE_RUNNING:
if (s->thread_info.state == PA_SOURCE_INIT) {
do_trigger = true;
quick = u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state);
}
if (s->thread_info.state == PA_SOURCE_SUSPENDED) {
if (!u->sink || u->sink_suspended) {
if (unsuspend(u) < 0)
return -1;
quick = false;
}
do_trigger = true;
u->in_mmap_current = 0;
u->in_mmap_saved_nfrags = 0;
u->source_suspended = false;
}
break;
case PA_SOURCE_UNLINKED:
case PA_SOURCE_INIT:
case PA_SOURCE_INVALID_STATE:
;
}
if (do_trigger)
trigger(u, u->sink ? u->sink->thread_info.state : PA_SINK_INVALID_STATE, new_state, quick);
return 0;
}
