int
main(int argc, char *argv[])
{
printf(1, "Hello World! Pid is: %d\n\r", getpid());
printf(1, "Add number: %d\n\r", addnum(2));
printf(1, "Add number: %d\n\r", addnum(5));
exit();
}
int main (void)
{
printf("Try to add 1 to number, it equals: %d\n",addnum(1));
printf("Try to add 2 to number, it equals: %d\n",addnum(2));
printf("Try to add 3 to number, it equals: %d\n",addnum(3));
printf("\nNormally, this would return 1 2 3, but it now returns 1 3 6:\n");
printf("This is because addnum keeps numbers value, not throwing it out\n");
printf("after the returns. We can only change numbers value in addnum.\n");
printf("Its scope stays in addnum.");
}
int main(void)
{
first = malloc(sizeof(node));
int product;
for (int i = 1; i < 1000; i++)
{
for(int j = 1; j < 1000; j++)
{
int result = i * j;
if(pandig(result, i, j))
{
// printf("this works: %d\n", result);
addnum(result);
}
else
{
// printf("this doesn't work");
}
}
}
node* nextpointer = first;
int sum = 0;
while(nextpointer != NULL)
{
// printf("%d\n", nextpointer->value);
sum += nextpointer->value;
nextpointer = nextpointer-> ptr;
}
printf("%d\n", sum);
}
int main(int argc, char *argv[])
{
printf("sum = %d\n", addnum(7,3));
printf("sum = %d\n", addNumbers(5, 4));
return 0;
}
int *plusOne(int *digits, int digitsSize, int *returnSize)
{
int i, c;
res = 0;
revert(digits, digitsSize);
c = 1;
for (i = 0; i < digitsSize; i++) {
digits[i] += c;
c = 0;
if (digits[i] > 9) {
digits[i] -= 10;
c = 1;
}
addnum(digits[i]);
}
if (c)
addnum(c);
revert(res, p);
*returnSize = p;
return(res);
}
int main()
{
struct node* res=NULL;
struct node* f=NULL;
struct node* s=NULL;
add(&f,6);add(&f,4);add(&f,9);add(&f,5);add(&f,7);
print(f);
add(&s,8);add(&s,4);
print(s);
res=addnum(f,s);
print(res);
return 0;
}
int
main(int argc, char *argv[])
{
int i = 0, pid;
printf(1, "%s", "** Placeholder program for grading scripts **\n");
printf(1, "%d\n", addnum(22675));
for (i = 226; i <=245; ++i)
{
printf(1, "%d\n", addnum(i));
}
pid = fork();
if (pid == 0) {
printf(1, "%d\n", addnum(22675));
for (i = 226; i <=245; ++i)
{
printf(1, "%d\n", addnum(i));
}
printf(1, "End of tests\n");
while(1);
}
while(1);
return(0);
}
void
VCDMetaInfo( access_t *p_access, /*const*/ char *psz_mrl )
{
vcdplayer_t *p_vcdplayer = (vcdplayer_t *) p_access->p_sys;
input_thread_t *p_input = p_vcdplayer->p_input;
vcdinfo_obj_t *p_vcdev = p_vcdplayer->vcd;
size_t i_entries = vcdinfo_get_num_entries(p_vcdev);
size_t last_entry = 0;
char *psz_cat = _("Disc");
track_t i_track;
# define addstr(t,v) input_Control(p_input,INPUT_ADD_INFO,psz_cat,t,"%s",v)
# define addnum(t,v) input_Control(p_input,INPUT_ADD_INFO,psz_cat,t,"%d",v)
# define addhex(t,v) input_Control(p_input,INPUT_ADD_INFO,psz_cat,t,"%x",v)
addstr(_("VCD Format"), vcdinfo_get_format_version_str(p_vcdev));
addstr(_("Album"), vcdinfo_get_album_id (p_vcdev));
addstr(_("Application"), vcdinfo_get_application_id (p_vcdev));
addstr(_("Preparer"), vcdinfo_get_preparer_id (p_vcdev));
addnum(_("Vol #"), vcdinfo_get_volume_num (p_vcdev));
addnum(_("Vol max #"), vcdinfo_get_volume_count (p_vcdev));
addstr(_("Volume Set"), vcdinfo_get_volumeset_id (p_vcdev));
addstr(_("Volume"), vcdinfo_get_volume_id (p_vcdev));
addstr(_("Publisher"), vcdinfo_get_publisher_id (p_vcdev));
addstr(_("System Id"), vcdinfo_get_system_id (p_vcdev));
addnum("LIDs", vcdinfo_get_num_LIDs (p_vcdev));
addnum(_("Entries"), vcdinfo_get_num_entries (p_vcdev));
addnum(_("Segments"), vcdinfo_get_num_segments (p_vcdev));
addnum(_("Tracks"), vcdinfo_get_num_tracks (p_vcdev));
/* Spit out track information. Could also include MSF info.
Also build title table.
*/
for( i_track = 1 ; i_track < p_vcdplayer->i_tracks ; i_track++ ) {
unsigned int audio_type = vcdinfo_get_track_audio_type(p_vcdev, i_track);
uint32_t i_secsize = vcdinfo_get_track_sect_count(p_vcdev, i_track);
if (p_vcdplayer->b_svd) {
addnum(_("Audio Channels"),
vcdinfo_audio_type_num_channels(p_vcdev, audio_type) );
}
addnum(_("First Entry Point"), 0 );
for ( last_entry = 0 ; last_entry < i_entries
&& vcdinfo_get_track(p_vcdev, last_entry) == i_track; last_entry++ ) ;
addnum(_("Last Entry Point"), last_entry-1 );
addnum(_("Track size (in sectors)"), i_secsize );
}
{
lid_t i_lid;
for( i_lid = 1 ; i_lid <= p_vcdplayer->i_lids ; i_lid++ ) {
PsdListDescriptor_t pxd;
if (vcdinfo_lid_get_pxd(p_vcdev, &pxd, i_lid)) {
switch (pxd.descriptor_type) {
case PSD_TYPE_END_LIST:
addstr(_("type"), _("end"));
break;
case PSD_TYPE_PLAY_LIST:
addstr(_("type"), _("play list"));
addnum("items", vcdinf_pld_get_noi(pxd.pld));
addhex("next", vcdinf_pld_get_next_offset(pxd.pld));
addhex("previous", vcdinf_pld_get_prev_offset(pxd.pld));
addhex("return", vcdinf_pld_get_return_offset(pxd.pld));
addnum("wait time", vcdinf_get_wait_time(pxd.pld));
break;
case PSD_TYPE_SELECTION_LIST:
case PSD_TYPE_EXT_SELECTION_LIST:
addstr(_("type"), PSD_TYPE_SELECTION_LIST == pxd.descriptor_type
? _("extended selection list") : _("selection list") );
addhex("default", vcdinf_psd_get_default_offset(pxd.psd));
addhex("loop count", vcdinf_get_loop_count(pxd.psd));
addhex("next", vcdinf_psd_get_next_offset(pxd.psd));
addhex("previous", vcdinf_psd_get_prev_offset(pxd.psd));
addhex("return", vcdinf_psd_get_return_offset(pxd.psd));
addhex("rejected", vcdinf_psd_get_lid_rejected(pxd.psd));
addhex("time-out offset", vcdinf_get_timeout_offset(pxd.psd));
addnum("time-out time", vcdinf_get_timeout_time(pxd.psd));
break;
default:
addstr(_("type"), _("unknown type"));
break;
}
}
}
}
# undef addstr
# undef addnum
# undef addhex
if ( CDIO_INVALID_TRACK != i_track )
{
char *psz_tfmt = var_InheritString( p_access, MODULE_STRING "-title-format" );
char *psz_name = VCDFormatStr( p_vcdplayer, psz_tfmt, psz_mrl,
&(p_vcdplayer->play_item) );
free( psz_tfmt );
input_Control( p_input, INPUT_SET_NAME, psz_name );
free( psz_name );
}
}
/*
* mulfile: print files with more than one column of output and
* more than one file concurrently
*/
int
mulfile(int argc, char *argv[])
{
char *ptbf;
int j;
int pln;
int cnt;
char *lstdat;
int i;
FILE **fbuf = NULL;
int actf;
int lncnt;
int col;
int pagecnt;
int fproc;
char *buf = NULL;
char *hbuf = NULL;
char *ohbuf;
const char *fname;
int ips = 0;
int cps = 0;
int ops = 0;
int mor = 0;
int retval = 1;
/*
* array of FILE *, one for each operand
*/
if ((fbuf = (FILE **)malloc((unsigned)clcnt*sizeof(FILE *))) == NULL) {
mfail();
goto out;
}
/*
* page header
*/
if ((hbuf = malloc((unsigned)(HDBUF + offst)*sizeof(char))) == NULL) {
mfail();
goto out;
}
ohbuf = hbuf + offst;
/*
* do not know how many columns yet. The number of operands provide an
* upper bound on the number of columns. We use the number of files
* we can open successfully to set the number of columns. The operation
* of the merge operation (-m) in relation to unsuccessful file opens
* is unspecified by posix.
*/
j = 0;
while (j < clcnt) {
if ((fbuf[j] = nxtfile(argc, argv, &fname, ohbuf, 1)) == NULL)
break;
if (pgnm && (inskip(fbuf[j], pgnm, lines)))
fbuf[j] = NULL;
++j;
}
/*
* if no files, exit
*/
if (!j)
goto out;
/*
* calculate page boundaries based on open file count
*/
clcnt = j;
if (nmwd) {
colwd = (pgwd - clcnt - nmwd)/clcnt;
pgwd = ((colwd + 1) * clcnt) - nmwd - 2;
} else {
colwd = (pgwd + 1 - clcnt)/clcnt;
pgwd = ((colwd + 1) * clcnt) - 1;
}
if (colwd < 1) {
(void)fprintf(err,
"pr: page width too small for %d columns\n", clcnt);
goto out;
}
actf = clcnt;
col = colwd + 1;
/*
* line buffer
*/
if ((buf = malloc((unsigned)(pgwd+offst+1)*sizeof(char))) == NULL) {
mfail();
goto out;
}
if (offst) {
(void)memset(buf, (int)' ', offst);
(void)memset(hbuf, (int)' ', offst);
}
if (pgnm)
pagecnt = pgnm;
else
pagecnt = 1;
lncnt = 0;
/*
* continue to loop while any file still has data
*/
while (actf > 0) {
ttypause(pagecnt);
/*
* loop by line
*/
for (i = 0; i < lines; ++i) {
ptbf = buf + offst;
lstdat = ptbf;
if (nmwd) {
/*
* add line number to line
*/
addnum(ptbf, nmwd, ++lncnt);
ptbf += nmwd;
*ptbf++ = nmchar;
}
j = 0;
fproc = 0;
/*
* loop by column
*/
for (j = 0; j < clcnt; ++j) {
if (fbuf[j] == NULL) {
/*
* empty column; EOF
*/
cnt = 0;
} else if ((cnt = inln(fbuf[j], ptbf, colwd,
&cps, 1, &mor)) < 0) {
/*
* EOF hit; no data
*/
if (fbuf[j] != stdin)
(void)fclose(fbuf[j]);
fbuf[j] = NULL;
--actf;
cnt = 0;
} else {
/*
* process file data
*/
ptbf += cnt;
lstdat = ptbf;
fproc++;
}
/*
* if last ACTIVE column, done with line
*/
if (fproc >= actf)
break;
/*
* pad to end of column
*/
if (sflag) {
*ptbf++ = schar;
} else if ((pln = col - cnt) > 0) {
(void)memset(ptbf, (int)' ', pln);
ptbf += pln;
}
}
/*
* calculate data in line
*/
if ((j = lstdat - buf) <= offst)
break;
if (!i && !nohead && prhead(hbuf, fname, pagecnt))
goto out;
/*
* output line
*/
if (otln(buf, j, &ips, &ops, 0))
goto out;
/*
* if no more active files, done
*/
if (actf <= 0) {
++i;
break;
}
}
/*
* pad to end of page
*/
if (i && prtail(lines-i, 0))
goto out;
++pagecnt;
}
if (eoptind < argc)
goto out;
retval = 0;
out:
free(buf);
free(hbuf);
free(fbuf);
return(retval);
}
/*
* horzcol: print files with more than one column of output across a page
*/
int
horzcol(int argc, char *argv[])
{
char *ptbf;
int pln;
int cnt = -1;
char *lstdat;
int col = colwd + 1;
int j;
int i;
int lncnt;
int pagecnt;
char *buf;
char *hbuf;
char *ohbuf;
const char *fname;
FILE *inf;
int ips = 0;
int cps = 0;
int ops = 0;
int mor = 0;
if ((buf = malloc((unsigned)(pgwd+offst+1)*sizeof(char))) == NULL) {
mfail();
return(1);
}
/*
* page header
*/
if ((hbuf = malloc((unsigned)(HDBUF + offst)*sizeof(char))) == NULL) {
free(buf);
mfail();
return(1);
}
ohbuf = hbuf + offst;
if (offst) {
(void)memset(buf, (int)' ', offst);
(void)memset(hbuf, (int)' ', offst);
}
/*
* loop by file
*/
while ((inf = nxtfile(argc, argv, &fname, ohbuf, 0)) != NULL) {
if (pgnm) {
if (inskip(inf, pgnm, lines))
continue;
pagecnt = pgnm;
} else
pagecnt = 1;
lncnt = 0;
/*
* loop by page
*/
for(;;) {
ttypause(pagecnt);
/*
* loop by line
*/
for (i = 0; i < lines; ++i) {
ptbf = buf + offst;
lstdat = ptbf;
j = 0;
/*
* loop by col
*/
for(;;) {
if (nmwd) {
/*
* add number to column
*/
addnum(ptbf, nmwd, ++lncnt);
ptbf += nmwd;
*ptbf++ = nmchar;
}
/*
* input line
*/
if ((cnt = inln(inf,ptbf,colwd,&cps,1,
&mor)) < 0)
break;
ptbf += cnt;
lstdat = ptbf;
/*
* if last line skip padding
*/
if (++j >= clcnt)
break;
/*
* pad to end of column
*/
if (sflag)
*ptbf++ = schar;
else if ((pln = col - cnt) > 0) {
(void)memset(ptbf,(int)' ',pln);
ptbf += pln;
}
}
/*
* determine line length
*/
if ((j = lstdat - buf) <= offst)
break;
if (!i && !nohead &&
prhead(hbuf, fname, pagecnt))
goto err;
/*
* output line
*/
if (otln(buf, j, &ips, &ops, 0))
goto err;
}
/*
* pad to end of page
*/
if (i && prtail(lines-i, 0))
goto err;
/*
* if EOF go to next file
*/
if (cnt < 0)
break;
++pagecnt;
}
if (inf != stdin)
(void)fclose(inf);
}
if (eoptind < argc)
goto err;
free(hbuf);
free(buf);
return(0);
err:
free(hbuf);
free(buf);
return(1);
}
/*
* vertcol: print files with more than one column of output down a page
*/
int
vertcol(int argc, char *argv[])
{
char *ptbf;
char **lstdat = NULL;
int i;
int j;
int cnt = -1;
int pln;
int *indy = NULL;
int cvc;
int *lindy = NULL;
int lncnt;
int stp;
int pagecnt;
int col = colwd + 1;
int mxlen = pgwd + offst + 1;
int mclcnt = clcnt - 1;
struct vcol *vc = NULL;
int mvc;
int tvc;
int cw = nmwd + 1;
int fullcol;
char *buf = NULL;
char *hbuf = NULL;
char *ohbuf;
const char *fname;
FILE *inf;
int ips = 0;
int cps = 0;
int ops = 0;
int mor = 0;
int retval = 1;
/*
* allocate page buffer
*/
if ((buf = malloc((unsigned)lines*mxlen*sizeof(char))) == NULL) {
mfail();
return(1);
}
/*
* allocate page header
*/
if ((hbuf = malloc((unsigned)(HDBUF + offst)*sizeof(char))) == NULL) {
mfail();
goto out;
}
ohbuf = hbuf + offst;
if (offst)
(void)memset(hbuf, (int)' ', offst);
/*
* col pointers when no headers
*/
mvc = lines * clcnt;
if ((vc =
(struct vcol *)malloc((unsigned)mvc*sizeof(struct vcol))) == NULL) {
mfail();
goto out;
}
/*
* pointer into page where last data per line is located
*/
if ((lstdat = (char **)malloc((unsigned)lines*sizeof(char *))) == NULL){
mfail();
goto out;
}
/*
* fast index lookups to locate start of lines
*/
if ((indy = (int *)malloc((unsigned)lines*sizeof(int))) == NULL) {
mfail();
goto out;
}
if ((lindy = (int *)malloc((unsigned)lines*sizeof(int))) == NULL) {
mfail();
goto out;
}
if (nmwd)
fullcol = col + cw;
else
fullcol = col;
/*
* initialize buffer lookup indexes and offset area
*/
for (j = 0; j < lines; ++j) {
lindy[j] = j * mxlen;
indy[j] = lindy[j] + offst;
if (offst) {
ptbf = buf + lindy[j];
(void)memset(ptbf, (int)' ', offst);
ptbf += offst;
} else
ptbf = buf + indy[j];
lstdat[j] = ptbf;
}
/*
* loop by file
*/
while ((inf = nxtfile(argc, argv, &fname, ohbuf, 0)) != NULL) {
if (pgnm) {
/*
* skip to requested page
*/
if (inskip(inf, pgnm, lines))
continue;
pagecnt = pgnm;
} else
pagecnt = 1;
lncnt = 0;
/*
* loop by page
*/
for(;;) {
ttypause(pagecnt);
/*
* loop by column
*/
cvc = 0;
for (i = 0; i < clcnt; ++i) {
j = 0;
/*
* if last column, do not pad
*/
if (i == mclcnt)
stp = 1;
else
stp = 0;
/*
* loop by line
*/
for(;;) {
/*
* is this first column
*/
if (!i) {
ptbf = buf + indy[j];
lstdat[j] = ptbf;
} else
ptbf = lstdat[j];
vc[cvc].pt = ptbf;
/*
* add number
*/
if (nmwd) {
addnum(ptbf, nmwd, ++lncnt);
ptbf += nmwd;
*ptbf++ = nmchar;
}
/*
* input next line
*/
cnt = inln(inf,ptbf,colwd,&cps,1,&mor);
vc[cvc++].cnt = cnt;
if (cnt < 0)
break;
ptbf += cnt;
/*
* pad all but last column on page
*/
if (!stp) {
/*
* pad to end of column
*/
if (sflag)
*ptbf++ = schar;
else if ((pln = col-cnt) > 0) {
(void)memset(ptbf,
(int)' ',pln);
ptbf += pln;
}
}
/*
* remember last char in line
*/
lstdat[j] = ptbf;
if (++j >= lines)
break;
}
if (cnt < 0)
break;
}
/*
* when -t (no header) is specified the spec requires
* the min number of lines. The last page may not have
* balanced length columns. To fix this we must reorder
* the columns. This is a very slow technique so it is
* only used under limited conditions. Without -t, the
* balancing of text columns is unspecified. To NOT
* balance the last page, add the global variable
* nohead to the if statement below e.g.
*
* if ((cnt < 0) && nohead && cvc ......
*/
--cvc;
/*
* check to see if last page needs to be reordered
*/
if ((cnt < 0) && cvc && ((mvc-cvc) >= clcnt)){
pln = cvc/clcnt;
if (cvc % clcnt)
++pln;
/*
* print header
*/
if (!nohead && prhead(hbuf, fname, pagecnt))
goto out;
for (i = 0; i < pln; ++i) {
ips = 0;
ops = 0;
if (offst &&
otln(buf,offst,&ips,&ops,1))
goto out;
tvc = i;
for (j = 0; j < clcnt; ++j) {
/*
* determine column length
*/
if (j == mclcnt) {
/*
* last column
*/
cnt = vc[tvc].cnt;
if (nmwd)
cnt += cw;
} else if (sflag) {
/*
* single ch between
*/
cnt = vc[tvc].cnt + 1;
if (nmwd)
cnt += cw;
} else
cnt = fullcol;
if (otln(vc[tvc].pt, cnt, &ips,
&ops, 1))
goto out;
tvc += pln;
if (tvc >= cvc)
break;
}
/*
* terminate line
*/
if (otln(buf, 0, &ips, &ops, 0))
goto out;
}
/*
* pad to end of page
*/
if (prtail((lines - pln), 0))
goto out;
/*
* done with output, go to next file
*/
break;
}
/*
* determine how many lines to output
*/
if (i > 0)
pln = lines;
else
pln = j;
/*
* print header
*/
if (pln && !nohead && prhead(hbuf, fname, pagecnt))
goto out;
/*
* output each line
*/
for (i = 0; i < pln; ++i) {
ptbf = buf + lindy[i];
if ((j = lstdat[i] - ptbf) <= offst)
break;
if (otln(ptbf, j, &ips, &ops, 0))
goto out;
}
/*
* pad to end of page
*/
if (pln && prtail((lines - pln), 0))
goto out;
/*
* if EOF go to next file
*/
if (cnt < 0)
break;
++pagecnt;
}
if (inf != stdin)
(void)fclose(inf);
}
if (eoptind < argc)
goto out;
retval = 0;
out:
free(lindy);
free(indy);
free(lstdat);
free(vc);
free(hbuf);
free(buf);
return(retval);
}
/*
* onecol: print files with only one column of output.
* Line length is unlimited.
*/
int
onecol(int argc, char *argv[])
{
int cnt = -1;
int off;
int lrgln;
int linecnt;
int num;
int lncnt;
int pagecnt;
int ips;
int ops;
int cps;
char *obuf;
char *lbuf;
char *nbuf;
char *hbuf;
char *ohbuf;
FILE *inf;
const char *fname;
int mor;
if (nmwd)
num = nmwd + 1;
else
num = 0;
off = num + offst;
/*
* allocate line buffer
*/
if ((obuf = malloc((unsigned)(LBUF + off)*sizeof(char))) == NULL) {
mfail();
return(1);
}
/*
* allocate header buffer
*/
if ((hbuf = malloc((unsigned)(HDBUF + offst)*sizeof(char))) == NULL) {
free(obuf);
mfail();
return(1);
}
ohbuf = hbuf + offst;
nbuf = obuf + offst;
lbuf = nbuf + num;
if (num)
nbuf[--num] = nmchar;
if (offst) {
(void)memset(obuf, (int)' ', offst);
(void)memset(hbuf, (int)' ', offst);
}
/*
* loop by file
*/
while ((inf = nxtfile(argc, argv, &fname, ohbuf, 0)) != NULL) {
if (pgnm) {
/*
* skip to specified page
*/
if (inskip(inf, pgnm, lines))
continue;
pagecnt = pgnm;
} else
pagecnt = 1;
lncnt = 0;
/*
* loop by page
*/
for(;;) {
linecnt = 0;
lrgln = 0;
ops = 0;
ips = 0;
cps = 0;
ttypause(pagecnt);
/*
* loop by line
*/
while (linecnt < lines) {
/*
* input next line
*/
if ((cnt = inln(inf,lbuf,LBUF,&cps,0,&mor)) < 0)
break;
if (!linecnt && !nohead &&
prhead(hbuf, fname, pagecnt))
goto err;
/*
* start of new line.
*/
if (!lrgln) {
if (num)
addnum(nbuf, num, ++lncnt);
if (otln(obuf,cnt+off, &ips, &ops, mor))
goto err;
} else if (otln(lbuf, cnt, &ips, &ops, mor))
goto err;
/*
* if line bigger than buffer, get more
*/
if (mor) {
lrgln = 1;
continue;
}
/*
* whole line rcvd. reset tab proc. state
*/
++linecnt;
lrgln = 0;
ops = 0;
ips = 0;
}
/*
* fill to end of page
*/
if (linecnt && prtail(lines-linecnt-lrgln, lrgln))
goto err;
/*
* On EOF go to next file
*/
if (cnt < 0)
break;
++pagecnt;
}
if (inf != stdin)
(void)fclose(inf);
}
if (eoptind < argc)
goto err;
free(hbuf);
free(obuf);
return(0);
err:
free(hbuf);
free(obuf);
return(1);
}
/*
* mulfile: print files with more than one column of output and
* more than one file concurrently
*/
int
mulfile(int argc, char *argv[])
{
char *ptbf;
int j;
int pln;
int *rc;
int cnt;
char *lstdat;
int i;
FILE **fbuf = NULL;
int actf;
int lncnt;
int col;
int pagecnt;
int fproc;
char *buf = NULL;
char *hbuf = NULL;
char *ohbuf;
char *fname;
int ips = 0;
int cps = 0;
int ops = 0;
int mor = 0;
int error = 1;
/*
* array of FILE *, one for each operand
*/
if ((fbuf = calloc((unsigned)clcnt, sizeof(FILE *))) == NULL)
goto oomem;
/*
* array of int *, one for each operand
*/
if ((rc = calloc((unsigned)clcnt, sizeof(int))) == NULL)
goto oomem;
/*
* page header
*/
if ((hbuf = malloc((unsigned)HDBUF + offst)) == NULL)
goto oomem;
ohbuf = hbuf + offst;
/*
* do not know how many columns yet. The number of operands provide an
* upper bound on the number of columns. We use the number of files
* we can open successfully to set the number of columns. The operation
* of the merge operation (-m) in relation to unsuccessful file opens
* is unspecified by posix.
*
* XXX - this seems moderately bogus, you'd think that specifying
* "pr -2 a b c d" would run though all the files in pairs, but
* the existing code says up two files, or fewer if one is bogus.
* fixing it would require modifying the looping structure, so be it.
*/
j = 0;
while (j < clcnt) {
if ((fbuf[j] = nxtfile(argc, argv, &fname, ohbuf, 1)) != NULL) {
rc[j] = NORMAL;
j++;
}
}
/*
* if no files, exit
*/
if (j)
clcnt = j;
else
goto out;
/*
* calculate page boundaries based on open file count
*/
if (nmwd) {
colwd = (pgwd - clcnt - nmwd)/clcnt;
pgwd = ((colwd + 1) * clcnt) - nmwd - 2;
} else {
colwd = (pgwd + 1 - clcnt)/clcnt;
pgwd = ((colwd + 1) * clcnt) - 1;
}
if (colwd < 1) {
ferrout("pr: page width too small for %d columns\n", clcnt);
goto out;
}
col = colwd + 1;
/*
* line buffer
*/
if ((buf = malloc((unsigned)pgwd + offst + 1)) == NULL)
goto oomem;
if (offst) {
(void)memset(buf, (int)' ', offst);
(void)memset(hbuf, (int)' ', offst);
}
pagecnt = 0;
lncnt = 0;
actf = clcnt;
/*
* continue to loop while any file still has data
*/
while (actf > 0) {
/*
* loop on "form"
*/
for (;;) {
/*
* loop by line
*/
for (i = 0; i < lines; ++i) {
ptbf = buf + offst;
lstdat = ptbf;
if (nmwd) {
/*
* add line number to line
*/
addnum(ptbf, nmwd, ++lncnt);
ptbf += nmwd;
*ptbf++ = nmchar;
}
fproc = 0;
/*
* loop by column
*/
for (j = 0; j < clcnt; ++j) {
if (rc[j] == NORMAL ) {
rc[j] = inln(fbuf[j], ptbf, colwd, &cnt, &cps, 1, &mor);
if (cnt >= 0) {
/*
* process file data
*/
ptbf += cnt;
lstdat = ptbf;
fproc++;
} else
cnt = 0;
if (rc[j] == END) {
/*
* EOF close file
*/
if (fbuf[j] != stdin)
(void)fclose(fbuf[j]);
--actf;
}
} else
cnt = 0;
/*
* if last ACTIVE column, done with line
*/
if (fproc >= actf)
break;
/*
* pad to end of column
*/
if (sflag) {
*ptbf++ = schar;
} else {
if (cnt >= 0)
pln = col - cnt;
else
pln = col;
if (pln > 0) {
(void)memset(ptbf, (int)' ', pln);
ptbf += pln;
}
}
}
/*
* if there was anything to do, print it
*/
if (fproc != 0) {
if (!i && prhead(hbuf, fname, ++pagecnt))
goto out;
/*
* output line
*/
if (otln(buf, lstdat-buf, &ips, &ops, 0))
goto out;
} else
break;
}
/*
* pad to end of page
*/
if (prtail(lines - i, 0))
return(1);
for (j = 0; j < clcnt; ++j)
if (rc[j] != END)
rc[j] = NORMAL;
if (actf <= 0)
break;
}
if (actf <= 0)
break;
}
if (eoptind < argc){
goto out;
} else {
error = 0;
goto out;
}
oomem:
mfail();
out:
if (fbuf) {
for (j = 0; j < clcnt; j++) {
if (fbuf[j] && fbuf[j] != stdin)
(void)fclose(fbuf[j]);
}
free(fbuf);
}
free(hbuf);
free(buf);
return error;
}
/*
* horzcol: print files with more than one column of output across a page
*/
int
horzcol(int argc, char *argv[])
{
char *ptbf;
int pln;
char *lstdat;
int col = colwd + 1;
int j;
int i;
int cnt;
int rc;
int lncnt;
int pagecnt;
char *buf = NULL;
char *hbuf = NULL;
char *ohbuf;
char *fname;
FILE *inf = NULL;
int cps = 0;
int mor = 0;
int ips = 0;
int ops = 0;
int error = 1;
if ((buf = malloc((unsigned)pgwd + offst + 1)) == NULL)
goto oomem;
/*
* page header
*/
if ((hbuf = malloc((unsigned)HDBUF + offst)) == NULL)
goto oomem;
ohbuf = hbuf + offst;
if (offst) {
(void)memset(buf, (int)' ', offst);
(void)memset(hbuf, (int)' ', offst);
}
/*
* loop by file
*/
while ((inf = nxtfile(argc, argv, &fname, ohbuf, 0)) != NULL) {
pagecnt = 0;
lncnt = 0;
/*
* loop by form
*/
for (;;) {
/*
* loop by page
*/
for(;;) {
/*
* loop by line
*/
for (i = 0; i < lines; ++i) {
ptbf = buf + offst;
lstdat = ptbf;
j = 0;
/*
* loop by col
*/
for(;;) {
if (nmwd) {
/*
* add number to column
*/
addnum(ptbf, nmwd, ++lncnt);
ptbf += nmwd;
*ptbf++ = nmchar;
}
/*
* input line
*/
rc = inln(inf,ptbf,colwd,&cnt,&cps,1, &mor);
if (cnt >= 0) {
if (!i && !j && prhead(hbuf, fname, ++pagecnt))
goto out;
ptbf += cnt;
lstdat = ptbf;
/*
* if last line skip padding
*/
if (++j >= clcnt)
break;
/*
* pad to end of column
*/
if (sflag)
*ptbf++ = schar;
else if ((pln = col - cnt) > 0) {
(void)memset(ptbf,(int)' ',pln);
ptbf += pln;
}
}
if (rc != NORMAL)
break;
}
/*
* output line if any columns on it
*/
if (j) {
if (otln(buf, lstdat-buf, &ips, &ops, 0))
goto out;
}
if (rc != NORMAL)
break;
}
/*
* pad to end of page
*/
if (prtail(lines - i, 0))
return(1);
/*
* if FORM continue
*/
if (rc == END)
break;
}
/*
* if EOF go to next file
*/
if (rc == END)
break;
}
if (inf != stdin)
(void)fclose(inf);
}
if (eoptind < argc){
goto out;
} else {
error = 0;
goto out;
}
oomem:
mfail();
out:
free(buf);
free(hbuf);
if (inf != NULL && inf != stdin)
(void)fclose(inf);
return error;
}
/*
* onecol: print files with only one column of output.
* Line length is unlimited.
*/
int
onecol(int argc, char *argv[])
{
int off;
int lrgln;
int linecnt;
int num;
int cnt;
int rc;
int lncnt;
int pagecnt;
int ips;
int ops;
int cps;
char *obuf = NULL;
char *lbuf;
char *nbuf;
char *hbuf = NULL;
char *ohbuf;
FILE *inf = NULL;
char *fname;
int mor;
int error = 1;
if (nmwd)
num = nmwd + 1;
else
num = 0;
off = num + offst;
/*
* allocate line buffer
*/
if ((obuf = malloc((unsigned)(LBUF + off)*sizeof(char))) == NULL)
goto oomem;
/*
* allocate header buffer
*/
if ((hbuf = malloc((unsigned)(HDBUF + offst)*sizeof(char))) == NULL)
goto oomem;
ohbuf = hbuf + offst;
nbuf = obuf + offst;
lbuf = nbuf + num;
if (num)
nbuf[--num] = nmchar;
if (offst) {
(void)memset(obuf, (int)' ', offst);
(void)memset(hbuf, (int)' ', offst);
}
/*
* loop by file
*/
while ((inf = nxtfile(argc, argv, &fname, ohbuf, 0)) != NULL) {
pagecnt = 0;
lncnt = 0;
/*
* loop by "form"
*/
for(;;) {
/*
* loop by page
*/
for(;;) {
linecnt = 0;
lrgln = 0;
ops = 0;
ips = 0;
cps = 0;
/*
* loop by line
*/
while (linecnt < lines) {
/*
* input next line
*/
rc = inln(inf,lbuf,LBUF,&cnt,&cps,0,&mor);
if (cnt >= 0) {
if (!lrgln)
if (!linecnt && prhead(hbuf, fname, ++pagecnt))
goto out;
/*
* start new line or continue a long one
*/
if (!lrgln) {
if (num)
addnum(nbuf, num, ++lncnt);
if (otln(obuf,cnt+off, &ips, &ops, mor))
goto out;
} else
if (otln(lbuf, cnt, &ips, &ops, mor))
goto out;
/*
* if line bigger than buffer, get more
*/
if (mor) {
lrgln = 1;
} else {
/*
* whole line rcvd. reset tab proc. state
*/
++linecnt;
lrgln = 0;
ops = 0;
ips = 0;
}
}
if (rc != NORMAL)
break;
}
/*
* fill to end of page
*/
if (prtail(lines - linecnt, lrgln))
goto out;
/*
* unless END continue
*/
if (rc == END)
break;
}
/*
* On EOF go to next file
*/
if (rc == END)
break;
}
if (inf != stdin)
(void)fclose(inf);
}
/*
* If we didn't process all the files, return error
*/
if (eoptind < argc) {
goto out;
} else {
error = 0;
goto out;
}
oomem:
mfail();
out:
free(obuf);
free(hbuf);
if (inf != NULL && inf != stdin)
(void)fclose(inf);
return error;
}
int main()
{
#ifdef TEST
freopen("input","r",stdin);
#endif
int n,q;
while (scanf("%d%d",&n,&q)==2 && n!=0)
{
int tot=0;
int last=1<<31,cnt=0;
int i;
for (i=1;i<=n;i++)
{
int x;
scanf("%d",&x);
if (x!=last)
{
if (last!=1<<31) addnum(++tot,last,i-cnt,cnt);
cnt=0;
}
last=x;
++cnt;
pos2grp[i]=tot+1;
}
addnum(++tot,last,i-cnt,cnt);
#ifdef TEST
for (i=1;i<=tot;i++) printf("number %d pos=%d cnt=%d\n",a[i][0],a[i][1],a[i][2]);
#endif
int k;
for (i=1;i<=tot;i++) f[i][0]=a[i][2]; // cnt
for (k=1;(1<<k)<=tot;k++)
{
const int limiti=tot-(1<<k)+1;
for (i=1;i<=limiti;i++)
f[i][k]=max(f[i][k-1],f[i+(1<<(k-1))][k-1]);
}
while (q--)
{
int l,r,lid,rid;
scanf("%d%d",&l,&r);
//lid=find2(tot,l);rid=find2(tot,r);
lid=pos2grp[l];
rid=pos2grp[r];
//printf("[%d-%d] ",lid,rid);
if (lid==rid)
printf("%d\n",r-l+1);
else // lid<rid<=tot
{
int ans;
ans=max(a[lid+1][1]-l,r-a[rid][1]+1);
if (lid+1!=rid)
{
++lid;--rid;
const int len=rid-lid+1;//len>=1
for (k=-1;(1<<(k+1))<=len;k++);
ans=max(ans,max(f[lid][k],f[rid-(1<<k)+1][k]));
}
printf("%d\n",ans);
}
}
}
return 0;
}
