void rectangle_constrain(WRectangle *g, const WRectangle *bounds)
{
const WRectangle tmpg=*g;
g->x=minof(maxof(tmpg.x, bounds->x), tmpg.x+tmpg.w-1);
g->y=minof(maxof(tmpg.y, bounds->y), tmpg.y+tmpg.h-1);
g->w=maxof(1, minof(bounds->x+bounds->w, tmpg.x+tmpg.w)-g->x);
g->h=maxof(1, minof(bounds->y+bounds->h, tmpg.y+tmpg.h)-g->y);
}
/*EXTL_DOC
* Set module basic settings. The parameter table may contain the
* following fields:
*
* \begin{tabularx}{\linewidth}{lX}
* \tabhead{Field & Description}
* \var{scroll_amount} & Number of pixels to scroll at a time in
* pointer-controlled menus when one extends
* beyond a border of the screen and the pointer
* touches that border. \\
* \var{scroll_delay} & Time between such scrolling events in
* milliseconds.
* \end{tabularx}
*/
EXTL_EXPORT
void mod_menu_set(ExtlTab tab)
{
int a, t;
if(extl_table_gets_i(tab, "scroll_amount", &a))
scroll_amount=maxof(0, a);
if(extl_table_gets_i(tab, "scroll_delay", &t))
scroll_time=maxof(0, t);
}
Window create_xwindow(WRootWin *rw, Window par, const WRectangle *geom, const char *name)
{
int w=maxof(1, geom->w);
int h=maxof(1, geom->h);
const char *p[1];
Window window;
window = XCreateSimpleWindow(ioncore_g.dpy, par, geom->x, geom->y, w, h,
0, 0, BlackPixel(ioncore_g.dpy, rw->xscr));
p[0] = name;
xwindow_set_text_property(window, XA_WM_NAME, p, 1);
return window;
}
void frame_border_inner_geom(const WFrame *frame, WRectangle *geom)
{
GrBorderWidths bdw;
frame_border_geom(frame, geom);
if(frame->brush!=NULL){
grbrush_get_border_widths(frame->brush, &bdw);
geom->x+=bdw.left;
geom->y+=bdw.top;
geom->w=maxof(0, geom->w-(bdw.left+bdw.right));
geom->h=maxof(0, geom->h-(bdw.top+bdw.bottom));
}
}
static void get_inner_geom(WMenu *menu, WRectangle *geom)
{
GrBorderWidths bdw;
get_outer_geom(menu, geom);
if(menu->brush!=NULL){
grbrush_get_border_widths(menu->brush, &bdw);
geom->x+=bdw.left;
geom->y+=bdw.top;
geom->w-=bdw.left+bdw.right;
geom->h-=bdw.top+bdw.bottom;
geom->w=maxof(0, geom->w);
geom->h=maxof(0, geom->h);
}
}
static void menu_firstfit(WMenu *menu, bool submenu, const WRectangle *refg)
{
WRectangle geom;
calc_size(menu, &(geom.w), &(geom.h));
if(!(menu->last_fp.mode®ION_FIT_BOUNDS)){
geom.x=menu->last_fp.g.x;
geom.y=menu->last_fp.g.y;
}else if(menu->pmenu_mode){
geom.x=refg->x;
geom.y=refg->y;
if(!submenu){
const WRectangle *maxg =
®ION_GEOM(REGION_PARENT((WRegion*)menu));
geom.x-=geom.w/2;
geom.y+=POINTER_OFFSET;
if(geom.y+MINIMUM_Y_VISIBILITY>maxg->y+maxg->h){
geom.y=maxg->y+maxg->h-MINIMUM_Y_VISIBILITY;
geom.x=refg->x+POINTER_OFFSET;
if(geom.x+geom.w>maxg->x+maxg->w)
geom.x=refg->x-geom.w-POINTER_OFFSET;
}else{
if(geom.x<0)
geom.x=0;
else if(geom.x+geom.w>maxg->x+maxg->w)
geom.x=maxg->x+maxg->w-geom.w;
}
}
}else{
const WRectangle *maxg=&(menu->last_fp.g);
if(submenu){
int l, r, t, b, xoff, yoff;
get_placement_offs(menu, &xoff, &yoff);
l=refg->x+xoff;
r=refg->x+refg->w+xoff;
t=refg->y-yoff;
b=refg->y+refg->h-yoff;
geom.x=maxof(l, r-geom.w);
if(geom.x+geom.w>maxg->x+maxg->w)
geom.x=maxg->x;
geom.y=minof(b-geom.h, t);
if(geom.y<maxg->y)
geom.y=maxg->y;
}else{
geom.x=maxg->x;
geom.y=maxg->y+maxg->h-geom.h;
}
}
window_do_fitrep(&menu->win, NULL, &geom);
}
static int scrolld_subs(WMenu *menu, int d)
{
int diff=0;
WRegion *p=REGION_PARENT_REG(menu);
const WRectangle *pg;
if(p==NULL)
return 0;
pg=®ION_GEOM(p);
while(menu!=NULL){
diff=maxof(diff, calc_diff(®ION_GEOM(menu), pg, d));
menu=menu->submenu;
}
return minof(maxof(0, diff), scroll_amount);
}
void frame_border_geom(const WFrame *frame, WRectangle *geom)
{
geom->x=0;
geom->y=0;
geom->w=REGION_GEOM(frame).w;
geom->h=REGION_GEOM(frame).h;
if(!BAR_INSIDE_BORDER(frame) && frame->brush!=NULL){
geom->y+=frame->bar_h;
geom->h=maxof(0, geom->h-frame->bar_h);
}
}
void frame_managed_geom(const WFrame *frame, WRectangle *geom)
{
uint spacing=get_spacing(frame);
frame_border_inner_geom(frame, geom);
/*
geom->x+=spacing;
geom->y+=spacing;
geom->w-=2*spacing;
geom->h-=2*spacing;
*/
if(BAR_INSIDE_BORDER(frame) && BAR_EXISTS(frame)){
geom->y+=frame->bar_h+spacing;
geom->h-=frame->bar_h+spacing;
}
geom->w=maxof(geom->w, 0);
geom->h=maxof(geom->h, 0);
}
int main(void) {
int na, nb;
puts("請輸入兩個整數：");
printf("整數1：");
scanf("%d", &na);
printf("整數2：");
scanf("%d", &nb);
printf("兩者中較大者之值為%d。\n", maxof(na, nb));
return (0);
}
static void menu_do_refit(WMenu *menu, WWindow *par, const WFitParams *oldfp)
{
WRectangle geom;
calc_size(menu, &(geom.w), &(geom.h));
if(!(menu->last_fp.mode®ION_FIT_BOUNDS)){
geom.x=menu->last_fp.g.x;
geom.y=menu->last_fp.g.y;
}else if(menu->pmenu_mode){
geom.x=REGION_GEOM(menu).x;
geom.y=REGION_GEOM(menu).y;
}else{
const WRectangle *maxg=&(menu->last_fp.g);
int xdiff=REGION_GEOM(menu).x-oldfp->g.x;
int ydiff=(REGION_GEOM(menu).y+REGION_GEOM(menu).h
-(oldfp->g.y+oldfp->g.h));
geom.x=maxof(0, minof(maxg->x+xdiff, maxg->x+maxg->w-geom.w));
geom.y=maxof(0, minof(maxg->y+maxg->h+ydiff, maxg->y+maxg->h)-geom.h);
}
window_do_fitrep(&menu->win, par, &geom);
}
/*EXTL_DOC
* Set module configuration. The following are supported:
*
* \begin{tabularx}{\linewidth}{lX}
* \tabhead{Field & Description}
* \var{autoshowcompl} & (boolean) Is auto-show-completions enabled?
* (default: true). \\
* \var{autoshowcompl_delay} & (integer) auto-show-completions delay
* in milliseconds (default: 250). \\
* \var{caseicompl} & (boolean) Turn some completions case-insensitive
* (default: false). \\
* \var{substrcompl} & (boolean) Complete on sub-strings in some cases
* (default: ftrue). \\
* \end{tabularx}
*/
EXTL_EXPORT
void mod_query_set(ExtlTab tab)
{
ModQueryConfig *c=&mod_query_config;
extl_table_gets_b(tab, "autoshowcompl", &c->autoshowcompl);
extl_table_gets_b(tab, "caseicompl", &c->caseicompl);
extl_table_gets_b(tab, "substrcompl", &c->substrcompl);
if(extl_table_gets_i(tab, "autoshowcompl_delay",
&c->autoshowcompl_delay)){
c->autoshowcompl_delay=maxof(c->autoshowcompl_delay, 0);
}
}
int main()
{
int a[] = {};
int i = 0;
int n = 5;
for (i = 0; i < n; i++) {
printf("a[%d]=", i);
scanf("%d", &a[i]);
}
printf("配列の最大値は%d\n", maxof(a, n));
return 0;
}
void menu_size_hints(WMenu *menu, WSizeHints *hints_ret)
{
int n=menu->n_entries;
int w=menu->max_entry_w;
int h=menu->entry_h*n + menu->entry_spacing*maxof(0, n-1);
if(menu->brush!=NULL){
GrBorderWidths bdw;
grbrush_get_border_widths(menu->brush, &bdw);
w+=bdw.left+bdw.right;
h+=bdw.top+bdw.bottom;
}
hints_ret->min_set=TRUE;
hints_ret->min_width=w;
hints_ret->min_height=h;
}
void frame_bar_geom(const WFrame *frame, WRectangle *geom)
{
uint off;
if(BAR_INSIDE_BORDER(frame)){
off=0; /*get_spacing(frame);*/
frame_border_inner_geom(frame, geom);
}else{
off=0;
geom->x=0;
geom->y=0;
geom->w=(frame->barmode==FRAME_BAR_SHAPED
? frame->bar_w
: REGION_GEOM(frame).w);
}
geom->x+=off;
geom->y+=off;
geom->w=maxof(0, geom->w-2*off);
geom->h=BAR_H(frame);
}
uint gr_stylespec_score2(const GrStyleSpec *spec, const GrStyleSpec *attr1,
const GrStyleSpec *attr2)
{
uint score=0;
uint i;
for(i=0; i<spec->n; i++){
int sc=scorefind(attr1, &spec->attrs[i]);
if(attr2!=NULL)
sc=maxof(sc, scorefind(attr2, &spec->attrs[i]));
if(sc==0){
score=0;
break;
}
score+=sc;
}
return score;
}
int main(int argc, const char * argv[]) {
int i;
int x,y,z,t;
unsigned long int k,m,n;
scanf("%s %s",a,b);
m=strlen(a);
n=strlen(b);
for (i=0; i<m/2; i++) {
swap(&a[i],&a[m-i-1]);
}
for (i=0; i<n/2; i++) {
swap(&b[i],&b[n-1-i]);
}
k=maxof(m, n);
t=0;
for (i=0; i<k; i++) {
x=0;
y=0;
if (a[i]) {
x=a[i]-'0';
}
if (b[i]) {
y=b[i]-'0';
}
z=x+y+t;
t=(z>=10?1:0);
z=z%10;
sum[i]=z+'0';
}
if (t) {
sum[i]='1';
}
k=strlen(sum);
for (i=(int)k-1; i>=0; i--) {
printf("%c",sum[i]);
}
return 0;
}
void f(void) {
int i = 5;
int j[256];
j[42] = 24;
printf("%d\n",maxof(3, i, j[42], 0));
}
void sizepolicy(WSizePolicy *szplcy, WRegion *reg,
const WRectangle *rq_geom, int rq_flags,
WFitParams *fp)
{
uint extra=fp->mode®ION_FIT_ROTATE;
WRectangle tmp;
if(rq_geom!=NULL)
tmp=*rq_geom;
else if(reg!=NULL)
tmp=REGION_GEOM(reg);
else
tmp=fp->g;
if((*szplcy)&SIZEPOLICY_SHRUNK){
if(reg!=NULL){
tmp.w=region_min_w(reg);
tmp.h=region_min_h(reg);
}else{
tmp.w=1;
tmp.h=1;
}
rq_flags&=~(REGION_RQGEOM_WEAK_W|REGION_RQGEOM_WEAK_H);
}
fp->mode=REGION_FIT_EXACT|extra;
switch((*szplcy)&SIZEPOLICY_MASK){
case SIZEPOLICY_GRAVITY:
gravity_stretch_policy(*szplcy, reg, &tmp, fp, FALSE, FALSE);
break;
case SIZEPOLICY_STRETCH_LEFT:
gravity_stretch_policy(org(*szplcy, SIZEPOLICY_HORIZ_LEFT|SIZEPOLICY_VERT_CENTER),
reg, &tmp, fp, FALSE, TRUE);
break;
case SIZEPOLICY_STRETCH_RIGHT:
gravity_stretch_policy(org(*szplcy, SIZEPOLICY_HORIZ_RIGHT|SIZEPOLICY_VERT_CENTER),
reg, &tmp, fp, FALSE, TRUE);
break;
case SIZEPOLICY_STRETCH_TOP:
gravity_stretch_policy(org(*szplcy, SIZEPOLICY_VERT_TOP|SIZEPOLICY_HORIZ_CENTER),
reg, &tmp, fp, TRUE, FALSE);
break;
case SIZEPOLICY_STRETCH_BOTTOM:
gravity_stretch_policy(org(*szplcy, SIZEPOLICY_VERT_BOTTOM|SIZEPOLICY_HORIZ_CENTER),
reg, &tmp, fp, TRUE, FALSE);
break;
case SIZEPOLICY_FULL_EXACT:
gravity_stretch_policy(org(*szplcy, SIZEPOLICY_VERT_CENTER|SIZEPOLICY_HORIZ_CENTER),
reg, &tmp, fp, TRUE, TRUE);
break;
case SIZEPOLICY_FREE:
if(reg!=NULL)
region_size_hints_correct(reg, &tmp.w, &tmp.h, FALSE);
rectangle_constrain(&tmp, &(fp->g));
fp->g=tmp;
break;
case SIZEPOLICY_VISIBILITY_CONSTRAINED:
if(reg!=NULL)
region_size_hints_correct(reg, &tmp.w, &tmp.h, FALSE);
{
/* Constraint such that at least min(size, CF_VISIBILITY_CONSTRAINT)
* much is visible at each border.
*/
int dx=maxof(0, tmp.w-CF_VISIBILITY_CONSTRAINT);
int dy=maxof(0, tmp.h-CF_VISIBILITY_CONSTRAINT);
tmp.x=maxof(fp->g.x-dx, minof(tmp.x, fp->g.x+fp->g.w+dx-tmp.w));
tmp.y=maxof(fp->g.y-dy, minof(tmp.y, fp->g.y+fp->g.h+dy-tmp.h));
}
fp->g=tmp;
break;
case SIZEPOLICY_UNCONSTRAINED:
if(reg!=NULL)
region_size_hints_correct(reg, &tmp.w, &tmp.h, TRUE);
fp->g=tmp;
break;
case SIZEPOLICY_FREE_GLUE:
sizepolicy_free_snap(szplcy, reg, &tmp, rq_flags, fp);
break;
case SIZEPOLICY_FULL_BOUNDS:
default:
fp->mode=REGION_FIT_BOUNDS|extra;
break;
}
}
static int fit_y(int y, int h, const WRectangle *max_geom)
{
int mh=maxof(max_geom->h, 1);
h=minof(mh, h);
return minof(maxof(y, max_geom->y), max_geom->y+mh-h);
}
static int fit_x(int x, int w, const WRectangle *max_geom)
{
int mw=maxof(max_geom->w, 1);
w=minof(mw, w);
return minof(maxof(x, max_geom->x), max_geom->x+mw-w);
}
int main_server_udp(int ipv4_sock, int ipv6_sock, in_port_t local_port) {
/* Use recvmsg/sendmsg instead of recvfrom/sendto because
the latter combination may choose a different source
HIT for the server */
int err = 0, on = 1, recvnum, sendnum, is_ipv4 = 0;
int cmsg_level, cmsg_type, highest_descriptor = -1;
fd_set read_fdset;
union {
struct sockaddr_in in4;
struct sockaddr_in6 in6;
} peer_addr, local_addr;
uint8_t cmsgbuf[CMSG_SPACE(sizeof(struct inet6_pktinfo))];
uint8_t mylovemostdata[IP_MAXPACKET];
struct iovec iov;
struct cmsghdr *cmsg = (struct cmsghdr *) cmsgbuf;
union {
struct in_pktinfo *in4;
struct inet6_pktinfo *in6;
} pktinfo;
struct msghdr msg;
FD_ZERO(&read_fdset);
FD_SET(ipv4_sock, &read_fdset);
FD_SET(ipv6_sock, &read_fdset);
highest_descriptor = maxof(2, ipv4_sock, ipv6_sock);
printf("=== Server listening INADDR_ANY/IN6ADDR_ANY ===\n");
while(select((highest_descriptor + 1), &read_fdset,
NULL, NULL, NULL)) {
/* XX FIXME: receiving two packets at the same time */
if (FD_ISSET(ipv4_sock, &read_fdset)) {
is_ipv4 = 1;
//FD_CLR(ipv4_sock, &read_fdset);
} else if (FD_ISSET(ipv6_sock, &read_fdset)) {
is_ipv4 = 0;
//FD_CLR(ipv6_sock, &read_fdset);
} else {
printf("Unhandled select event\n");
goto reset;
}
msg.msg_name = &peer_addr.in6;
msg.msg_namelen = sizeof(struct sockaddr_in6);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = cmsgbuf;
msg.msg_controllen = sizeof(cmsgbuf);
msg.msg_flags = 0;
iov.iov_base = mylovemostdata;
iov.iov_len = sizeof(mylovemostdata);
memset(mylovemostdata, 0, sizeof(mylovemostdata));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(cmsgbuf, 0, sizeof(cmsgbuf));
recvnum = recvmsg((is_ipv4 ? ipv4_sock : ipv6_sock), &msg, 0);
if (recvnum < 0) {
perror("recvmsg\n");
goto reset;
}
printf("Received %d bytes\n", recvnum);
//is_ipv4 = IN6_IS_ADDR_V4MAPPED(&peer_addr.in6.sin6_addr);
cmsg_level = (is_ipv4) ? IPPROTO_IP : IPPROTO_IPV6;
cmsg_type = (is_ipv4) ? IP_PKTINFO : IPV6_2292PKTINFO;
/* Local address comes from ancillary data passed
* with msg due to IPV6_PKTINFO socket option */
for (cmsg=CMSG_FIRSTHDR(&msg); cmsg;
cmsg=CMSG_NXTHDR(&msg,cmsg)){
if ((cmsg->cmsg_level == cmsg_level) &&
(cmsg->cmsg_type == cmsg_type)) {
/* The structure is a union, so this fills
also the pktinfo_in6 pointer */
pktinfo.in4 =
(struct in_pktinfo *)CMSG_DATA(cmsg);
break;
}
}
if (is_ipv4) {
local_addr.in4.sin_family = AF_INET;
local_addr.in4.sin_port = htons(local_port);
//local_addr.in4.sin_port = peer_addr.in6.sin6_port;
local_addr.in4.sin_addr.s_addr =
pktinfo.in4->ipi_addr.s_addr;
HIP_DEBUG_INADDR("local addr",
&local_addr.in4.sin_addr);
HIP_DEBUG("local port %d\n",
ntohs(local_addr.in4.sin_port));
HIP_DEBUG_INADDR("peer addr",
&peer_addr.in4.sin_addr);
HIP_DEBUG("peer port %d\n",
ntohs(peer_addr.in4.sin_port));
} else {
local_addr.in6.sin6_family = AF_INET6;
memcpy(&local_addr.in6.sin6_addr,
&pktinfo.in6->ipi6_addr,
sizeof(struct in6_addr));
local_addr.in6.sin6_port = htons(local_port);
HIP_DEBUG_IN6ADDR("local addr",
&local_addr.in6.sin6_addr);
HIP_DEBUG("local port %d\n",
ntohs(local_addr.in6.sin6_port));
HIP_DEBUG_IN6ADDR("peer addr",
&peer_addr.in6.sin6_addr);
HIP_DEBUG("peer port %d\n",
ntohs(peer_addr.in6.sin6_port));
}
err = udp_send_msg((is_ipv4 ? ipv4_sock : ipv6_sock),
mylovemostdata, recvnum,
(struct sockaddr *) &local_addr,
(struct sockaddr *) &peer_addr);
if (err) {
printf("Failed to echo data back\n");
}
reset:
FD_ZERO(&read_fdset);
FD_SET(ipv4_sock, &read_fdset);
FD_SET(ipv6_sock, &read_fdset);
}
out_err:
return err;
}
