Introduction
Introduction Statistics Contact Development Disclaimer Help
Whitespace normalization. - sam - An updated version of the sam text editor.
git clone git://vernunftzentrum.de/sam.git
Log
Files
Refs
LICENSE
---
commit 1cff9deb7a8839bff68b86fa5c5c4a21049bc849
parent d77dc3305c595d23651ca6cfdbfdf9a7503eac5c
Author: Rob King <[email protected]>
Date: Tue, 6 Sep 2016 17:24:43 -0500
Whitespace normalization.
Diffstat:
include/libc.h | 58 +++++++++++++++---------------
include/libg.h | 250 ++++++++++++++++----------------
include/regexp.h | 84 ++++++++++++++++----------------
libXg/Gwin.h | 14 +++++++-------
libXg/GwinP.h | 28 ++++++++++++++--------------
libXg/arc.c | 60 ++++++++++++++++----------------
libXg/arith.c | 186 ++++++++++++++++----------------
libXg/balloc.c | 76 ++++++++++++++++----------------
libXg/bitblt.c | 96 ++++++++++++++++----------------
libXg/bitbltclip.c | 114 ++++++++++++++++----------------
libXg/border.c | 38 ++++++++++++++++----------------
libXg/bscreenrect.c | 6 +++---
libXg/circle.c | 24 ++++++++++++------------
libXg/clipline.c | 336 ++++++++++++++++----------------
libXg/clipr.c | 22 +++++++++++-----------
libXg/copymasked.c | 64 ++++++++++++++++----------------
libXg/cursorset.c | 6 +++---
libXg/disc.c | 24 ++++++++++++------------
libXg/ellipse.c | 20 ++++++++++----------
libXg/font.c | 2 +-
libXg/gcs.c | 560 ++++++++++++++++----------------
libXg/getrect.c | 78 ++++++++++++++++----------------
libXg/gwin.c | 474 ++++++++++++++++----------------
libXg/latin1.c | 54 ++++++++++++++++----------------
libXg/ldconvert.c | 86 +++++++++++++++---------------
libXg/libgint.h | 46 ++++++++++++++++----------------
libXg/menuhit.c | 352 ++++++++++++++++----------------
libXg/point.c | 20 ++++++++++----------
libXg/polysegment.c | 32 ++++++++++++++++----------------
libXg/rdbitmap.c | 98 ++++++++++++++++----------------
libXg/rdbitmapfile.c | 102 ++++++++++++++++----------------
libXg/rectclip.c | 36 ++++++++++++++++----------------
libXg/rune.c | 340 ++++++++++++++++----------------
libXg/segment.c | 28 ++++++++++++++--------------
libXg/string.c | 38 ++++++++++++++++----------------
libXg/strwidth.c | 2 +-
libXg/texture.c | 62 ++++++++++++++++----------------
libXg/wrbitmap.c | 70 ++++++++++++++++----------------
libXg/wrbitmapfile.c | 74 ++++++++++++++++----------------
libXg/xtbinit.c | 514 ++++++++++++++++----------------
libframe/frbox.c | 186 ++++++++++++++++----------------
libframe/frdelete.c | 182 ++++++++++++++++----------------
libframe/frdraw.c | 76 ++++++++++++++++----------------
libframe/frinit.c | 56 ++++++++++++++++----------------
libframe/frinsert.c | 442 ++++++++++++++++----------------
libframe/frptofchar.c | 166 ++++++++++++++++----------------
libframe/frselect.c | 140 ++++++++++++++++----------------
libframe/frstr.c | 38 ++++++++++++++++----------------
libframe/frutil.c | 140 ++++++++++++++++----------------
libframe/misc.c | 90 ++++++++++++++++----------------
sam/address.c | 412 ++++++++++++++++----------------
sam/buffer.c | 264 ++++++++++++++++----------------
sam/cmd.c | 906 ++++++++++++++++----------------
sam/disc.c | 514 ++++++++++++++++----------------
sam/error.c | 162 +++++++++++++++---------------
sam/errors.h | 116 +++++++++++++++---------------
sam/file.c | 702 ++++++++++++++++----------------
sam/io.c | 414 +++++++++++++++---------------
sam/list.c | 34 ++++++++++++++++----------------
sam/mesg.c | 1202 ++++++++++++++++----------------
sam/mesg.h | 164 ++++++++++++++++----------------
sam/moveto.c | 250 ++++++++++++++++----------------
sam/multi.c | 112 ++++++++++++++++----------------
sam/parse.h | 98 ++++++++++++++++----------------
sam/rasp.c | 470 ++++++++++++++++----------------
sam/regexp.c | 1286 ++++++++++++++++----------------
sam/sam.c | 936 ++++++++++++++++----------------
sam/sam.h | 606 ++++++++++++++++----------------
sam/shell.c | 276 +++++++++++++++---------------
sam/string.c | 172 +++++++++++++++---------------
sam/sys.c | 54 ++++++++++++++++----------------
sam/unix.c | 190 +++++++++++++++---------------
sam/xec.c | 672 ++++++++++++++++----------------
samterm/flayer.c | 638 ++++++++++++++++----------------
samterm/flayer.h | 64 ++++++++++++++++----------------
samterm/icons.c | 14 +++++++-------
samterm/io.c | 218 ++++++++++++++++----------------
samterm/main.c | 678 ++++++++++++++++----------------
samterm/menu.c | 600 ++++++++++++++++----------------
samterm/mesg.c | 1136 ++++++++++++++++----------------
samterm/rasp.c | 358 ++++++++++++++++----------------
samterm/samterm.h | 252 ++++++++++++++++----------------
samterm/scroll.c | 224 ++++++++++++++++----------------
samterm/unix.c | 200 ++++++++++++++++----------------
84 files changed, 10242 insertions(+), 10242 deletions(-)
---
diff --git a/include/libc.h b/include/libc.h
@@ -1,53 +1,53 @@
/* Copyright (c) 1998 Lucent Technologies - All rights reserved. */
- /* Plan 9 C library interface */
+ /* Plan 9 C library interface */
-#define sprint sprintf
-#define dup(a,b) dup2(a,b)
-#define seek(a,b,c) lseek(a,b,c)
-#define create(name, mode, perm) creat(name, perm)
-#define exec(a,b) execv(a,b)
-#define USED(a)
+#define sprint sprintf
+#define dup(a,b) dup2(a,b)
+#define seek(a,b,c) lseek(a,b,c)
+#define create(name, mode, perm) creat(name, perm)
+#define exec(a,b) execv(a,b)
+#define USED(a)
#define SET(a)
-#define _exits(v) if (v!=0) _exit(1); else _exit…
+#define _exits(v) if (v!=0) _exit(1); else _exit(0)
enum
{
- OREAD = 0, /* open for read */
- OWRITE = 1, /* open for write */
- ORDWR = 2, /* open for read/write */
- ERRLEN = 64 /* length of error message */
+ OREAD = 0, /* open for read */
+ OWRITE = 1, /* open for write */
+ ORDWR = 2, /* open for read/write */
+ ERRLEN = 64 /* length of error message */
};
enum
{
- UTFmax = 3, /* maximum bytes per rune */
- Runesync = 0x80, /* cannot represent part of a u…
- Runeself = 0x80, /* rune and utf sequences are t…
- Runeerror = 0x80 /* decoding error in utf */
+ UTFmax = 3, /* maximum bytes per rune */
+ Runesync = 0x80, /* cannot represent part of a utf sequence (<) */
+ Runeself = 0x80, /* rune and utf sequences are the same (<) */
+ Runeerror = 0x80 /* decoding error in utf */
};
/*
* new rune routines
*/
-extern int runetochar(char*, Rune*);
-extern int chartorune(Rune*, char*);
-extern int runelen(long);
-extern int fullrune(char*, int);
+extern int runetochar(char*, Rune*);
+extern int chartorune(Rune*, char*);
+extern int runelen(long);
+extern int fullrune(char*, int);
/*
* rune routines from converted str routines
*/
-extern int utflen(char*); /* was countrune */
-extern char* utfrune(char*, long);
-extern char* utfrrune(char*, long);
-extern char* utfutf(char*, char*);
+extern int utflen(char*); /* was countrune */
+extern char* utfrune(char*, long);
+extern char* utfrrune(char*, long);
+extern char* utfutf(char*, char*);
/*
- * Miscellaneous functions
+ * Miscellaneous functions
*/
-extern int notify (void(*)(void *, char *));
-extern int errstr(char *);
-extern char* getuser(void);
-extern void exits(char*);
+extern int notify (void(*)(void *, char *));
+extern int errstr(char *);
+extern char* getuser(void);
+extern void exits(char*);
diff --git a/include/libg.h b/include/libg.h
@@ -10,7 +10,7 @@
#include <commands.h>
-enum{ EMAXMSG = 128+8192 }; /* max event size */
+enum{ EMAXMSG = 128+8192 }; /* max event size */
/*
* Cursors
@@ -28,43 +28,43 @@ enum{
* Types
*/
-typedef struct Bitmap Bitmap;
-typedef struct Point Point;
-typedef struct Rectangle Rectangle;
-typedef struct Keystroke Keystroke;
-typedef struct Mouse Mouse;
-typedef struct Menu Menu;
-typedef struct Event Event;
-typedef struct RGB RGB;
+typedef struct Bitmap Bitmap;
+typedef struct Point Point;
+typedef struct Rectangle Rectangle;
+typedef struct Keystroke Keystroke;
+typedef struct Mouse Mouse;
+typedef struct Menu Menu;
+typedef struct Event Event;
+typedef struct RGB RGB;
-struct Point
+struct Point
{
- int x;
- int y;
+ int x;
+ int y;
};
struct Rectangle
{
- Point min;
- Point max;
+ Point min;
+ Point max;
};
-struct Bitmap
+struct Bitmap
{
- Rectangle r; /* rectangle in data area, local coords */
- Rectangle clipr; /* clipping region */
- int ldepth;
- int id; /* as known by the X server */
- Bitmap *cache; /* zero; distinguishes bitmap fro…
+ Rectangle r; /* rectangle in data area, local coords */
+ Rectangle clipr; /* clipping region */
+ int ldepth;
+ int id; /* as known by the X server */
+ Bitmap *cache; /* zero; distinguishes bitmap from layer */
XftDraw *fd; /* font drawable */
- int flag; /* flag used by X implementation of li…
+ int flag; /* flag used by X implementation of libg */
};
-struct Mouse
+struct Mouse
{
- int buttons; /* bit array: LMR=124 */
- Point xy;
- unsigned long msec;
+ int buttons; /* bit array: LMR=124 */
+ Point xy;
+ unsigned long msec;
};
struct Keystroke
@@ -77,71 +77,71 @@ struct Keystroke
struct Menu
{
- char **item;
- char *(*gen)(int);
- int lasthit;
+ char **item;
+ char *(*gen)(int);
+ int lasthit;
};
-struct Event
+struct Event
{
- Keystroke keystroke;
- Mouse mouse;
- int n; /* number of characters in mesage…
- unsigned char data[EMAXMSG]; /* message from an arbitrar…
+ Keystroke keystroke;
+ Mouse mouse;
+ int n; /* number of characters in mesage */
+ unsigned char data[EMAXMSG]; /* message from an arbitrary file descript…
};
struct RGB
{
- unsigned long red;
- unsigned long green;
- unsigned long blue;
+ unsigned long red;
+ unsigned long green;
+ unsigned long blue;
};
/*
* Codes for bitblt etc.
*
- * D
- * 0 1
+ * D
+ * 0 1
* ---------
- * 0 | 1 | 2 |
+ * 0 | 1 | 2 |
* S |---|---|
- * 1 | 4 | 8 |
+ * 1 | 4 | 8 |
* ---------
*
- * Usually used as D|S; DorS is so tracebacks are readable.
+ * Usually used as D|S; DorS is so tracebacks are readable.
*/
typedef
-enum Fcode
+enum Fcode
{
- Zero = 0x0,
- DnorS = 0x1,
- DandnotS = 0x2,
- notS = 0x3,
- notDandS = 0x4,
- notD = 0x5,
- DxorS = 0x6,
- DnandS = 0x7,
- DandS = 0x8,
- DxnorS = 0x9,
- D = 0xA,
- DornotS = 0xB,
- S = 0xC,
- notDorS = 0xD,
- DorS = 0xE,
- F = 0xF
+ Zero = 0x0,
+ DnorS = 0x1,
+ DandnotS = 0x2,
+ notS = 0x3,
+ notDandS = 0x4,
+ notD = 0x5,
+ DxorS = 0x6,
+ DnandS = 0x7,
+ DandS = 0x8,
+ DxnorS = 0x9,
+ D = 0xA,
+ DornotS = 0xB,
+ S = 0xC,
+ notDorS = 0xD,
+ DorS = 0xE,
+ F = 0xF
} Fcode;
/*
* Miscellany
*/
-typedef void (*Errfunc)(char *);
+typedef void (*Errfunc)(char *);
extern void addlatin(char, char, short);
-extern Point add(Point, Point);
-extern Point sub(Point, Point);
-extern Point mul(Point, int);
-extern Point divpt(Point, int);
+extern Point add(Point, Point);
+extern Point sub(Point, Point);
+extern Point mul(Point, int);
+extern Point divpt(Point, int);
extern Rectangle rsubp(Rectangle, Point);
extern Rectangle raddp(Rectangle, Point);
extern Rectangle inset(Rectangle, int);
@@ -149,92 +149,92 @@ extern Rectangle rmul(Rectangle, int);
extern Rectangle rdiv(Rectangle, int);
extern Rectangle rshift(Rectangle, int);
extern Rectangle rcanon(Rectangle);
-extern Bitmap* balloc(Rectangle, int);
-extern void bfree(Bitmap*);
-extern int rectclip(Rectangle*, Rectangle);
-extern void xtbinit(Errfunc, char*, int*, char**, char**);
-extern void bclose(void);
-extern void berror(char*);
-extern void bitblt2(Bitmap*, Point, Bitmap*, Rectangle, Fcode, unsigne…
-extern void bitblt(Bitmap*, Point, Bitmap*, Rectangle, Fcode);
-extern void copymasked(Bitmap*, Point, Bitmap*, Bitmap*, Rectangle);
-extern int bitbltclip(void*);
-extern Point string(Bitmap*, Point, XftFont*, char*, Fcode);
-extern void segment(Bitmap*, Point, Point, int, Fcode);
-extern void point(Bitmap*, Point, int, Fcode);
-extern void arc(Bitmap*, Point, Point, Point, int, Fcode);
-extern void circle(Bitmap*, Point, int, int, Fcode);
-extern void disc(Bitmap*, Point, int, int, Fcode);
-extern void ellipse(Bitmap*, Point, int, int, int, Fcode);
-extern void polysegment(Bitmap *, int, Point *, int, Fcode);
-extern long strwidth(XftFont*, char*);
-extern Point strsize(XftFont*, char*);
-extern long charwidth(XftFont*, Rune);
-extern void texture(Bitmap*, Rectangle, Bitmap*, Fcode);
-extern void wrbitmap(Bitmap*, int, int, unsigned char*);
-extern void rdbitmap(Bitmap*, int, int, unsigned char*);
-extern void wrbitmapfile(int, Bitmap*);
-extern Bitmap* rdbitmapfile(int);
-extern int ptinrect(Point, Rectangle);
-extern int rectXrect(Rectangle, Rectangle);
-extern int eqpt(Point, Point);
-extern int eqrect(Rectangle, Rectangle);
-extern void border(Bitmap*, Rectangle, int, Fcode, unsigned long);
-extern void cursorswitch(unsigned int);
-extern void cursorset(Point);
+extern Bitmap* balloc(Rectangle, int);
+extern void bfree(Bitmap*);
+extern int rectclip(Rectangle*, Rectangle);
+extern void xtbinit(Errfunc, char*, int*, char**, char**);
+extern void bclose(void);
+extern void berror(char*);
+extern void bitblt2(Bitmap*, Point, Bitmap*, Rectangle, Fcode, unsigned long,…
+extern void bitblt(Bitmap*, Point, Bitmap*, Rectangle, Fcode);
+extern void copymasked(Bitmap*, Point, Bitmap*, Bitmap*, Rectangle);
+extern int bitbltclip(void*);
+extern Point string(Bitmap*, Point, XftFont*, char*, Fcode);
+extern void segment(Bitmap*, Point, Point, int, Fcode);
+extern void point(Bitmap*, Point, int, Fcode);
+extern void arc(Bitmap*, Point, Point, Point, int, Fcode);
+extern void circle(Bitmap*, Point, int, int, Fcode);
+extern void disc(Bitmap*, Point, int, int, Fcode);
+extern void ellipse(Bitmap*, Point, int, int, int, Fcode);
+extern void polysegment(Bitmap *, int, Point *, int, Fcode);
+extern long strwidth(XftFont*, char*);
+extern Point strsize(XftFont*, char*);
+extern long charwidth(XftFont*, Rune);
+extern void texture(Bitmap*, Rectangle, Bitmap*, Fcode);
+extern void wrbitmap(Bitmap*, int, int, unsigned char*);
+extern void rdbitmap(Bitmap*, int, int, unsigned char*);
+extern void wrbitmapfile(int, Bitmap*);
+extern Bitmap* rdbitmapfile(int);
+extern int ptinrect(Point, Rectangle);
+extern int rectXrect(Rectangle, Rectangle);
+extern int eqpt(Point, Point);
+extern int eqrect(Rectangle, Rectangle);
+extern void border(Bitmap*, Rectangle, int, Fcode, unsigned long);
+extern void cursorswitch(unsigned int);
+extern void cursorset(Point);
extern Rectangle bscreenrect(Rectangle*);
-extern void bflush(void);
-extern int clipline(Rectangle, Point*, Point*);
-extern int clipr(Bitmap*, Rectangle);
-extern int scrpix(int*,int*);
+extern void bflush(void);
+extern int clipline(Rectangle, Point*, Point*);
+extern int clipr(Bitmap*, Rectangle);
+extern int scrpix(int*,int*);
extern unsigned long getbg(void);
-extern void einit(unsigned long);
+extern void einit(unsigned long);
extern unsigned long estart(unsigned long, int, int);
extern unsigned long etimer(unsigned long, long);
extern unsigned long event(Event*);
extern unsigned long eread(unsigned long, Event*);
-extern Mouse emouse(void);
-extern Keystroke ekbd(void);
-extern void pushkbd(int c);
-extern int ecanread(unsigned long);
-extern int ecanmouse(void);
-extern int ecankbd(void);
-extern void ereshaped(Rectangle); /* supplied by user */
-extern void eflush(unsigned long);
-extern int menuhit(int, Mouse*, Menu*);
+extern Mouse emouse(void);
+extern Keystroke ekbd(void);
+extern void pushkbd(int c);
+extern int ecanread(unsigned long);
+extern int ecanmouse(void);
+extern int ecankbd(void);
+extern void ereshaped(Rectangle); /* supplied by user */
+extern void eflush(unsigned long);
+extern int menuhit(int, Mouse*, Menu*);
extern Rectangle getrect(int, Mouse*);
extern unsigned long rgbpix(Bitmap*, RGB);
-extern void rdcolmap(Bitmap*, RGB*);
-extern void wrcolmap(Bitmap*, RGB*);
+extern void rdcolmap(Bitmap*, RGB*);
+extern void wrcolmap(Bitmap*, RGB*);
extern void raisewindow(void);
/* Extra functions supplied by libXg */
-extern int snarfswap(char*, int, char**);
-extern int scrollfwdbut(void);
+extern int snarfswap(char*, int, char**);
+extern int scrollfwdbut(void);
enum{
- Emouse = 1,
- Ekeyboard = 2
+ Emouse = 1,
+ Ekeyboard = 2
};
-extern Point Pt(int, int);
+extern Point Pt(int, int);
extern Rectangle Rect(int, int, int, int);
extern Rectangle Rpt(Point, Point);
-#define Dx(r) ((r).max.x-(r).min.x)
-#define Dy(r) ((r).max.y-(r).min.y)
+#define Dx(r) ((r).max.x-(r).min.x)
+#define Dy(r) ((r).max.y-(r).min.y)
-extern Bitmap screen;
-extern XftFont *font;
+extern Bitmap screen;
+extern XftFont *font;
extern XftColor fontcolor;
extern XftColor bgcolor;
-#define BGSHORT(p) (((p)[0]<<0) | ((p)[1]<<8))
-#define BGLONG(p) ((BGSHORT(p)<<0) | (BGSHORT(p+2)<<16))
-#define BPSHORT(p, v) ((p)[0]=(v), (p)[1]=((v)>>8))
-#define BPLONG(p, v) (BPSHORT(p, (v)), BPSHORT(p+2, (v)>…
+#define BGSHORT(p) (((p)[0]<<0) | ((p)[1]<<8))
+#define BGLONG(p) ((BGSHORT(p)<<0) | (BGSHORT(p+2)<<16))
+#define BPSHORT(p, v) ((p)[0]=(v), (p)[1]=((v)>>8))
+#define BPLONG(p, v) (BPSHORT(p, (v)), BPSHORT(p+2, (v)>>16))
#endif
diff --git a/include/regexp.h b/include/regexp.h
@@ -1,65 +1,65 @@
/* Copyright (c) 1998 Lucent Technologies - All rights reserved. */
-typedef struct Resub Resub;
-typedef struct Reclass Reclass;
-typedef struct Reinst Reinst;
-typedef struct Reprog Reprog;
+typedef struct Resub Resub;
+typedef struct Reclass Reclass;
+typedef struct Reinst Reinst;
+typedef struct Reprog Reprog;
/*
- * Sub expression matches
+ * Sub expression matches
*/
struct Resub{
- union
- {
- char *sp;
- Rune *rsp;
- }s;
- union
- {
- char *ep;
- Rune *rep;
- }e;
+ union
+ {
+ char *sp;
+ Rune *rsp;
+ }s;
+ union
+ {
+ char *ep;
+ Rune *rep;
+ }e;
};
/*
- * character class, each pair of rune's defines a range
+ * character class, each pair of rune's defines a range
*/
struct Reclass{
- Rune *end;
- Rune spans[64];
+ Rune *end;
+ Rune spans[64];
};
/*
- * Machine instructions
+ * Machine instructions
*/
struct Reinst{
- int type;
- union {
- Reclass *cp; /* class pointer */
- Rune r; /* character */
- int subid; /* sub-expression id for RBRA…
- Reinst *right; /* right child of OR */
- }u1;
- union { /* regexp relies on these two being in the same union */
- Reinst *left; /* left child of OR */
- Reinst *next; /* next instruction for CAT & LBR…
- }u2;
+ int type;
+ union {
+ Reclass *cp; /* class pointer */
+ Rune r; /* character */
+ int subid; /* sub-expression id for RBRA and LBRA */
+ Reinst *right; /* right child of OR */
+ }u1;
+ union { /* regexp relies on these two being in the same union */
+ Reinst *left; /* left child of OR */
+ Reinst *next; /* next instruction for CAT & LBRA */
+ }u2;
};
/*
- * Reprogram definition
+ * Reprogram definition
*/
struct Reprog{
- Reinst *startinst; /* start pc */
- Reclass class[16]; /* .data */
- Reinst firstinst[5]; /* .text */
+ Reinst *startinst; /* start pc */
+ Reclass class[16]; /* .data */
+ Reinst firstinst[5]; /* .text */
};
-extern Reprog *regcomp(char*);
-extern Reprog *regcomplit(char*);
-extern Reprog *regcompnl(char*);
-extern void regerror(char*);
-extern int regexec(Reprog*, char*, Resub*, int);
-extern void regsub(char*, char*, Resub*, int);
-extern int rregexec(Reprog*, Rune*, Resub*, int);
-extern void rregsub(Rune*, Rune*, Resub*, int);
+extern Reprog *regcomp(char*);
+extern Reprog *regcomplit(char*);
+extern Reprog *regcompnl(char*);
+extern void regerror(char*);
+extern int regexec(Reprog*, char*, Resub*, int);
+extern void regsub(char*, char*, Resub*, int);
+extern int rregexec(Reprog*, Rune*, Resub*, int);
+extern void rregsub(Rune*, Rune*, Resub*, int);
diff --git a/libXg/Gwin.h b/libXg/Gwin.h
@@ -25,13 +25,13 @@ typedef struct _GwinRec *GwinWidget;
/* Type definition for gwin resources */
typedef struct {
- int buttons;
- struct {
- int x;
- int y;
- } xy;
- unsigned long msec;
- } Gwinmouse;
+ int buttons;
+ struct {
+ int x;
+ int y;
+ } xy;
+ unsigned long msec;
+ } Gwinmouse;
typedef void (*Reshapefunc)(int, int, int, int);
typedef void (*Charfunc)(int, int, int, int, int);
diff --git a/libXg/GwinP.h b/libXg/GwinP.h
@@ -8,20 +8,20 @@
/* Gwin instance part */
typedef struct {
- /* New resource fields */
- Pixel foreground;
- Boolean forwardr; /* does right button scroll fo…
- Reshapefunc reshaped; /* Notify app of reshape */
- Charfunc gotchar; /* Notify app of char arrival */
- Mousefunc gotmouse; /* Notify app of mouse change */
- String selection; /* Current selection */
- int compose;
+ /* New resource fields */
+ Pixel foreground;
+ Boolean forwardr; /* does right button scroll forward? */
+ Reshapefunc reshaped; /* Notify app of reshape */
+ Charfunc gotchar; /* Notify app of char arrival */
+ Mousefunc gotmouse; /* Notify app of mouse change */
+ String selection; /* Current selection */
+ int compose;
} GwinPart;
/* Full instance record */
typedef struct _GwinRec {
- CorePart core;
- GwinPart gwin;
+ CorePart core;
+ GwinPart gwin;
} GwinRec;
/* New type for class methods */
@@ -29,14 +29,14 @@ typedef String (*SelSwapProc)(Widget, String);
/* Class part */
typedef struct {
- SelSwapProc select_swap;
- XtPointer extension;
+ SelSwapProc select_swap;
+ XtPointer extension;
} GwinClassPart;
/* Full class record */
typedef struct _GwinClassRec {
- CoreClassPart core_class;
- GwinClassPart gwin_class;
+ CoreClassPart core_class;
+ GwinClassPart gwin_class;
} GwinClassRec, *GwinWidgetClass;
/* External definition for class record */
diff --git a/libXg/arc.c b/libXg/arc.c
@@ -10,36 +10,36 @@
void
arc(Bitmap *b, Point p0, Point p1, Point p2, int v, Fcode f)
{
- unsigned int d;
- int x, y, r, start, end, delta;
- GC g;
+ unsigned int d;
+ int x, y, r, start, end, delta;
+ GC g;
- p1.x -= p0.x;
- p1.y -= p0.y;
- p2.x -= p0.x;
- p2.y -= p0.y;
- r = (int)sqrt((double)(p1.x*p1.x + p1.y*p1.y));
- start = (int)(64*rad2deg(atan2(-p2.y, p2.x)));
- end = (int)(64*rad2deg(atan2(-p1.y, p1.x)));
- if(start < 0)
- start += 64*360;
- if(end < 0)
- end += 64*360;
- delta = end - start;
- if(delta < 0)
- delta += 64*360;
- x = p0.x - r;
- y = p0.y - r;
- if(b->flag&SHIFT){
- x -= b->r.min.x;
- y -= b->r.min.y;
- }
- d = 2*r;
- g = _getfillgc(f, b, v);
- /*
- * delta is positive, so this draws counterclockwise arc
- * from start to start+delta
- */
- XDrawArc(_dpy, (Drawable)b->id, g, x, y, d, d, start, delta);
+ p1.x -= p0.x;
+ p1.y -= p0.y;
+ p2.x -= p0.x;
+ p2.y -= p0.y;
+ r = (int)sqrt((double)(p1.x*p1.x + p1.y*p1.y));
+ start = (int)(64*rad2deg(atan2(-p2.y, p2.x)));
+ end = (int)(64*rad2deg(atan2(-p1.y, p1.x)));
+ if(start < 0)
+ start += 64*360;
+ if(end < 0)
+ end += 64*360;
+ delta = end - start;
+ if(delta < 0)
+ delta += 64*360;
+ x = p0.x - r;
+ y = p0.y - r;
+ if(b->flag&SHIFT){
+ x -= b->r.min.x;
+ y -= b->r.min.y;
+ }
+ d = 2*r;
+ g = _getfillgc(f, b, v);
+ /*
+ * delta is positive, so this draws counterclockwise arc
+ * from start to start+delta
+ */
+ XDrawArc(_dpy, (Drawable)b->id, g, x, y, d, d, start, delta);
}
diff --git a/libXg/arith.c b/libXg/arith.c
@@ -6,190 +6,190 @@
Point
add(Point a, Point b)
{
- a.x += b.x;
- a.y += b.y;
- return a;
+ a.x += b.x;
+ a.y += b.y;
+ return a;
}
Point
sub(Point a, Point b)
{
- a.x -= b.x;
- a.y -= b.y;
- return a;
+ a.x -= b.x;
+ a.y -= b.y;
+ return a;
}
Rectangle
inset(Rectangle r, int n)
{
- r.min.x += n;
- r.min.y += n;
- r.max.x -= n;
- r.max.y -= n;
- return r;
+ r.min.x += n;
+ r.min.y += n;
+ r.max.x -= n;
+ r.max.y -= n;
+ return r;
}
Point
divpt(Point a, int b)
{
- a.x /= b;
- a.y /= b;
- return a;
+ a.x /= b;
+ a.y /= b;
+ return a;
}
Point
mul(Point a, int b)
{
- a.x *= b;
- a.y *= b;
- return a;
+ a.x *= b;
+ a.y *= b;
+ return a;
}
Rectangle
rsubp(Rectangle r, Point p)
{
- r.min.x -= p.x;
- r.min.y -= p.y;
- r.max.x -= p.x;
- r.max.y -= p.y;
- return r;
+ r.min.x -= p.x;
+ r.min.y -= p.y;
+ r.max.x -= p.x;
+ r.max.y -= p.y;
+ return r;
}
Rectangle
raddp(Rectangle r, Point p)
{
- r.min.x += p.x;
- r.min.y += p.y;
- r.max.x += p.x;
- r.max.y += p.y;
- return r;
+ r.min.x += p.x;
+ r.min.y += p.y;
+ r.max.x += p.x;
+ r.max.y += p.y;
+ return r;
}
Rectangle
rmul(Rectangle r, int a)
{
- if (a != 1) {
- r.min.x *= a;
- r.min.y *= a;
- r.max.x *= a;
- r.max.y *= a;
- }
- return r;
+ if (a != 1) {
+ r.min.x *= a;
+ r.min.y *= a;
+ r.max.x *= a;
+ r.max.y *= a;
+ }
+ return r;
}
Rectangle
rdiv(Rectangle r, int a)
{
- if (a != 1) {
- r.min.x /= a;
- r.min.y /= a;
- r.max.x /= a;
- r.max.y /= a;
- }
- return r;
+ if (a != 1) {
+ r.min.x /= a;
+ r.min.y /= a;
+ r.max.x /= a;
+ r.max.y /= a;
+ }
+ return r;
}
Rectangle
rshift(Rectangle r, int a)
{
- if (a > 0) {
- r.min.x <<= a;
- r.min.y <<= a;
- r.max.x <<= a;
- r.max.y <<= a;
- }
- else if (a < 0) {
- a = -a;
- r.min.x >>= a;
- r.min.y >>= a;
- r.max.x >>= a;
- r.max.y >>= a;
- }
- return r;
+ if (a > 0) {
+ r.min.x <<= a;
+ r.min.y <<= a;
+ r.max.x <<= a;
+ r.max.y <<= a;
+ }
+ else if (a < 0) {
+ a = -a;
+ r.min.x >>= a;
+ r.min.y >>= a;
+ r.max.x >>= a;
+ r.max.y >>= a;
+ }
+ return r;
}
int
eqpt(Point p, Point q)
{
- return p.x==q.x && p.y==q.y;
+ return p.x==q.x && p.y==q.y;
}
int
eqrect(Rectangle r, Rectangle s)
{
- return r.min.x==s.min.x && r.max.x==s.max.x &&
- r.min.y==s.min.y && r.max.y==s.max.y;
+ return r.min.x==s.min.x && r.max.x==s.max.x &&
+ r.min.y==s.min.y && r.max.y==s.max.y;
}
int
rectXrect(Rectangle r, Rectangle s)
{
- return r.min.x<s.max.x && s.min.x<r.max.x &&
- r.min.y<s.max.y && s.min.y<r.max.y;
+ return r.min.x<s.max.x && s.min.x<r.max.x &&
+ r.min.y<s.max.y && s.min.y<r.max.y;
}
int
rectinrect(Rectangle r, Rectangle s)
{
- /* !ptinrect(r.min, s) in line for speed */
- if(!(r.min.x>=s.min.x && r.min.x<s.max.x &&
- r.min.y>=s.min.y && r.min.y<s.max.y))
- return 0;
- return r.max.x<=s.max.x && r.max.y<=s.max.y;
+ /* !ptinrect(r.min, s) in line for speed */
+ if(!(r.min.x>=s.min.x && r.min.x<s.max.x &&
+ r.min.y>=s.min.y && r.min.y<s.max.y))
+ return 0;
+ return r.max.x<=s.max.x && r.max.y<=s.max.y;
}
int
ptinrect(Point p, Rectangle r)
{
- return p.x>=r.min.x && p.x<r.max.x &&
- p.y>=r.min.y && p.y<r.max.y;
+ return p.x>=r.min.x && p.x<r.max.x &&
+ p.y>=r.min.y && p.y<r.max.y;
}
Rectangle
rcanon(Rectangle r)
{
- int t;
- if (r.max.x < r.min.x) {
- t = r.min.x;
- r.min.x = r.max.x;
- r.max.x = t;
- }
- if (r.max.y < r.min.y) {
- t = r.min.y;
- r.min.y = r.max.y;
- r.max.y = t;
- }
- return r;
+ int t;
+ if (r.max.x < r.min.x) {
+ t = r.min.x;
+ r.min.x = r.max.x;
+ r.max.x = t;
+ }
+ if (r.max.y < r.min.y) {
+ t = r.min.y;
+ r.min.y = r.max.y;
+ r.max.y = t;
+ }
+ return r;
}
Rectangle
Rect(int x1, int y1, int x2, int y2)
{
- Rectangle r;
+ Rectangle r;
- r.min.x = x1;
- r.min.y = y1;
- r.max.x = x2;
- r.max.y = y2;
- return r;
+ r.min.x = x1;
+ r.min.y = y1;
+ r.max.x = x2;
+ r.max.y = y2;
+ return r;
}
Rectangle
Rpt(Point p1, Point p2)
{
- Rectangle r;
+ Rectangle r;
- r.min = p1;
- r.max = p2;
- return r;
+ r.min = p1;
+ r.max = p2;
+ return r;
}
Point
Pt(int x, int y)
{
- Point p;
+ Point p;
- p.x = x;
- p.y = y;
- return p;
+ p.x = x;
+ p.y = y;
+ return p;
}
diff --git a/libXg/balloc.c b/libXg/balloc.c
@@ -7,49 +7,49 @@
Bitmap*
balloc(Rectangle r, int ldepth)
{
- Bitmap *b;
+ Bitmap *b;
- b = _balloc(r, ldepth);
- bitblt(b, r.min, b, r, Zero);
- return b;
+ b = _balloc(r, ldepth);
+ bitblt(b, r.min, b, r, Zero);
+ return b;
}
Bitmap*
_balloc(Rectangle r, int ldepth)
{
- int id;
- Bitmap *b;
- int ld;
- Rectangle rx;
+ int id;
+ Bitmap *b;
+ int ld;
+ Rectangle rx;
- b = (Bitmap *)calloc(1, sizeof(Bitmap));
- if(b == 0)
- berror("balloc malloc");
- if (ldepth == 0)
- ld = 0;
- else
- ld = screen.ldepth;
- rx = r;
- if (Dx(rx) == 0)
- rx.max.x++;
- if (Dy(rx) == 0)
- rx.max.y++;
- id = (int) XCreatePixmap(_dpy, (Drawable)screen.id,
- Dx(rx), Dy(rx), _ld2d[ld]);
- b->ldepth = ldepth;
- b->r = r;
- b->clipr = r;
- b->id = id;
- b->cache = 0;
- if(ldepth == 0)
- b->flag = DP1|BL1;
- else
- b->flag = screen.flag&BL1;
- if(r.min.x==0 && r.min.y ==0)
- b->flag |= ZORG;
- else
- b->flag |= SHIFT;
- return b;
+ b = (Bitmap *)calloc(1, sizeof(Bitmap));
+ if(b == 0)
+ berror("balloc malloc");
+ if (ldepth == 0)
+ ld = 0;
+ else
+ ld = screen.ldepth;
+ rx = r;
+ if (Dx(rx) == 0)
+ rx.max.x++;
+ if (Dy(rx) == 0)
+ rx.max.y++;
+ id = (int) XCreatePixmap(_dpy, (Drawable)screen.id,
+ Dx(rx), Dy(rx), _ld2d[ld]);
+ b->ldepth = ldepth;
+ b->r = r;
+ b->clipr = r;
+ b->id = id;
+ b->cache = 0;
+ if(ldepth == 0)
+ b->flag = DP1|BL1;
+ else
+ b->flag = screen.flag&BL1;
+ if(r.min.x==0 && r.min.y ==0)
+ b->flag |= ZORG;
+ else
+ b->flag |= SHIFT;
+ return b;
}
void
@@ -57,6 +57,6 @@ bfree(Bitmap *b)
{
if (b->fd)
XftDrawDestroy(b->fd);
- XFreePixmap(_dpy, (Pixmap)b->id);
- free(b);
+ XFreePixmap(_dpy, (Pixmap)b->id);
+ free(b);
}
diff --git a/libXg/bitblt.c b/libXg/bitblt.c
@@ -13,10 +13,10 @@ bitblt(Bitmap *d, Point p, Bitmap *s, Rectangle r, Fcode f)
void
bitblt2(Bitmap *d, Point p, Bitmap *s, Rectangle r, Fcode f, unsigned long fg,…
{
- int sx, sy, dx, dy, bfunc;
- GC g;
- unsigned long plane;
- Bitmap *btmp;
+ int sx, sy, dx, dy, bfunc;
+ GC g;
+ unsigned long plane;
+ Bitmap *btmp;
if (fg == 0)
fg = _fgpixel;
@@ -24,48 +24,48 @@ bitblt2(Bitmap *d, Point p, Bitmap *s, Rectangle r, Fcode f…
if (bg == 0)
bg = _bgpixel;
- if(Dx(r)<=0 || Dy(r)<=0)
- return;
- sx = r.min.x;
- sy = r.min.y;
- if(s->flag&SHIFT){
- sx -= s->r.min.x;
- sy -= s->r.min.y;
- }
- dx = p.x;
- dy = p.y;
- if(d->flag&SHIFT){
- dx -= d->r.min.x;
- dy -= d->r.min.y;
- }
- g = _getcopygc2(f, d, s, &bfunc, fg, bg);
- if(bfunc == UseCopyArea)
- XCopyArea(_dpy, (Drawable)s->id, (Drawable)d->id, g,
- sx, sy, Dx(r), Dy(r), dx, dy);
- else if(bfunc == UseFillRectangle){
- XFillRectangle(_dpy, (Drawable)d->id, g,
- dx, dy, Dx(r), Dy(r));
- }else{
- /* bfunc == UseCopyPlane */
- plane = _ld2dmask[s->ldepth];
- plane &= ~(plane>>1);
- if(0/*f == S*/)
- XCopyPlane(_dpy, (Drawable)s->id, (Drawable)d->id, g,
- sx, sy, Dx(r), Dy(r), dx, dy, plane);
- else {
- /*
- * CopyPlane can only do func code S,
- * so copy src rect into a bitmap with the same depth
- * as the dest, then do the bitblt from the tmp.
- * This won't recurse again because we only get
- * UseCopyPlane with differing bitmap depths
- */
- btmp = _balloc(Rect(0,0,Dx(r),Dy(r)), d->ldepth);
- XCopyPlane(_dpy, (Drawable)s->id, (Drawable)btmp->id, …
- sx, sy, Dx(r), Dy(r), 0, 0, plane);
- bitblt(d, p, btmp, btmp->r, f);
- bfree(btmp);
- }
- }
- XFlush(_dpy);
+ if(Dx(r)<=0 || Dy(r)<=0)
+ return;
+ sx = r.min.x;
+ sy = r.min.y;
+ if(s->flag&SHIFT){
+ sx -= s->r.min.x;
+ sy -= s->r.min.y;
+ }
+ dx = p.x;
+ dy = p.y;
+ if(d->flag&SHIFT){
+ dx -= d->r.min.x;
+ dy -= d->r.min.y;
+ }
+ g = _getcopygc2(f, d, s, &bfunc, fg, bg);
+ if(bfunc == UseCopyArea)
+ XCopyArea(_dpy, (Drawable)s->id, (Drawable)d->id, g,
+ sx, sy, Dx(r), Dy(r), dx, dy);
+ else if(bfunc == UseFillRectangle){
+ XFillRectangle(_dpy, (Drawable)d->id, g,
+ dx, dy, Dx(r), Dy(r));
+ }else{
+ /* bfunc == UseCopyPlane */
+ plane = _ld2dmask[s->ldepth];
+ plane &= ~(plane>>1);
+ if(0/*f == S*/)
+ XCopyPlane(_dpy, (Drawable)s->id, (Drawable)d->id, g,
+ sx, sy, Dx(r), Dy(r), dx, dy, plane);
+ else {
+ /*
+ * CopyPlane can only do func code S,
+ * so copy src rect into a bitmap with the same depth
+ * as the dest, then do the bitblt from the tmp.
+ * This won't recurse again because we only get
+ * UseCopyPlane with differing bitmap depths
+ */
+ btmp = _balloc(Rect(0,0,Dx(r),Dy(r)), d->ldepth);
+ XCopyPlane(_dpy, (Drawable)s->id, (Drawable)btmp->id, g,
+ sx, sy, Dx(r), Dy(r), 0, 0, plane);
+ bitblt(d, p, btmp, btmp->r, f);
+ bfree(btmp);
+ }
+ }
+ XFlush(_dpy);
}
diff --git a/libXg/bitbltclip.c b/libXg/bitbltclip.c
@@ -7,62 +7,62 @@
int
bitbltclip(void *vp)
{
- int dx, dy;
- int i;
- struct bbcarg{
- Bitmap *dm;
- Point p;
- Bitmap *sm;
- Rectangle r;
- Fcode f;
- }*bp;
+ int dx, dy;
+ int i;
+ struct bbcarg{
+ Bitmap *dm;
+ Point p;
+ Bitmap *sm;
+ Rectangle r;
+ Fcode f;
+ }*bp;
- bp = (struct bbcarg *)vp;
- dx = Dx(bp->r);
- dy = Dy(bp->r);
- if(bp->p.x < bp->dm->clipr.min.x){
- i = bp->dm->clipr.min.x-bp->p.x;
- bp->r.min.x += i;
- bp->p.x += i;
- dx -= i;
- }
- if(bp->p.y < bp->dm->clipr.min.y){
- i = bp->dm->clipr.min.y-bp->p.y;
- bp->r.min.y += i;
- bp->p.y += i;
- dy -= i;
- }
- if(bp->p.x+dx > bp->dm->clipr.max.x){
- i = bp->p.x+dx-bp->dm->clipr.max.x;
- bp->r.max.x -= i;
- dx -= i;
- }
- if(bp->p.y+dy > bp->dm->clipr.max.y){
- i = bp->p.y+dy-bp->dm->clipr.max.y;
- bp->r.max.y -= i;
- dy -= i;
- }
- if(bp->r.min.x < bp->sm->clipr.min.x){
- i = bp->sm->clipr.min.x-bp->r.min.x;
- bp->p.x += i;
- bp->r.min.x += i;
- dx -= i;
- }
- if(bp->r.min.y < bp->sm->clipr.min.y){
- i = bp->sm->clipr.min.y-bp->r.min.y;
- bp->p.y += i;
- bp->r.min.y += i;
- dy -= i;
- }
- if(bp->r.max.x > bp->sm->clipr.max.x){
- i = bp->r.max.x-bp->sm->clipr.max.x;
- bp->r.max.x -= i;
- dx -= i;
- }
- if(bp->r.max.y > bp->sm->clipr.max.y){
- i = bp->r.max.y-bp->sm->clipr.max.y;
- bp->r.max.y -= i;
- dy -= i;
- }
- return dx>0 && dy>0;
+ bp = (struct bbcarg *)vp;
+ dx = Dx(bp->r);
+ dy = Dy(bp->r);
+ if(bp->p.x < bp->dm->clipr.min.x){
+ i = bp->dm->clipr.min.x-bp->p.x;
+ bp->r.min.x += i;
+ bp->p.x += i;
+ dx -= i;
+ }
+ if(bp->p.y < bp->dm->clipr.min.y){
+ i = bp->dm->clipr.min.y-bp->p.y;
+ bp->r.min.y += i;
+ bp->p.y += i;
+ dy -= i;
+ }
+ if(bp->p.x+dx > bp->dm->clipr.max.x){
+ i = bp->p.x+dx-bp->dm->clipr.max.x;
+ bp->r.max.x -= i;
+ dx -= i;
+ }
+ if(bp->p.y+dy > bp->dm->clipr.max.y){
+ i = bp->p.y+dy-bp->dm->clipr.max.y;
+ bp->r.max.y -= i;
+ dy -= i;
+ }
+ if(bp->r.min.x < bp->sm->clipr.min.x){
+ i = bp->sm->clipr.min.x-bp->r.min.x;
+ bp->p.x += i;
+ bp->r.min.x += i;
+ dx -= i;
+ }
+ if(bp->r.min.y < bp->sm->clipr.min.y){
+ i = bp->sm->clipr.min.y-bp->r.min.y;
+ bp->p.y += i;
+ bp->r.min.y += i;
+ dy -= i;
+ }
+ if(bp->r.max.x > bp->sm->clipr.max.x){
+ i = bp->r.max.x-bp->sm->clipr.max.x;
+ bp->r.max.x -= i;
+ dx -= i;
+ }
+ if(bp->r.max.y > bp->sm->clipr.max.y){
+ i = bp->r.max.y-bp->sm->clipr.max.y;
+ bp->r.max.y -= i;
+ dy -= i;
+ }
+ return dx>0 && dy>0;
}
diff --git a/libXg/border.c b/libXg/border.c
@@ -8,23 +8,23 @@ extern unsigned long _borderpixel;
void
border(Bitmap *l, Rectangle r, int i, Fcode c, unsigned long bg)
{
- if(i > 0){
- bitblt2(l, r.min,
- l, Rect(r.min.x, r.min.y, r.max.x, r.min.y+i), c, _bor…
- bitblt2(l, Pt(r.min.x, r.max.y-i),
- l, Rect(r.min.x, r.max.y-i, r.max.x, r.max.y), c, _bor…
- bitblt2(l, Pt(r.min.x, r.min.y+i),
- l, Rect(r.min.x, r.min.y+i, r.min.x+i, r.max.y-i), c, …
- bitblt2(l, Pt(r.max.x-i, r.min.y+i),
- l, Rect(r.max.x-i, r.min.y+i, r.max.x, r.max.y-i), c, …
- }else if(i < 0){
- bitblt2(l, Pt(r.min.x, r.min.y+i),
- l, Rect(r.min.x, r.min.y+i, r.max.x, r.min.y), c, _bor…
- bitblt2(l, Pt(r.min.x, r.max.y),
- l, Rect(r.min.x, r.max.y, r.max.x, r.max.y-i), c, _bor…
- bitblt2(l, Pt(r.min.x+i, r.min.y+i),
- l, Rect(r.min.x+i, r.min.y+i, r.min.x, r.max.y-i), c, …
- bitblt2(l, Pt(r.max.x, r.min.y+i),
- l, Rect(r.max.x, r.min.y+i, r.max.x-i, r.max.y-i), c, …
- }
+ if(i > 0){
+ bitblt2(l, r.min,
+ l, Rect(r.min.x, r.min.y, r.max.x, r.min.y+i), c, _borderpixel, bg…
+ bitblt2(l, Pt(r.min.x, r.max.y-i),
+ l, Rect(r.min.x, r.max.y-i, r.max.x, r.max.y), c, _borderpixel, bg…
+ bitblt2(l, Pt(r.min.x, r.min.y+i),
+ l, Rect(r.min.x, r.min.y+i, r.min.x+i, r.max.y-i), c, _borderpixel…
+ bitblt2(l, Pt(r.max.x-i, r.min.y+i),
+ l, Rect(r.max.x-i, r.min.y+i, r.max.x, r.max.y-i), c, _borderpixel…
+ }else if(i < 0){
+ bitblt2(l, Pt(r.min.x, r.min.y+i),
+ l, Rect(r.min.x, r.min.y+i, r.max.x, r.min.y), c, _borderpixel, bg…
+ bitblt2(l, Pt(r.min.x, r.max.y),
+ l, Rect(r.min.x, r.max.y, r.max.x, r.max.y-i), c, _borderpixel, bg…
+ bitblt2(l, Pt(r.min.x+i, r.min.y+i),
+ l, Rect(r.min.x+i, r.min.y+i, r.min.x, r.max.y-i), c, _borderpixel…
+ bitblt2(l, Pt(r.max.x, r.min.y+i),
+ l, Rect(r.max.x, r.min.y+i, r.max.x-i, r.max.y-i), c, _borderpixel…
+ }
}
diff --git a/libXg/bscreenrect.c b/libXg/bscreenrect.c
@@ -12,7 +12,7 @@
Rectangle
bscreenrect(Rectangle *clipr)
{
- if(clipr)
- *clipr = screen.clipr;
- return screen.r;
+ if(clipr)
+ *clipr = screen.clipr;
+ return screen.r;
}
diff --git a/libXg/circle.c b/libXg/circle.c
@@ -7,17 +7,17 @@
void
circle(Bitmap *b, Point p, int r, int v, Fcode f)
{
- unsigned int d;
- int x, y;
- GC g;
+ unsigned int d;
+ int x, y;
+ GC g;
- x = p.x - r;
- y = p.y - r;
- if (b->flag&SHIFT){
- x -= b->r.min.x;
- y -= b->r.min.y;
- }
- d = 2*r;
- g = _getfillgc(f, b, v);
- XDrawArc(_dpy, (Drawable)b->id, g, x, y, d, d, 0, 23040/* 360 deg */);
+ x = p.x - r;
+ y = p.y - r;
+ if (b->flag&SHIFT){
+ x -= b->r.min.x;
+ y -= b->r.min.y;
+ }
+ d = 2*r;
+ g = _getfillgc(f, b, v);
+ XDrawArc(_dpy, (Drawable)b->id, g, x, y, d, d, 0, 23040/* 360 deg */);
}
diff --git a/libXg/clipline.c b/libXg/clipline.c
@@ -6,220 +6,220 @@
typedef struct Linedesc
{
- int x0;
- int y0;
- char xmajor;
- char slopeneg;
- long dminor;
- long dmajor;
+ int x0;
+ int y0;
+ char xmajor;
+ char slopeneg;
+ long dminor;
+ long dmajor;
} Linedesc;
-int _clipline(Rectangle, Point*, Point*, Linedesc*);
+int _clipline(Rectangle, Point*, Point*, Linedesc*);
-#define XYswap(p) t=(p)->x, (p)->x=(p)->y, (p)->y=t
-#define Swap(x, y) t=x, x=y, y=t
+#define XYswap(p) t=(p)->x, (p)->x=(p)->y, (p)->y=t
+#define Swap(x, y) t=x, x=y, y=t
static long
-lfloor(long x, long y) /* first integer <= x/y */
+lfloor(long x, long y) /* first integer <= x/y */
{
- if(y <= 0){
- if(y == 0)
- return x;
- y = -y;
- x = -x;
- }
- if(x < 0){ /* be careful; C div. is undefined */
- x = -x;
- x += y-1;
- return -(x/y);
- }
- return x/y;
+ if(y <= 0){
+ if(y == 0)
+ return x;
+ y = -y;
+ x = -x;
+ }
+ if(x < 0){ /* be careful; C div. is undefined */
+ x = -x;
+ x += y-1;
+ return -(x/y);
+ }
+ return x/y;
}
static long
-lceil(long x, long y) /* first integer >= x/y */
+lceil(long x, long y) /* first integer >= x/y */
{
- if(y <= 0){
- if(y == 0)
- return x;
- y = -y;
- x = -x;
- }
- if(x < 0){
- x = -x;
- return -(x/y);
- }
- x += y-1;
- return x/y;
+ if(y <= 0){
+ if(y == 0)
+ return x;
+ y = -y;
+ x = -x;
+ }
+ if(x < 0){
+ x = -x;
+ return -(x/y);
+ }
+ x += y-1;
+ return x/y;
}
int
_gminor(long x, Linedesc *l)
{
- long y;
+ long y;
- y = 2*(x-l->x0)*l->dminor + l->dmajor;
- y = lfloor(y, 2*l->dmajor) + l->y0;
- return l->slopeneg? -y : y;
+ y = 2*(x-l->x0)*l->dminor + l->dmajor;
+ y = lfloor(y, 2*l->dmajor) + l->y0;
+ return l->slopeneg? -y : y;
}
int
_gmajor(long y, Linedesc *l)
{
- long x;
-
- x = 2*((l->slopeneg? -y : y)-l->y0)*l->dmajor - l->dminor;
- x = lceil(x, 2*l->dminor) + l->x0;
- if(l->dminor)
- while(_gminor(x-1, l) == y)
- x--;
- return x;
+ long x;
+
+ x = 2*((l->slopeneg? -y : y)-l->y0)*l->dmajor - l->dminor;
+ x = lceil(x, 2*l->dminor) + l->x0;
+ if(l->dminor)
+ while(_gminor(x-1, l) == y)
+ x--;
+ return x;
}
void
gsetline(Point *pp0, Point *pp1, Linedesc *l)
{
- long dx, dy, t;
- Point endpt;
- int swapped;
- Point p0, p1;
-
- swapped = 0;
- p0 = *pp0;
- p1 = *pp1;
- l->xmajor = 1;
- l->slopeneg = 0;
- dx = p1.x - p0.x;
- dy = p1.y - p0.y;
- if(abs(dy) > abs(dx)){ /* Steep */
- l->xmajor = 0;
- XYswap(&p0);
- XYswap(&p1);
- Swap(dx, dy);
- }
- if(dx < 0){
- swapped++;
- Swap(p0.x, p1.x);
- Swap(p0.y, p1.y);
- dx = -dx;
- dy = -dy;
- }
- if(dy < 0){
- l->slopeneg = 1;
- dy = -dy;
- p0.y = -p0.y;
- }
- l->dminor = dy;
- l->dmajor = dx;
- l->x0 = p0.x;
- l->y0 = p0.y;
- p1.x = swapped? p0.x+1 : p1.x-1;
- p1.y = _gminor(p1.x, l);
- if(l->xmajor == 0){
- XYswap(&p0);
- XYswap(&p1);
- }
- if(pp0->x > pp1->x){
- *pp1 = *pp0;
- *pp0 = p1;
- }else
- *pp1 = p1;
+ long dx, dy, t;
+ Point endpt;
+ int swapped;
+ Point p0, p1;
+
+ swapped = 0;
+ p0 = *pp0;
+ p1 = *pp1;
+ l->xmajor = 1;
+ l->slopeneg = 0;
+ dx = p1.x - p0.x;
+ dy = p1.y - p0.y;
+ if(abs(dy) > abs(dx)){ /* Steep */
+ l->xmajor = 0;
+ XYswap(&p0);
+ XYswap(&p1);
+ Swap(dx, dy);
+ }
+ if(dx < 0){
+ swapped++;
+ Swap(p0.x, p1.x);
+ Swap(p0.y, p1.y);
+ dx = -dx;
+ dy = -dy;
+ }
+ if(dy < 0){
+ l->slopeneg = 1;
+ dy = -dy;
+ p0.y = -p0.y;
+ }
+ l->dminor = dy;
+ l->dmajor = dx;
+ l->x0 = p0.x;
+ l->y0 = p0.y;
+ p1.x = swapped? p0.x+1 : p1.x-1;
+ p1.y = _gminor(p1.x, l);
+ if(l->xmajor == 0){
+ XYswap(&p0);
+ XYswap(&p1);
+ }
+ if(pp0->x > pp1->x){
+ *pp1 = *pp0;
+ *pp0 = p1;
+ }else
+ *pp1 = p1;
}
/*
* Modified clip-to-rectangle algorithm
- * works in bitmaps
- * Everything in SCREEN coordinates.
+ * works in bitmaps
+ * Everything in SCREEN coordinates.
*
- * Newman & Sproull 124 (1st edition)
+ * Newman & Sproull 124 (1st edition)
*/
static int
code(Point *p, Rectangle *r)
{
- return( (p->x<r->min.x? 1 : p->x>=r->max.x? 2 : 0) |
- (p->y<r->min.y? 4 : p->y>=r->max.y? 8 : 0));
+ return( (p->x<r->min.x? 1 : p->x>=r->max.x? 2 : 0) |
+ (p->y<r->min.y? 4 : p->y>=r->max.y? 8 : 0));
}
int
clipline(Rectangle r, Point *p0, Point *p1)
{
- Linedesc l;
+ Linedesc l;
- return _clipline(r, p0, p1, &l);
+ return _clipline(r, p0, p1, &l);
}
int
_clipline(Rectangle r, Point *p0, Point *p1, Linedesc *l)
{
- int c0, c1, n;
- long t, ret;
- Point temp;
- int swapped;
-
- if(p0->x==p1->x && p0->y==p1->y)
- return 0;
- gsetline(p0, p1, l);
- /* line is now closed */
- if(l->xmajor == 0){
- XYswap(p0);
- XYswap(p1);
- XYswap(&r.min);
- XYswap(&r.max);
- }
- c0 = code(p0, &r);
- c1 = code(p1, &r);
- ret = 1;
- swapped = 0;
- n = 0;
- while(c0 | c1){
- if(c0 & c1){ /* no point of line in r */
- ret = 0;
- goto Return;
- }
- if(++n > 10){ /* horrible points; overflow etc. etc. */
- ret = 0;
- goto Return;
- }
- if(c0 == 0){ /* swap points */
- temp = *p0;
- *p0 = *p1;
- *p1 = temp;
- Swap(c0, c1);
- swapped ^= 1;
- }
- if(c0 == 0)
- break;
- if(c0 & 1){ /* push towards left edge */
- p0->x = r.min.x;
- p0->y = _gminor(p0->x, l);
- }else if(c0 & 2){ /* push towards right edge */
- p0->x = r.max.x-1;
- p0->y = _gminor(p0->x, l);
- }else if(c0 & 4){ /* push towards top edge */
- p0->y = r.min.y;
- if(l->slopeneg)
- p0->x = _gmajor(p0->y-1, l)-1;
- else
- p0->x = _gmajor(p0->y, l);
- }else if(c0 & 8){ /* push towards bottom edge */
- p0->y = r.max.y-1;
- if(l->slopeneg)
- p0->x = _gmajor(p0->y, l);
- else
- p0->x = _gmajor(p0->y+1, l)-1;
- }
- c0 = code(p0, &r);
- }
+ int c0, c1, n;
+ long t, ret;
+ Point temp;
+ int swapped;
+
+ if(p0->x==p1->x && p0->y==p1->y)
+ return 0;
+ gsetline(p0, p1, l);
+ /* line is now closed */
+ if(l->xmajor == 0){
+ XYswap(p0);
+ XYswap(p1);
+ XYswap(&r.min);
+ XYswap(&r.max);
+ }
+ c0 = code(p0, &r);
+ c1 = code(p1, &r);
+ ret = 1;
+ swapped = 0;
+ n = 0;
+ while(c0 | c1){
+ if(c0 & c1){ /* no point of line in r */
+ ret = 0;
+ goto Return;
+ }
+ if(++n > 10){ /* horrible points; overflow etc. etc. */
+ ret = 0;
+ goto Return;
+ }
+ if(c0 == 0){ /* swap points */
+ temp = *p0;
+ *p0 = *p1;
+ *p1 = temp;
+ Swap(c0, c1);
+ swapped ^= 1;
+ }
+ if(c0 == 0)
+ break;
+ if(c0 & 1){ /* push towards left edge */
+ p0->x = r.min.x;
+ p0->y = _gminor(p0->x, l);
+ }else if(c0 & 2){ /* push towards right edge */
+ p0->x = r.max.x-1;
+ p0->y = _gminor(p0->x, l);
+ }else if(c0 & 4){ /* push towards top edge */
+ p0->y = r.min.y;
+ if(l->slopeneg)
+ p0->x = _gmajor(p0->y-1, l)-1;
+ else
+ p0->x = _gmajor(p0->y, l);
+ }else if(c0 & 8){ /* push towards bottom edge */
+ p0->y = r.max.y-1;
+ if(l->slopeneg)
+ p0->x = _gmajor(p0->y, l);
+ else
+ p0->x = _gmajor(p0->y+1, l)-1;
+ }
+ c0 = code(p0, &r);
+ }
Return:
- if(l->xmajor == 0){
- XYswap(p0);
- XYswap(p1);
- }
- if(swapped){
- temp = *p0;
- *p0 = *p1;
- *p1 = temp;
- }
- return ret;
+ if(l->xmajor == 0){
+ XYswap(p0);
+ XYswap(p1);
+ }
+ if(swapped){
+ temp = *p0;
+ *p0 = *p1;
+ *p1 = temp;
+ }
+ return ret;
}
diff --git a/libXg/clipr.c b/libXg/clipr.c
@@ -7,15 +7,15 @@
int
clipr(Bitmap *d, Rectangle r)
{
- if(rectclip(&r, d->r) == 0)
- return 0;
- d->clipr = r;
- if(r.min.x != d->r.min.x ||
- r.min.y != d->r.min.y ||
- r.max.x != d->r.max.x ||
- r.max.y != d->r.max.y)
- d->flag |= CLIP;
- else
- d->flag &= ~CLIP;
- return 1;
+ if(rectclip(&r, d->r) == 0)
+ return 0;
+ d->clipr = r;
+ if(r.min.x != d->r.min.x ||
+ r.min.y != d->r.min.y ||
+ r.max.x != d->r.max.x ||
+ r.max.y != d->r.max.y)
+ d->flag |= CLIP;
+ else
+ d->flag &= ~CLIP;
+ return 1;
}
diff --git a/libXg/copymasked.c b/libXg/copymasked.c
@@ -13,37 +13,37 @@
void
copymasked(Bitmap *d, Point p, Bitmap *s, Bitmap *m, Rectangle r)
{
- int sx, sy, dx, dy;
- XGCValues gcv;
- GC g;
+ int sx, sy, dx, dy;
+ XGCValues gcv;
+ GC g;
- if(Dx(r)<=0 || Dy(r)<=0)
- return;
- sx = r.min.x;
- sy = r.min.y;
- if(s->flag&SHIFT){
- sx -= s->r.min.x;
- sy -= s->r.min.y;
- }
- dx = p.x;
- dy = p.y;
- if(d->flag&SHIFT){
- dx -= d->r.min.x;
- dy -= d->r.min.y;
- }
- gcv.fill_style = FillStippled;
- gcv.stipple = (Pixmap)m->id;
- gcv.function = GXclear;
- gcv.ts_x_origin = dx;
- gcv.ts_y_origin = dy;
- gcv.fill_style = FillStippled;
- g = _getgc(d, GCFunction|GCStipple|GCTileStipXOrigin
- |GCTileStipYOrigin|GCFillStyle, &gcv);
- XFillRectangle(_dpy, (Drawable)d->id, g,
- dx, dy, Dx(r), Dy(r));
- gcv.function = GXor;
- gcv.fill_style = FillSolid;
- g = _getgc(d, GCFunction|GCFillStyle, &gcv);
- XCopyArea(_dpy, (Drawable)s->id, (Drawable)d->id, g,
- sx, sy, Dx(r), Dy(r), dx, dy);
+ if(Dx(r)<=0 || Dy(r)<=0)
+ return;
+ sx = r.min.x;
+ sy = r.min.y;
+ if(s->flag&SHIFT){
+ sx -= s->r.min.x;
+ sy -= s->r.min.y;
+ }
+ dx = p.x;
+ dy = p.y;
+ if(d->flag&SHIFT){
+ dx -= d->r.min.x;
+ dy -= d->r.min.y;
+ }
+ gcv.fill_style = FillStippled;
+ gcv.stipple = (Pixmap)m->id;
+ gcv.function = GXclear;
+ gcv.ts_x_origin = dx;
+ gcv.ts_y_origin = dy;
+ gcv.fill_style = FillStippled;
+ g = _getgc(d, GCFunction|GCStipple|GCTileStipXOrigin
+ |GCTileStipYOrigin|GCFillStyle, &gcv);
+ XFillRectangle(_dpy, (Drawable)d->id, g,
+ dx, dy, Dx(r), Dy(r));
+ gcv.function = GXor;
+ gcv.fill_style = FillSolid;
+ g = _getgc(d, GCFunction|GCFillStyle, &gcv);
+ XCopyArea(_dpy, (Drawable)s->id, (Drawable)d->id, g,
+ sx, sy, Dx(r), Dy(r), dx, dy);
}
diff --git a/libXg/cursorset.c b/libXg/cursorset.c
@@ -10,7 +10,7 @@
void
cursorset(Point p)
{
- /* motion will be relative to window origin */
- p = sub(p, screen.r.min);
- XWarpPointer(_dpy, None, (Window)screen.id, 0, 0, 0, 0, p.x, p.y);
+ /* motion will be relative to window origin */
+ p = sub(p, screen.r.min);
+ XWarpPointer(_dpy, None, (Window)screen.id, 0, 0, 0, 0, p.x, p.y);
}
diff --git a/libXg/disc.c b/libXg/disc.c
@@ -7,17 +7,17 @@
void
disc(Bitmap *b, Point p, int r, int v, Fcode f)
{
- unsigned int d;
- int x, y;
- GC g;
+ unsigned int d;
+ int x, y;
+ GC g;
- x = p.x - r;
- y = p.y - r;
- if (b->flag&SHIFT){
- x -= b->r.min.x;
- y -= b->r.min.y;
- }
- d = 2*r;
- g = _getfillgc(f, b, v);
- XFillArc(_dpy, (Drawable)b->id, g, x, y, d, d, 0, 23040/* 360 deg */);
+ x = p.x - r;
+ y = p.y - r;
+ if (b->flag&SHIFT){
+ x -= b->r.min.x;
+ y -= b->r.min.y;
+ }
+ d = 2*r;
+ g = _getfillgc(f, b, v);
+ XFillArc(_dpy, (Drawable)b->id, g, x, y, d, d, 0, 23040/* 360 deg */);
}
diff --git a/libXg/ellipse.c b/libXg/ellipse.c
@@ -9,15 +9,15 @@
void
ellipse(Bitmap *bp, Point p, int a, int b, int v, Fcode f)
{
- int x, y;
- GC g;
+ int x, y;
+ GC g;
- x = p.x - a;
- y = p.y - b;
- if (bp->flag&SHIFT){
- x -= bp->r.min.x;
- y -= bp->r.min.y;
- }
- g = _getfillgc(f, bp, v);
- XDrawArc(_dpy, (Drawable)bp->id, g, x, y, 2*a, 2*b, 0, 23040/* 360 deg…
+ x = p.x - a;
+ y = p.y - b;
+ if (bp->flag&SHIFT){
+ x -= bp->r.min.x;
+ y -= bp->r.min.y;
+ }
+ g = _getfillgc(f, bp, v);
+ XDrawArc(_dpy, (Drawable)bp->id, g, x, y, 2*a, 2*b, 0, 23040/* 360 deg */);
}
diff --git a/libXg/font.c b/libXg/font.c
@@ -4,7 +4,7 @@
#include <libg.h>
#include "libgint.h"
-#define PJW 0 /* use NUL==pjw for invisible characters */
+#define PJW 0 /* use NUL==pjw for invisible characters */
long
charwidth(XftFont *f, Rune r)
diff --git a/libXg/gcs.c b/libXg/gcs.c
@@ -36,22 +36,22 @@
* source and dest use 1 for black. This is a straight translation.
*/
static int gx[16] = {
- GXclear, /* Zero */
- GXnor, /* DnorS */
- GXandInverted, /* DandnotS */
- GXcopyInverted, /* notS */
- GXandReverse, /* notDandS */
- GXinvert, /* notD */
- GXxor, /* DxorS */
- GXnand, /* DnandS */
- GXand, /* DandS */
- GXequiv, /* DxnorS */
- GXnoop, /* D */
- GXorInverted, /* DornotS */
- GXcopy, /* S */
- GXorReverse, /* notDorS */
- GXor, /* DorS */
- GXset, /* F */
+ GXclear, /* Zero */
+ GXnor, /* DnorS */
+ GXandInverted, /* DandnotS */
+ GXcopyInverted, /* notS */
+ GXandReverse, /* notDandS */
+ GXinvert, /* notD */
+ GXxor, /* DxorS */
+ GXnand, /* DnandS */
+ GXand, /* DandS */
+ GXequiv, /* DxnorS */
+ GXnoop, /* D */
+ GXorInverted, /* DornotS */
+ GXcopy, /* S */
+ GXorReverse, /* notDorS */
+ GXor, /* DorS */
+ GXset, /* F */
};
/*
@@ -61,22 +61,22 @@ static int gx[16] = {
* The comment on each line is op, in Fcode terms.
*/
static int d0s1gx[16] = {
- GXset, /* Zero */
- GXorReverse, /* DnorS */
- GXor, /* DandnotS */
- GXcopy, /* notS */
- GXnand, /* notDandS */
- GXinvert, /* notD */
- GXxor, /* DxorS */
- GXandReverse, /* DnandS */
- GXorInverted, /* DandS */
- GXequiv, /* DxnorS */
- GXnoop, /* D */
- GXand, /* DornotS */
- GXcopyInverted, /* S */
- GXnor, /* notDorS */
- GXandInverted, /* DorS */
- GXclear, /* F */
+ GXset, /* Zero */
+ GXorReverse, /* DnorS */
+ GXor, /* DandnotS */
+ GXcopy, /* notS */
+ GXnand, /* notDandS */
+ GXinvert, /* notD */
+ GXxor, /* DxorS */
+ GXandReverse, /* DnandS */
+ GXorInverted, /* DandS */
+ GXequiv, /* DxnorS */
+ GXnoop, /* D */
+ GXand, /* DornotS */
+ GXcopyInverted, /* S */
+ GXnor, /* notDorS */
+ GXandInverted, /* DorS */
+ GXclear, /* F */
};
/*
* gx func code corresponding to libg func code when 1 means black
@@ -85,22 +85,22 @@ static int d0s1gx[16] = {
* The comment on each line is op, in Fcode terms.
*/
static int d1s0gx[16] = {
- GXclear, /* Zero */
- GXandReverse, /* DnorS */
- GXand, /* DandnotS */
- GXcopy, /* notS */
- GXnor, /* notDandS */
- GXinvert, /* notD */
- GXequiv, /* DxorS */
- GXorReverse, /* DnandS */
- GXandInverted, /* DandS */
- GXxor, /* DxnorS */
- GXnoop, /* D */
- GXor, /* DornotS */
- GXcopyInverted, /* S */
- GXnand, /* notDorS */
- GXorInverted, /* DorS */
- GXset, /* F */
+ GXclear, /* Zero */
+ GXandReverse, /* DnorS */
+ GXand, /* DandnotS */
+ GXcopy, /* notS */
+ GXnor, /* notDandS */
+ GXinvert, /* notD */
+ GXequiv, /* DxorS */
+ GXorReverse, /* DnandS */
+ GXandInverted, /* DandS */
+ GXxor, /* DxnorS */
+ GXnoop, /* D */
+ GXor, /* DornotS */
+ GXcopyInverted, /* S */
+ GXnand, /* notDorS */
+ GXorInverted, /* DorS */
+ GXset, /* F */
};
/*
@@ -110,44 +110,44 @@ static int d1s0gx[16] = {
* The comment on each line is op, in Fcode terms.
*/
static int d0s0gx[16] = {
- GXset, /* Zero */
- GXnand, /* DnorS */
- GXorInverted, /* DandnotS */
- GXcopyInverted, /* notS */
- GXorReverse, /* notDandS */
- GXinvert, /* notD */
- GXequiv, /* DxorS */
- GXnor, /* DnandS */
- GXor, /* DandS */
- GXxor, /* DxnorS */
- GXnoop, /* D */
- GXandInverted, /* DornotS */
- GXcopy, /* S */
- GXandReverse, /* notDorS */
- GXand, /* DorS */
- GXclear, /* F */
+ GXset, /* Zero */
+ GXnand, /* DnorS */
+ GXorInverted, /* DandnotS */
+ GXcopyInverted, /* notS */
+ GXorReverse, /* notDandS */
+ GXinvert, /* notD */
+ GXequiv, /* DxorS */
+ GXnor, /* DnandS */
+ GXor, /* DandS */
+ GXxor, /* DxnorS */
+ GXnoop, /* D */
+ GXandInverted, /* DornotS */
+ GXcopy, /* S */
+ GXandReverse, /* notDorS */
+ GXand, /* DorS */
+ GXclear, /* F */
};
/*
* 1 for those Fcodes that are degenerate (don't involve src)
*/
static int degengc[16] = {
- 1, /* Zero */
- 0, /* DnorS */
- 0, /* DandnotS */
- 0, /* notS */
- 0, /* notDandS */
- 1, /* notD */
- 0, /* DxorS */
- 0, /* DnandS */
- 0, /* DandS */
- 0, /* DxnorS */
- 1, /* D */
- 0, /* DornotS */
- 0, /* S */
- 0, /* notDorS */
- 0, /* DorS */
- 1, /* F */
+ 1, /* Zero */
+ 0, /* DnorS */
+ 0, /* DandnotS */
+ 0, /* notS */
+ 0, /* notDandS */
+ 1, /* notD */
+ 0, /* DxorS */
+ 0, /* DnandS */
+ 0, /* DandS */
+ 0, /* DxnorS */
+ 1, /* D */
+ 0, /* DornotS */
+ 0, /* S */
+ 0, /* notDorS */
+ 0, /* DorS */
+ 1, /* F */
};
/*
@@ -160,37 +160,37 @@ static int degengc[16] = {
GC
_getgc(Bitmap *b, unsigned long gcvm, XGCValues *pgcv)
{
- static GC gc0, gcn;
- static int clipset = 0;
- GC g;
- XRectangle xr;
+ static GC gc0, gcn;
+ static int clipset = 0;
+ GC g;
+ XRectangle xr;
- g = (b->ldepth==0)? gc0 : gcn;
- if(!g){
- g = XCreateGC(_dpy, (Drawable)b->id, gcvm, pgcv);
- if(b->ldepth==0)
- gc0 = g;
- else
- gcn = g;
- } else
- XChangeGC(_dpy, g, gcvm, pgcv);
- if(b->flag&CLIP){
- xr.x = b->clipr.min.x;
- xr.y = b->clipr.min.y;
- xr.width = Dx(b->clipr);
- xr.height = Dy(b->clipr);
- if(b->flag&SHIFT){
- xr.x -= b->r.min.x;
- xr.y -= b->r.min.y;
- }
- XSetClipRectangles(_dpy, g, 0, 0, &xr, 1, YXBanded);
- clipset = 1;
- }else if(clipset){
- pgcv->clip_mask = None;
- XChangeGC(_dpy, g, GCClipMask, pgcv);
- clipset = 0;
- }
- return g;
+ g = (b->ldepth==0)? gc0 : gcn;
+ if(!g){
+ g = XCreateGC(_dpy, (Drawable)b->id, gcvm, pgcv);
+ if(b->ldepth==0)
+ gc0 = g;
+ else
+ gcn = g;
+ } else
+ XChangeGC(_dpy, g, gcvm, pgcv);
+ if(b->flag&CLIP){
+ xr.x = b->clipr.min.x;
+ xr.y = b->clipr.min.y;
+ xr.width = Dx(b->clipr);
+ xr.height = Dy(b->clipr);
+ if(b->flag&SHIFT){
+ xr.x -= b->r.min.x;
+ xr.y -= b->r.min.y;
+ }
+ XSetClipRectangles(_dpy, g, 0, 0, &xr, 1, YXBanded);
+ clipset = 1;
+ }else if(clipset){
+ pgcv->clip_mask = None;
+ XChangeGC(_dpy, g, GCClipMask, pgcv);
+ clipset = 0;
+ }
+ return g;
}
/*
@@ -207,88 +207,88 @@ _getfillgc(Fcode f, Bitmap *b, unsigned long val)
GC
_getfillgc2(Fcode f, Bitmap *b, unsigned long val, unsigned long fg, unsigned …
{
- int xf, m;
- unsigned long v, spix, vmax;
- XGCValues gcv;
+ int xf, m;
+ unsigned long v, spix, vmax;
+ XGCValues gcv;
- f &= F;
- vmax = _ld2dmask[b->ldepth];
- v = val & vmax;
- spix = v;
- xf = GXcopy;
- m = b->flag;
- if(m & DP1){
- xf = (m&BL1)? gx[f] : d0s1gx[f];
- }else{
- switch(f){
- case Zero:
- labZero:
- spix = bg;
- break;
- case F:
- labF:
- spix = fg;
- break;
- case D:
- labD:
- xf = GXnoop;
- break;
- case notD:
- labnotD:
- xf = GXxor;
- spix = fg^bg;
- break;
- case S:
- if(val == ~0)
- spix = fg;
- else
- spix = v;
- break;
- case notS:
- if(val == ~0)
- spix = bg;
- else
- spix = v;
- break;
- case DxorS:
- xf = GXxor;
- if(val == ~0)
- spix = fg^bg;
- else
- spix = v;
- break;
- case DxnorS:
- xf = GXxor;
- if(val == 0)
- spix = fg^bg;
- else
- spix = v;
- break;
- default:
- /* hard to do anything other than v==0 or v==~0 case */
- if(v < vmax-v){
- /* v is closer to 0 than vmax */
- switch(f&~S){
- case D&~S: goto labD;
- case notD&~S: goto labnotD;
- case Zero&~S: goto labZero;
- case F&~S: goto labF;
- }
- }else{
- /* v is closer to vmax than 0 */
- switch(f&S){
- case D&S: goto labD;
- case notD&S: goto labnotD;
- case Zero&S: goto labZero;
- case F&S: goto labF;
- }
- }
-
- }
- }
- gcv.foreground = spix;
- gcv.function = xf;
- return _getgc(b, GCForeground|GCFunction, &gcv);
+ f &= F;
+ vmax = _ld2dmask[b->ldepth];
+ v = val & vmax;
+ spix = v;
+ xf = GXcopy;
+ m = b->flag;
+ if(m & DP1){
+ xf = (m&BL1)? gx[f] : d0s1gx[f];
+ }else{
+ switch(f){
+ case Zero:
+ labZero:
+ spix = bg;
+ break;
+ case F:
+ labF:
+ spix = fg;
+ break;
+ case D:
+ labD:
+ xf = GXnoop;
+ break;
+ case notD:
+ labnotD:
+ xf = GXxor;
+ spix = fg^bg;
+ break;
+ case S:
+ if(val == ~0)
+ spix = fg;
+ else
+ spix = v;
+ break;
+ case notS:
+ if(val == ~0)
+ spix = bg;
+ else
+ spix = v;
+ break;
+ case DxorS:
+ xf = GXxor;
+ if(val == ~0)
+ spix = fg^bg;
+ else
+ spix = v;
+ break;
+ case DxnorS:
+ xf = GXxor;
+ if(val == 0)
+ spix = fg^bg;
+ else
+ spix = v;
+ break;
+ default:
+ /* hard to do anything other than v==0 or v==~0 case */
+ if(v < vmax-v){
+ /* v is closer to 0 than vmax */
+ switch(f&~S){
+ case D&~S: goto labD;
+ case notD&~S: goto labnotD;
+ case Zero&~S: goto labZero;
+ case F&~S: goto labF;
+ }
+ }else{
+ /* v is closer to vmax than 0 */
+ switch(f&S){
+ case D&S: goto labD;
+ case notD&S: goto labnotD;
+ case Zero&S: goto labZero;
+ case F&S: goto labF;
+ }
+ }
+
+ }
+ }
+ gcv.foreground = spix;
+ gcv.function = xf;
+ return _getgc(b, GCForeground|GCFunction, &gcv);
}
/*
@@ -307,103 +307,103 @@ _getcopygc(Fcode f, Bitmap *db, Bitmap *sb, int *bltfun…
GC
_getcopygc2(Fcode f, Bitmap *db, Bitmap *sb, int *bltfunc, unsigned long fg, u…
{
- unsigned long spix, df, sf;
- int xf, c;
- XGCValues gcv;
- unsigned long gcvm;
+ unsigned long spix, df, sf;
+ int xf, c;
+ XGCValues gcv;
+ unsigned long gcvm;
- f &= F;
- gcvm = 0;
- df = db->flag;
- if(degengc[f]){
- *bltfunc = UseFillRectangle;
- if(df&SCR || !(df&DP1)){
+ f &= F;
+ gcvm = 0;
+ df = db->flag;
+ if(degengc[f]){
+ *bltfunc = UseFillRectangle;
+ if(df&SCR || !(df&DP1)){
// nothing XXX
- }else{
- /* must be DP1 and BL1 */
- fg = 1;
- bg = 0;
- }
- switch(f){
- case Zero:
- xf = GXcopy;
- spix = bg;
- break;
- case F:
- xf = GXcopy;
- spix = fg;
- break;
- case D:
- xf = GXnoop;
- spix = fg;
- break;
- case notD:
- xf = GXxor;
- spix = fg^bg;
- break;
- }
- gcv.function = xf;
- gcv.foreground = spix;
- gcvm = GCFunction|GCForeground;
- }else{
- /* src is involved in f */
+ }else{
+ /* must be DP1 and BL1 */
+ fg = 1;
+ bg = 0;
+ }
+ switch(f){
+ case Zero:
+ xf = GXcopy;
+ spix = bg;
+ break;
+ case F:
+ xf = GXcopy;
+ spix = fg;
+ break;
+ case D:
+ xf = GXnoop;
+ spix = fg;
+ break;
+ case notD:
+ xf = GXxor;
+ spix = fg^bg;
+ break;
+ }
+ gcv.function = xf;
+ gcv.foreground = spix;
+ gcvm = GCFunction|GCForeground;
+ }else{
+ /* src is involved in f */
#define code(f1,f2) ((((f1)&(DP1|BL1))<<2)|((f2)&(DP1|BL1)))
- sf = sb->flag;
- c = code(df,sf);
- *bltfunc = UseCopyArea;
- switch(code(df,sf)){
- case code(DP1|BL1,DP1|BL1):
- case code(BL1,BL1):
- xf = gx[f];
- break;
- case code(DP1|BL1,DP1):
- xf = d1s0gx[f];
- break;
- case code(DP1,DP1|BL1):
- xf = d0s1gx[f];
- break;
- case code(DP1,DP1):
- case code(0,0):
- xf = d0s0gx[f];
- break;
- default:
- /*
- * One bitmap has depth 1, the other has screen depth.
- * We know the bitmap must have BL1.
- * CopyPlane must be used; it won't really work
- * for more than fcode==S.
- */
+ sf = sb->flag;
+ c = code(df,sf);
+ *bltfunc = UseCopyArea;
+ switch(code(df,sf)){
+ case code(DP1|BL1,DP1|BL1):
+ case code(BL1,BL1):
+ xf = gx[f];
+ break;
+ case code(DP1|BL1,DP1):
+ xf = d1s0gx[f];
+ break;
+ case code(DP1,DP1|BL1):
+ xf = d0s1gx[f];
+ break;
+ case code(DP1,DP1):
+ case code(0,0):
+ xf = d0s0gx[f];
+ break;
+ default:
+ /*
+ * One bitmap has depth 1, the other has screen depth.
+ * We know the bitmap must have BL1.
+ * CopyPlane must be used; it won't really work
+ * for more than fcode==S.
+ */
- *bltfunc = UseCopyPlane;
- xf = GXcopy;
- switch(c){
+ *bltfunc = UseCopyPlane;
+ xf = GXcopy;
+ switch(c){
- case code(0,DP1|BL1):
- case code(BL1,DP1|BL1):
+ case code(0,DP1|BL1):
+ case code(BL1,DP1|BL1):
// nothing XXX
- break;
- case code(DP1|BL1,0):
- fg = 0;
- bg = 1;
- break;
- case code(DP1|BL1,BL1):
- fg = 1;
- bg = 0;
- break;
- default:
- berror("bad combination of copy bitmaps");
- }
- gcv.foreground = fg;
- gcv.background = bg;
- gcvm |= GCForeground|GCBackground;
- }
- gcv.function = xf;
- gcvm |= GCFunction;
-
+ break;
+ case code(DP1|BL1,0):
+ fg = 0;
+ bg = 1;
+ break;
+ case code(DP1|BL1,BL1):
+ fg = 1;
+ bg = 0;
+ break;
+ default:
+ berror("bad combination of copy bitmaps");
+ }
+ gcv.foreground = fg;
+ gcv.background = bg;
+ gcvm |= GCForeground|GCBackground;
+ }
+ gcv.function = xf;
+ gcvm |= GCFunction;
+
#undef code
- }
+ }
- return _getgc(db, gcvm, &gcv);
+ return _getgc(db, gcvm, &gcv);
}
diff --git a/libXg/getrect.c b/libXg/getrect.c
@@ -9,56 +9,56 @@ grabcursor(void)
{
raisewindow();
- /* Grab X server with an limp wrist. */
- while (XGrabPointer(_dpy, screen.id, False,
- ButtonPressMask|ButtonReleaseMask|
- ButtonMotionMask|StructureNotifyMask,
- GrabModeAsync, GrabModeAsync, None, None, CurrentTime)
- != GrabSuccess)
- sleep(2);
+ /* Grab X server with an limp wrist. */
+ while (XGrabPointer(_dpy, screen.id, False,
+ ButtonPressMask|ButtonReleaseMask|
+ ButtonMotionMask|StructureNotifyMask,
+ GrabModeAsync, GrabModeAsync, None, None, CurrentTime)
+ != GrabSuccess)
+ sleep(2);
- /* Grab the keyboard too */
- XSetInputFocus(_dpy, screen.id, RevertToParent, CurrentTime);
+ /* Grab the keyboard too */
+ XSetInputFocus(_dpy, screen.id, RevertToParent, CurrentTime);
}
static void
ungrabcursor(void)
{
- XUngrabPointer(_dpy, CurrentTime);
+ XUngrabPointer(_dpy, CurrentTime);
}
Rectangle
getrect(int but, Mouse *m){
- Rectangle r, rc;
+ Rectangle r, rc;
- but = 1<<(but-1);
- cursorswitch(SweepCursor);
- while(m->buttons)
- *m = emouse();
- grabcursor();
- while(!(m->buttons & but)){
- *m = emouse();
- if(m->buttons & (7^but))
- goto Return;
- }
- r.min = m->xy;
- r.max = m->xy;
- do{
- rc = rcanon(r);
- border(&screen, rc, 2, F&~D, _bgpixel);
- *m = emouse();
- border(&screen, rc, 2, F&~D, _bgpixel);
- r.max = m->xy;
- }while(m->buttons & but);
+ but = 1<<(but-1);
+ cursorswitch(SweepCursor);
+ while(m->buttons)
+ *m = emouse();
+ grabcursor();
+ while(!(m->buttons & but)){
+ *m = emouse();
+ if(m->buttons & (7^but))
+ goto Return;
+ }
+ r.min = m->xy;
+ r.max = m->xy;
+ do{
+ rc = rcanon(r);
+ border(&screen, rc, 2, F&~D, _bgpixel);
+ *m = emouse();
+ border(&screen, rc, 2, F&~D, _bgpixel);
+ r.max = m->xy;
+ }while(m->buttons & but);
Return:
- cursorswitch(DefaultCursor);
- if(m->buttons & (7^but)){
- rc.min.x = rc.max.x = 0;
- rc.min.y = rc.max.y = 0;
- while(m->buttons)
- *m = emouse();
- }
- ungrabcursor();
- return rc;
+ cursorswitch(DefaultCursor);
+ if(m->buttons & (7^but)){
+ rc.min.x = rc.max.x = 0;
+ rc.min.y = rc.max.y = 0;
+ while(m->buttons)
+ *m = emouse();
+ }
+ ungrabcursor();
+ return rc;
}
diff --git a/libXg/gwin.c b/libXg/gwin.c
@@ -32,35 +32,35 @@ static String SelectSwap(Widget, String);
#define Offset(field) XtOffsetOf(GwinRec, gwin.field)
static XtResource resources[] = {
- {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
- Offset(foreground), XtRString, (XtPointer)XtDefaultForeground},
- {XtNscrollForwardR, XtCScrollForwardR, XtRBoolean, sizeof(Boolean),
- Offset(forwardr), XtRImmediate, (XtPointer)TRUE},
- {XtNreshaped, XtCReshaped, XtRFunction, sizeof(Reshapefunc),
- Offset(reshaped), XtRFunction, (XtPointer) NULL},
- {XtNgotchar, XtCGotchar, XtRFunction, sizeof(Charfunc),
- Offset(gotchar), XtRFunction, (XtPointer) NULL},
- {XtNgotmouse, XtCGotmouse, XtRFunction, sizeof(Mousefunc),
- Offset(gotmouse), XtRFunction, (XtPointer) NULL},
- {XtNselection, XtCSelection, XtRString, sizeof(String),
- Offset(selection), XtRString, (XtPointer) NULL},
- {XtNcomposeMod, XtCComposeMod, XtRInt, sizeof(int),
- Offset(compose), XtRImmediate, (XtPointer) 0}
+ {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
+ Offset(foreground), XtRString, (XtPointer)XtDefaultForeground},
+ {XtNscrollForwardR, XtCScrollForwardR, XtRBoolean, sizeof(Boolean),
+ Offset(forwardr), XtRImmediate, (XtPointer)TRUE},
+ {XtNreshaped, XtCReshaped, XtRFunction, sizeof(Reshapefunc),
+ Offset(reshaped), XtRFunction, (XtPointer) NULL},
+ {XtNgotchar, XtCGotchar, XtRFunction, sizeof(Charfunc),
+ Offset(gotchar), XtRFunction, (XtPointer) NULL},
+ {XtNgotmouse, XtCGotmouse, XtRFunction, sizeof(Mousefunc),
+ Offset(gotmouse), XtRFunction, (XtPointer) NULL},
+ {XtNselection, XtCSelection, XtRString, sizeof(String),
+ Offset(selection), XtRString, (XtPointer) NULL},
+ {XtNcomposeMod, XtCComposeMod, XtRInt, sizeof(int),
+ Offset(compose), XtRImmediate, (XtPointer) 0}
};
#undef Offset
static XtActionsRec actions[] = {
- {"key", Keyaction},
- {"mouse", Mouseaction},
- {"mapping", Mappingaction}
+ {"key", Keyaction},
+ {"mouse", Mouseaction},
+ {"mapping", Mappingaction}
};
static char tms[] =
- "<Key> : key() \n\
- <Motion> : mouse() \n\
- <BtnDown> : mouse() \n\
- <BtnUp> : mouse() \n\
- <Mapping> : mapping() \n";
+ "<Key> : key() \n\
+ <Motion> : mouse() \n\
+ <BtnDown> : mouse() \n\
+ <BtnUp> : mouse() \n\
+ <Mapping> : mapping() \n";
/* Class record declaration */
@@ -102,7 +102,7 @@ GwinClassRec gwinClassRec = {
},
/* Gwin class part */
{
- /* select_swap */ SelectSwap,
+ /* select_swap */ SelectSwap,
}
};
@@ -115,52 +115,52 @@ static int keypermod;
static void
Realize(Widget w, XtValueMask *valueMask, XSetWindowAttributes *attrs)
{
- XtValueMask mask;
+ XtValueMask mask;
- *valueMask |= CWBackingStore;
- attrs->backing_store = Always;
+ *valueMask |= CWBackingStore;
+ attrs->backing_store = Always;
- XtCreateWindow(w, InputOutput, (Visual *)0, *valueMask, attrs);
- XtSetKeyboardFocus(w->core.parent, w);
- if (modmap = XGetModifierMapping(XtDisplay(w)))
- keypermod = modmap->max_keypermod;
+ XtCreateWindow(w, InputOutput, (Visual *)0, *valueMask, attrs);
+ XtSetKeyboardFocus(w->core.parent, w);
+ if (modmap = XGetModifierMapping(XtDisplay(w)))
+ keypermod = modmap->max_keypermod;
- Resize(w);
+ Resize(w);
}
static void
Resize(Widget w)
{
- if(XtIsRealized(w))
- (*(XtClass(w)->core_class.expose))(w, (XEvent *)NULL, (Region)…
+ if(XtIsRealized(w))
+ (*(XtClass(w)->core_class.expose))(w, (XEvent *)NULL, (Region)NULL);
}
static void
Redraw(Widget w, XEvent *e, Region r)
{
- Reshapefunc f;
+ Reshapefunc f;
- f = ((GwinWidget)w)->gwin.reshaped;
- if(f)
- (*f)(w->core.x, w->core.y,
- w->core.x+w->core.width, w->core.y+w->core.height);
+ f = ((GwinWidget)w)->gwin.reshaped;
+ if(f)
+ (*f)(w->core.x, w->core.y,
+ w->core.x+w->core.width, w->core.y+w->core.height);
}
static void
Mappingaction(Widget w, XEvent *e, String *p, Cardinal *np)
{
- if (modmap)
- XFreeModifiermap(modmap);
- modmap = XGetModifierMapping(e->xany.display);
- if (modmap)
- keypermod = modmap->max_keypermod;
+ if (modmap)
+ XFreeModifiermap(modmap);
+ modmap = XGetModifierMapping(e->xany.display);
+ if (modmap)
+ keypermod = modmap->max_keypermod;
}
#define STUFFCOMPOSE() \
- f = ((GwinWidget)w)->gwin.gotchar; \
- if (f) \
- for (c = 0; c < composing; c++) \
- (*f)(compose[c], 0, Tcurrent, …
+ f = ((GwinWidget)w)->gwin.gotchar; \
+ if (f) \
+ for (c = 0; c < composing; c++) \
+ (*f)(compose[c], 0, Tcurrent, 0, 0)
typedef struct Keymapping Keymapping;
struct Keymapping{
@@ -200,25 +200,25 @@ keysymtoshort(KeySym k)
static void
Keyaction(Widget w, XEvent *e, String *p, Cardinal *np)
{
- static unsigned char compose[5];
- static int composing = -2;
+ static unsigned char compose[5];
+ static int composing = -2;
int composed = 0;
int kind = Kraw;
- int c, minmod;
- KeySym k, mk;
- Charfunc f;
- Modifiers md;
+ int c, minmod;
+ KeySym k, mk;
+ Charfunc f;
+ Modifiers md;
- /*
- * I tried using XtGetActionKeysym, but it didn't seem to
- * do case conversion properly
- * (at least, with Xterminal servers and R4 intrinsics)
- */
- if(e->xany.type != KeyPress)
- return;
+ /*
+ * I tried using XtGetActionKeysym, but it didn't seem to
+ * do case conversion properly
+ * (at least, with Xterminal servers and R4 intrinsics)
+ */
+ if(e->xany.type != KeyPress)
+ return;
- XtTranslateKeycode(e->xany.display, (KeyCode)e->xkey.keycode, e->xkey.…
+ XtTranslateKeycode(e->xany.display, (KeyCode)e->xkey.keycode, e->xkey.stat…
/* Check to see if it's a specially-handled key first. */
for (Keymapping *m = keymappings; m && m->kind != Kend; m++){
@@ -232,81 +232,81 @@ Keyaction(Widget w, XEvent *e, String *p, Cardinal *np)
}
}
- /*
- * The following song and dance is so we can have our chosen
- * modifier key behave like a compose key, i.e, press and release
- * and then type the compose sequence, like Plan 9. We have
- * to find out which key is the compose key first 'though.
- */
- if (IsModifierKey(k) && ((GwinWidget)w)->gwin.compose
- && composing == -2 && modmap) {
- minmod = (((GwinWidget)w)->gwin.compose+2)*keypermod;
- for (c = minmod; c < minmod+keypermod; c++) {
- XtTranslateKeycode(e->xany.display,
- modmap->modifiermap[c],
- e->xkey.state, &md, &mk);
- if (k == mk) {
- composing = -1;
- break;
- }
- }
- return;
- }
-
- /* Handle Multi_key separately, since it isn't a modifier */
- if(k == XK_Multi_key) {
- composing = -1;
- return;
- }
-
- if(k == NoSymbol || k > 0xff00)
- return;
-
- /* Check to see if we are in a composition sequence */
- if (!((GwinWidget)w)->gwin.compose && (e->xkey.state & Mod1Mask)
- && composing == -2)
- composing = -1;
- if (composing > -2) {
- compose[++composing] = k;
- if ((*compose == 'X') && (composing > 0)) {
- if ((k < '0') || (k > 'f') ||
- ((k > '9') && (k < 'a'))) {
- STUFFCOMPOSE();
- c = (unsigned short)k;
- composing = -2;
- } else if (composing == 4) {
- c = unicode(compose);
- if (c == -1) {
- STUFFCOMPOSE();
- c = (unsigned short)compose[4];
- } else
+ /*
+ * The following song and dance is so we can have our chosen
+ * modifier key behave like a compose key, i.e, press and release
+ * and then type the compose sequence, like Plan 9. We have
+ * to find out which key is the compose key first 'though.
+ */
+ if (IsModifierKey(k) && ((GwinWidget)w)->gwin.compose
+ && composing == -2 && modmap) {
+ minmod = (((GwinWidget)w)->gwin.compose+2)*keypermod;
+ for (c = minmod; c < minmod+keypermod; c++) {
+ XtTranslateKeycode(e->xany.display,
+ modmap->modifiermap[c],
+ e->xkey.state, &md, &mk);
+ if (k == mk) {
+ composing = -1;
+ break;
+ }
+ }
+ return;
+ }
+
+ /* Handle Multi_key separately, since it isn't a modifier */
+ if(k == XK_Multi_key) {
+ composing = -1;
+ return;
+ }
+
+ if(k == NoSymbol || k > 0xff00)
+ return;
+
+ /* Check to see if we are in a composition sequence */
+ if (!((GwinWidget)w)->gwin.compose && (e->xkey.state & Mod1Mask)
+ && composing == -2)
+ composing = -1;
+ if (composing > -2) {
+ compose[++composing] = k;
+ if ((*compose == 'X') && (composing > 0)) {
+ if ((k < '0') || (k > 'f') ||
+ ((k > '9') && (k < 'a'))) {
+ STUFFCOMPOSE();
+ c = (unsigned short)k;
+ composing = -2;
+ } else if (composing == 4) {
+ c = unicode(compose);
+ if (c == -1) {
+ STUFFCOMPOSE();
+ c = (unsigned short)compose[4];
+ } else
composed = 1;
- composing = -2;
- }
- } else if (composing == 1) {
- c = (int)latin1(compose);
- if (c == -1) {
- STUFFCOMPOSE();
- c = (unsigned short)compose[1];
- } else
+ composing = -2;
+ }
+ } else if (composing == 1) {
+ c = (int)latin1(compose);
+ if (c == -1) {
+ STUFFCOMPOSE();
+ c = (unsigned short)compose[1];
+ } else
composed = 1;
- composing = -2;
- }
- } else {
- if (composing >= 0) {
- composing++;
- STUFFCOMPOSE();
- }
- c = keysymtoshort(k);
- composing = -2;
- }
-
- if (composing >= -1)
- return;
-
- f = ((GwinWidget)w)->gwin.gotchar;
- if(f)
- (*f)(c, kind, Tcurrent, 0, 0);
+ composing = -2;
+ }
+ } else {
+ if (composing >= 0) {
+ composing++;
+ STUFFCOMPOSE();
+ }
+ c = keysymtoshort(k);
+ composing = -2;
+ }
+
+ if (composing >= -1)
+ return;
+
+ f = ((GwinWidget)w)->gwin.gotchar;
+ if(f)
+ (*f)(c, kind, Tcurrent, 0, 0);
}
typedef struct Chordmapping Chordmapping;
@@ -333,50 +333,50 @@ Chordmapping chordmappings[] ={
static void
Mouseaction(Widget w, XEvent *e, String *p, Cardinal *np)
{
- int s = 0;
+ int s = 0;
int ps = 0; /* the previous state */
int ob = 0;
- XButtonEvent *be = (XButtonEvent *)e;
- XMotionEvent *me = (XMotionEvent *)e;
- Gwinmouse m;
- Mousefunc f;
-
- switch(e->type){
- case ButtonPress:
- m.xy.x = be->x;
- m.xy.y = be->y;
- m.msec = be->time;
- ps = s = be->state;
- switch(be->button){
- case 1: s |= Button1Mask; break;
- case 2: s |= Button2Mask; break;
- case 3: s |= Button3Mask; break;
- case 4: s |= Button4Mask; break;
- case 5: s |= Button5Mask; break;
- }
- break;
- case ButtonRelease:
- m.xy.x = be->x;
- m.xy.y = be->y;
- m.msec = be->time;
- ps = s = be->state;
- switch(be->button){
- case 1: s &= ~Button1Mask; break;
- case 2: s &= ~Button2Mask; break;
- case 3: s &= ~Button3Mask; break;
- case 4: s &= ~Button4Mask; break;
- case 5: s &= ~Button5Mask; break;
- }
- break;
- case MotionNotify:
- ps = s = me->state;
- m.xy.x = me->x;
- m.xy.y = me->y;
- m.msec = me->time;
- break;
- default:
- return;
- }
+ XButtonEvent *be = (XButtonEvent *)e;
+ XMotionEvent *me = (XMotionEvent *)e;
+ Gwinmouse m;
+ Mousefunc f;
+
+ switch(e->type){
+ case ButtonPress:
+ m.xy.x = be->x;
+ m.xy.y = be->y;
+ m.msec = be->time;
+ ps = s = be->state;
+ switch(be->button){
+ case 1: s |= Button1Mask; break;
+ case 2: s |= Button2Mask; break;
+ case 3: s |= Button3Mask; break;
+ case 4: s |= Button4Mask; break;
+ case 5: s |= Button5Mask; break;
+ }
+ break;
+ case ButtonRelease:
+ m.xy.x = be->x;
+ m.xy.y = be->y;
+ m.msec = be->time;
+ ps = s = be->state;
+ switch(be->button){
+ case 1: s &= ~Button1Mask; break;
+ case 2: s &= ~Button2Mask; break;
+ case 3: s &= ~Button3Mask; break;
+ case 4: s &= ~Button4Mask; break;
+ case 5: s &= ~Button5Mask; break;
+ }
+ break;
+ case MotionNotify:
+ ps = s = me->state;
+ m.xy.x = me->x;
+ m.xy.y = me->y;
+ m.msec = me->time;
+ break;
+ default:
+ return;
+ }
m.buttons = 0;
@@ -403,86 +403,86 @@ Mouseaction(Widget w, XEvent *e, String *p, Cardinal *np)
}
}
- f = ((GwinWidget)w)->gwin.gotmouse;
- if(f)
- (*f)(&m);
+ f = ((GwinWidget)w)->gwin.gotmouse;
+ if(f)
+ (*f)(&m);
}
static void
SelCallback(Widget w, XtPointer cldata, Atom *sel, Atom *seltype,
- XtPointer val, unsigned long *len, int *fmt)
+ XtPointer val, unsigned long *len, int *fmt)
{
- String s;
- int n;
- GwinWidget gw = (GwinWidget)w;
-
- if(gw->gwin.selection)
- XtFree(gw->gwin.selection);
- if(*seltype != XA_STRING)
- n = 0;
- else
- n = (*len) * (*fmt/8);
- s = (String)XtMalloc(n+1);
- if(n > 0)
- memcpy(s, (char *)val, n);
- s[n] = 0;
- gw->gwin.selection = s;
- XtFree(val);
+ String s;
+ int n;
+ GwinWidget gw = (GwinWidget)w;
+
+ if(gw->gwin.selection)
+ XtFree(gw->gwin.selection);
+ if(*seltype != XA_STRING)
+ n = 0;
+ else
+ n = (*len) * (*fmt/8);
+ s = (String)XtMalloc(n+1);
+ if(n > 0)
+ memcpy(s, (char *)val, n);
+ s[n] = 0;
+ gw->gwin.selection = s;
+ XtFree(val);
}
static Boolean
SendSel(Widget w, Atom *sel, Atom *target, Atom *rtype, XtPointer *ans,
- unsigned long *anslen, int *ansfmt)
+ unsigned long *anslen, int *ansfmt)
{
- GwinWidget gw = (GwinWidget)w;
- static Atom targets = 0;
- XrmValue src, dst;
- char *s;
-
- if(*target == XA_STRING){
- s = gw->gwin.selection;
- if(!s)
- s = "";
- *rtype = XA_STRING;
- *ans = (XtPointer) XtNewString(s);
- *anslen = strlen(*ans);
- *ansfmt = 8;
- return TRUE;
- }
-
- return FALSE;
+ GwinWidget gw = (GwinWidget)w;
+ static Atom targets = 0;
+ XrmValue src, dst;
+ char *s;
+
+ if(*target == XA_STRING){
+ s = gw->gwin.selection;
+ if(!s)
+ s = "";
+ *rtype = XA_STRING;
+ *ans = (XtPointer) XtNewString(s);
+ *anslen = strlen(*ans);
+ *ansfmt = 8;
+ return TRUE;
+ }
+
+ return FALSE;
}
static String
SelectSwap(Widget w, String s)
{
- GwinWidget gw;
- String ans;
-
- gw = (GwinWidget)w;
- if(gw->gwin.selection){
- XtFree(gw->gwin.selection);
- gw->gwin.selection = 0;
- }
- XtGetSelectionValue(w, XA_PRIMARY, XA_STRING, SelCallback, 0,
- XtLastTimestampProcessed(XtDisplay(w)));
-
- while(gw->gwin.selection == 0)
- XtAppProcessEvent(XtWidgetToApplicationContext(w) , XtIMAll);
- ans = gw->gwin.selection;
- gw->gwin.selection = XtMalloc(strlen(s)+1);
- strcpy(gw->gwin.selection, s);
-
- XtOwnSelection(w, XA_PRIMARY, XtLastTimestampProcessed(XtDisplay(w)),
- SendSel, NULL, NULL);
-
- return ans;
+ GwinWidget gw;
+ String ans;
+
+ gw = (GwinWidget)w;
+ if(gw->gwin.selection){
+ XtFree(gw->gwin.selection);
+ gw->gwin.selection = 0;
+ }
+ XtGetSelectionValue(w, XA_PRIMARY, XA_STRING, SelCallback, 0,
+ XtLastTimestampProcessed(XtDisplay(w)));
+
+ while(gw->gwin.selection == 0)
+ XtAppProcessEvent(XtWidgetToApplicationContext(w) , XtIMAll);
+ ans = gw->gwin.selection;
+ gw->gwin.selection = XtMalloc(strlen(s)+1);
+ strcpy(gw->gwin.selection, s);
+
+ XtOwnSelection(w, XA_PRIMARY, XtLastTimestampProcessed(XtDisplay(w)),
+ SendSel, NULL, NULL);
+
+ return ans;
}
/* The returned answer should be free()ed when no longer needed */
String
GwinSelectionSwap(Widget w, String s)
{
- XtCheckSubclass(w, gwinWidgetClass, NULL);
- return (*((GwinWidgetClass) XtClass(w))->gwin_class.select_swap)(w, s);
+ XtCheckSubclass(w, gwinWidgetClass, NULL);
+ return (*((GwinWidgetClass) XtClass(w))->gwin_class.select_swap)(w, s);
}
diff --git a/libXg/latin1.c b/libXg/latin1.c
@@ -11,8 +11,8 @@
struct latin
{
- unsigned short l;
- unsigned char c[2];
+ unsigned short l;
+ unsigned char c[2];
};
struct latin latintab[] = {
@@ -232,7 +232,7 @@ struct latin *mappings = NULL;
void
freelatin(void)
{
- free(mappings);
+ free(mappings);
}
void
@@ -255,12 +255,12 @@ initlatin(void)
if (mappings)
atexit(freelatin);
- FILE *keyboard = NULL;
- if (getenv("HOME")){
- char path[1024] = {0};
- snprintf(path, sizeof(path) - 1, "%s/.keyboard", getenv("HOME"…
- keyboard = fopen(path, "r");
- }
+ FILE *keyboard = NULL;
+ if (getenv("HOME")){
+ char path[1024] = {0};
+ snprintf(path, sizeof(path) - 1, "%s/.keyboard", getenv("HOME"));
+ keyboard = fopen(path, "r");
+ }
if (!keyboard)
return;
@@ -270,13 +270,13 @@ initlatin(void)
while (fscanf(keyboard, " %c%c %hx%*[^\n]\n", &c0, &c1, &l) == 3)
addlatin(c0, c1, l);
- fclose(keyboard);
+ fclose(keyboard);
}
long
latin1(unsigned char *k)
{
- struct latin *l;
+ struct latin *l;
for (l = mappings; l->l; l++)
if (k[0] == l->c[0] && k[1] == l->c[1])
@@ -286,26 +286,26 @@ latin1(unsigned char *k)
if (k[0] == l->c[0] && k[1] == l->c[1])
return l->l;
- return -1;
+ return -1;
}
int
unicode(unsigned char *k)
{
- int i, c;
+ int i, c;
- k++; /* skip 'X' */
- c = 0;
- for(i=0; i<4; i++,k++){
- c <<= 4;
- if('0'<=*k && *k<='9')
- c += *k-'0';
- else if('a'<=*k && *k<='f')
- c += 10 + *k-'a';
- else if('A'<=*k && *k<='F')
- c += 10 + *k-'A';
- else
- return -1;
- }
- return c;
+ k++; /* skip 'X' */
+ c = 0;
+ for(i=0; i<4; i++,k++){
+ c <<= 4;
+ if('0'<=*k && *k<='9')
+ c += *k-'0';
+ else if('a'<=*k && *k<='f')
+ c += 10 + *k-'a';
+ else if('A'<=*k && *k<='F')
+ c += 10 + *k-'A';
+ else
+ return -1;
+ }
+ return c;
}
diff --git a/libXg/ldconvert.c b/libXg/ldconvert.c
@@ -7,49 +7,49 @@
void
_ldconvert(char *in, int inld, char *out, int outld, int w, int h)
{
- int a, b, i, j, i1, j1, j2, mask;
- int ind, inl, outd, outl;
- int hh, ww;
- char *p, *q;
+ int a, b, i, j, i1, j1, j2, mask;
+ int ind, inl, outd, outl;
+ int hh, ww;
+ char *p, *q;
- i1 = 8 >> inld;
- j1 = 8 >> outld;
- ind = 1 << inld;
- outd = 1 << outld;
- inl = ((w << inld) + 7)/8;
- outl = ((w << outld) + 7)/8;
- b = 0;
+ i1 = 8 >> inld;
+ j1 = 8 >> outld;
+ ind = 1 << inld;
+ outd = 1 << outld;
+ inl = ((w << inld) + 7)/8;
+ outl = ((w << outld) + 7)/8;
+ b = 0;
- if (ind > outd) {
- mask = 256 - (256 >> outd);
- for (hh = 0; hh < h; hh++, in += inl, out += outl)
- for (p = in, q = out, ww = 0; ww < w; ww++) {
- for (j = j1; j > 0; ) {
- a = *p++;
- for (i = i1; i > 0; i--, j--) {
- b |= a & mask;
- a <<= ind;
- b <<= outd;
- }
- }
- *q++ = (b >> 8);
- }
- } else {
- j2 = 1 << (outld - inld);
- mask = 256 - (256 >> ind);
- for (hh = 0; hh < h; hh++, in += inl, out += outl)
- for (p = in, q = out, ww = 0; ww < w; ww++) {
- a = *p++;
- for (i = i1; i > 0; ) {
- for (j = j1; j > 0; j--, i--) {
- b |= a & mask;
- a <<= ind;
- b <<= outd;
- }
- for (j = j2; j > 0; j--)
- b |= (b << ind);
- *q++ = (b >> 8);
- }
- }
- }
+ if (ind > outd) {
+ mask = 256 - (256 >> outd);
+ for (hh = 0; hh < h; hh++, in += inl, out += outl)
+ for (p = in, q = out, ww = 0; ww < w; ww++) {
+ for (j = j1; j > 0; ) {
+ a = *p++;
+ for (i = i1; i > 0; i--, j--) {
+ b |= a & mask;
+ a <<= ind;
+ b <<= outd;
+ }
+ }
+ *q++ = (b >> 8);
+ }
+ } else {
+ j2 = 1 << (outld - inld);
+ mask = 256 - (256 >> ind);
+ for (hh = 0; hh < h; hh++, in += inl, out += outl)
+ for (p = in, q = out, ww = 0; ww < w; ww++) {
+ a = *p++;
+ for (i = i1; i > 0; ) {
+ for (j = j1; j > 0; j--, i--) {
+ b |= a & mask;
+ a <<= ind;
+ b <<= outd;
+ }
+ for (j = j2; j > 0; j--)
+ b |= (b << ind);
+ *q++ = (b >> 8);
+ }
+ }
+ }
}
diff --git a/libXg/libgint.h b/libXg/libgint.h
@@ -17,8 +17,8 @@
#define Font xFont
#define Event xEvent
-#if defined(v10) || defined(HPUX)
-typedef char* caddr_t;
+#if defined(v10) || defined(HPUX)
+typedef char* caddr_t;
#endif
#include <X11/Xlib.h>
@@ -33,28 +33,28 @@ typedef char* caddr_t;
void initcursors(void);
/* Return a GCs for solid filling/strings/etc., segments/points, and tiling */
-extern GC _getfillgc(Fcode, Bitmap*, unsigned long);
-extern GC _getcopygc(Fcode, Bitmap*, Bitmap*, int*);
-extern GC _getfillgc2(Fcode, Bitmap*, unsigned long, unsigned long, uns…
-extern GC _getcopygc2(Fcode, Bitmap*, Bitmap*, int*, unsigned long, uns…
-extern GC _getgc(Bitmap*, unsigned long, XGCValues *);
+extern GC _getfillgc(Fcode, Bitmap*, unsigned long);
+extern GC _getcopygc(Fcode, Bitmap*, Bitmap*, int*);
+extern GC _getfillgc2(Fcode, Bitmap*, unsigned long, unsigned long, unsigned…
+extern GC _getcopygc2(Fcode, Bitmap*, Bitmap*, int*, unsigned long, unsigned…
+extern GC _getgc(Bitmap*, unsigned long, XGCValues *);
/* convert between different bitmap depths */
-extern void _ldconvert(char *, int, char *, int, int, int);
+extern void _ldconvert(char *, int, char *, int, int, int);
/* balloc without zero init (which uses a gc!) */
-extern Bitmap *_balloc(Rectangle, int);
+extern Bitmap *_balloc(Rectangle, int);
/* X Display for this application's connection */
-extern Display *_dpy;
+extern Display *_dpy;
/* screen depth foreground and background for this application */
-extern unsigned long _fgpixel, _bgpixel;
-extern XColor _fgcolor, _bgcolor;
+extern unsigned long _fgpixel, _bgpixel;
+extern XColor _fgcolor, _bgcolor;
/* indexed by log depth (0 <= ld <= 5), to give depth and planemask */
-extern int _ld2d[];
-extern unsigned long _ld2dmask[];
+extern int _ld2d[];
+extern unsigned long _ld2dmask[];
/* libg.h defines:
* extern Bitmap screen; -- Bitmap for application Window after xbinit()
@@ -78,17 +78,17 @@ extern unsigned long _ld2dmask[];
/* values for bitmap flag field (see _getcopygc if change first two vals) */
enum {
- DP1= 0x1, /* depth == 1 (ldepth == 0) */
- BL1= 0x2, /* black == 1 model */
- SCR= 0x4, /* on screen */
- ZORG= 0x8, /* r.min == Pt(0,0) */
- SHIFT= 0x20, /* !SCR & !ZORG */
- CLIP= 0x40 /* r != clipr */
+ DP1= 0x1, /* depth == 1 (ldepth == 0) */
+ BL1= 0x2, /* black == 1 model */
+ SCR= 0x4, /* on screen */
+ ZORG= 0x8, /* r.min == Pt(0,0) */
+ SHIFT= 0x20, /* !SCR & !ZORG */
+ CLIP= 0x40 /* r != clipr */
};
/* values for return bltfunc arg of _getcopygc */
enum {
- UseCopyArea,
- UseCopyPlane,
- UseFillRectangle
+ UseCopyArea,
+ UseCopyPlane,
+ UseFillRectangle
};
diff --git a/libXg/menuhit.c b/libXg/menuhit.c
@@ -6,28 +6,28 @@
enum
{
- Margin = 3, /* outside to text */
- Border = 2, /* outside to selection boxes */
- Blackborder = 1, /* width of outlining border */
- Vspacing = 1, /* extra spacing between lines of text */
- Maxunscroll = 25, /* maximum #entries before scrolling turns on…
- Nscroll = 20, /* number entries in scrolling part */
- Scrollwid = 14, /* width of scroll bar */
- Gap = 4 /* between text and scroll bar */
+ Margin = 3, /* outside to text */
+ Border = 2, /* outside to selection boxes */
+ Blackborder = 1, /* width of outlining border */
+ Vspacing = 1, /* extra spacing between lines of text */
+ Maxunscroll = 25, /* maximum #entries before scrolling turns on */
+ Nscroll = 20, /* number entries in scrolling part */
+ Scrollwid = 14, /* width of scroll bar */
+ Gap = 4 /* between text and scroll bar */
};
-static Bitmap *menutxt;
+static Bitmap *menutxt;
-static uchar menutxtbits[] = {
- 0x22, 0x22, 0x88, 0x88, 0x22, 0x22, 0x88, 0x88,
- 0x22, 0x22, 0x88, 0x88, 0x22, 0x22, 0x88, 0x88,
- 0x22, 0x22, 0x88, 0x88, 0x22, 0x22, 0x88, 0x88,
- 0x22, 0x22, 0x88, 0x88, 0x22, 0x22, 0x88, 0x88,
+static uchar menutxtbits[] = {
+ 0x22, 0x22, 0x88, 0x88, 0x22, 0x22, 0x88, 0x88,
+ 0x22, 0x22, 0x88, 0x88, 0x22, 0x22, 0x88, 0x88,
+ 0x22, 0x22, 0x88, 0x88, 0x22, 0x22, 0x88, 0x88,
+ 0x22, 0x22, 0x88, 0x88, 0x22, 0x22, 0x88, 0x88,
};
static int
fontheight() {
- return font->ascent + font->descent;
+ return font->ascent + font->descent;
}
/*
@@ -37,11 +37,11 @@ fontheight() {
static Rectangle
menurect(Rectangle r, int i)
{
- if(i < 0)
- return Rect(0, 0, 0, 0);
- r.min.y += (fontheight()+Vspacing)*i;
- r.max.y = r.min.y+fontheight()+Vspacing;
- return inset(r, Border-Margin);
+ if(i < 0)
+ return Rect(0, 0, 0, 0);
+ r.min.y += (fontheight()+Vspacing)*i;
+ r.max.y = r.min.y+fontheight()+Vspacing;
+ return inset(r, Border-Margin);
}
/*
@@ -51,9 +51,9 @@ menurect(Rectangle r, int i)
static int
menusel(Rectangle r, Point p)
{
- if(!ptinrect(p, r))
- return -1;
- return (p.y-r.min.y)/(fontheight()+Vspacing);
+ if(!ptinrect(p, r))
+ return -1;
+ return (p.y-r.min.y)/(fontheight()+Vspacing);
}
/*
@@ -65,177 +65,177 @@ menusel(Rectangle r, Point p)
static int
menuscan(int but, Mouse *m, Rectangle menur, int lasti)
{
- int i;
- Rectangle r;
+ int i;
+ Rectangle r;
- r = menurect(menur, lasti);
- bitblt(&screen, r.min, &screen, r, F&~D);
- *m = emouse();
- while(m->buttons & (1<<(but-1))){
- *m = emouse();
- i = menusel(menur, m->xy);
- if(i == lasti)
- continue;
- bitblt(&screen, r.min, &screen, r, F&~D);
- if(i == -1)
- return i;
- r = menurect(menur, i);
- bitblt(&screen, r.min, &screen, r, F&~D);
- lasti = i;
- }
- return lasti;
+ r = menurect(menur, lasti);
+ bitblt(&screen, r.min, &screen, r, F&~D);
+ *m = emouse();
+ while(m->buttons & (1<<(but-1))){
+ *m = emouse();
+ i = menusel(menur, m->xy);
+ if(i == lasti)
+ continue;
+ bitblt(&screen, r.min, &screen, r, F&~D);
+ if(i == -1)
+ return i;
+ r = menurect(menur, i);
+ bitblt(&screen, r.min, &screen, r, F&~D);
+ lasti = i;
+ }
+ return lasti;
}
void
menupaint(Menu *menu, Rectangle textr, int off, int nitemdrawn)
{
- int i;
- Point pt;
- Rectangle r;
- char *item;
+ int i;
+ Point pt;
+ Rectangle r;
+ char *item;
- r = inset(textr, Border-Margin);
- bitblt(&screen, r.min, &screen, r, 0);
- pt = Pt(textr.min.x+textr.max.x, textr.min.y);
- for(i = 0; i<nitemdrawn; i++, pt.y += fontheight()+Vspacing){
- item = menu->item? menu->item[i+off] : (*menu->gen)(i+off);
- string(&screen,
- Pt((pt.x-strwidth(font, item))/2, pt.y),
- font, item, S);
- }
+ r = inset(textr, Border-Margin);
+ bitblt(&screen, r.min, &screen, r, 0);
+ pt = Pt(textr.min.x+textr.max.x, textr.min.y);
+ for(i = 0; i<nitemdrawn; i++, pt.y += fontheight()+Vspacing){
+ item = menu->item? menu->item[i+off] : (*menu->gen)(i+off);
+ string(&screen,
+ Pt((pt.x-strwidth(font, item))/2, pt.y),
+ font, item, S);
+ }
}
static void
menuscrollpaint(Rectangle scrollr, int off, int nitem, int nitemdrawn)
{
- Rectangle r;
+ Rectangle r;
- bitblt(&screen, scrollr.min, &screen, scrollr, 0);
- r.min.x = scrollr.min.x;
- r.max.x = scrollr.max.x;
- r.min.y = scrollr.min.y + (Dy(scrollr)*off)/nitem;
- r.max.y = scrollr.min.y + (Dy(scrollr)*(off+nitemdrawn))/nitem;
- if(r.max.y < r.min.y+2)
- r.max.y = r.min.y+2;
- border(&screen, r, 1, F, _bgpixel);
- if(menutxt == 0){
- menutxt = balloc(Rect(0, 0, 16, 16), 0);
- if(menutxt)
- wrbitmap(menutxt, 0, 16, menutxtbits);
- }
- if(menutxt)
- texture(&screen, inset(r, 1), menutxt, S);
+ bitblt(&screen, scrollr.min, &screen, scrollr, 0);
+ r.min.x = scrollr.min.x;
+ r.max.x = scrollr.max.x;
+ r.min.y = scrollr.min.y + (Dy(scrollr)*off)/nitem;
+ r.max.y = scrollr.min.y + (Dy(scrollr)*(off+nitemdrawn))/nitem;
+ if(r.max.y < r.min.y+2)
+ r.max.y = r.min.y+2;
+ border(&screen, r, 1, F, _bgpixel);
+ if(menutxt == 0){
+ menutxt = balloc(Rect(0, 0, 16, 16), 0);
+ if(menutxt)
+ wrbitmap(menutxt, 0, 16, menutxtbits);
+ }
+ if(menutxt)
+ texture(&screen, inset(r, 1), menutxt, S);
}
int
menuhit(int but, Mouse *m, Menu *menu)
{
- int i, nitem, nitemdrawn, maxwid, lasti, off, noff, wid, screenitem;
- int scrolling;
- Rectangle r, menur, sc, textr, scrollr;
- Bitmap *b;
- Point pt;
- char *item;
+ int i, nitem, nitemdrawn, maxwid, lasti, off, noff, wid, screenitem;
+ int scrolling;
+ Rectangle r, menur, sc, textr, scrollr;
+ Bitmap *b;
+ Point pt;
+ char *item;
- sc = screen.clipr;
- clipr(&screen, screen.r);
- maxwid = 0;
- for(nitem = 0;
- item = menu->item? menu->item[nitem] : (*menu->gen)(nitem);
- nitem++){
- i = strwidth(font, item);
- if(i > maxwid)
- maxwid = i;
- }
- if(menu->lasthit<0 || menu->lasthit>=nitem)
- menu->lasthit = 0;
- screenitem = (Dy(screen.r)-10)/(fontheight()+Vspacing);
- if(nitem>Maxunscroll || nitem>screenitem){
- scrolling = 1;
- nitemdrawn = Nscroll;
- if(nitemdrawn > screenitem)
- nitemdrawn = screenitem;
- wid = maxwid + Gap + Scrollwid;
- off = menu->lasthit - nitemdrawn/2;
- if(off < 0)
- off = 0;
- if(off > nitem-nitemdrawn)
- off = nitem-nitemdrawn;
- lasti = menu->lasthit-off;
- }else{
- scrolling = 0;
- nitemdrawn = nitem;
- wid = maxwid;
- off = 0;
- lasti = menu->lasthit;
- }
- r = inset(Rect(0, 0, wid, nitemdrawn*(fontheight()+Vspacing)), -Margin…
- r = rsubp(r, Pt(wid/2, lasti*(fontheight()+Vspacing)+fontheight()/2));
- r = raddp(r, m->xy);
- pt = Pt(0, 0);
- if(r.max.x>screen.r.max.x)
- pt.x = screen.r.max.x-r.max.x;
- if(r.max.y>screen.r.max.y)
- pt.y = screen.r.max.y-r.max.y;
- if(r.min.x<screen.r.min.x)
- pt.x = screen.r.min.x-r.min.x;
- if(r.min.y<screen.r.min.y)
- pt.y = screen.r.min.y-r.min.y;
- menur = raddp(r, pt);
- textr.max.x = menur.max.x-Margin;
- textr.min.x = textr.max.x-maxwid;
- textr.min.y = menur.min.y+Margin;
- textr.max.y = textr.min.y + nitemdrawn*(fontheight()+Vspacing);
- if(scrolling){
- scrollr = inset(menur, Border);
- scrollr.max.x = scrollr.min.x+Scrollwid;
- }else
- scrollr = Rect(0, 0, 0, 0);
+ sc = screen.clipr;
+ clipr(&screen, screen.r);
+ maxwid = 0;
+ for(nitem = 0;
+ item = menu->item? menu->item[nitem] : (*menu->gen)(nitem);
+ nitem++){
+ i = strwidth(font, item);
+ if(i > maxwid)
+ maxwid = i;
+ }
+ if(menu->lasthit<0 || menu->lasthit>=nitem)
+ menu->lasthit = 0;
+ screenitem = (Dy(screen.r)-10)/(fontheight()+Vspacing);
+ if(nitem>Maxunscroll || nitem>screenitem){
+ scrolling = 1;
+ nitemdrawn = Nscroll;
+ if(nitemdrawn > screenitem)
+ nitemdrawn = screenitem;
+ wid = maxwid + Gap + Scrollwid;
+ off = menu->lasthit - nitemdrawn/2;
+ if(off < 0)
+ off = 0;
+ if(off > nitem-nitemdrawn)
+ off = nitem-nitemdrawn;
+ lasti = menu->lasthit-off;
+ }else{
+ scrolling = 0;
+ nitemdrawn = nitem;
+ wid = maxwid;
+ off = 0;
+ lasti = menu->lasthit;
+ }
+ r = inset(Rect(0, 0, wid, nitemdrawn*(fontheight()+Vspacing)), -Margin);
+ r = rsubp(r, Pt(wid/2, lasti*(fontheight()+Vspacing)+fontheight()/2));
+ r = raddp(r, m->xy);
+ pt = Pt(0, 0);
+ if(r.max.x>screen.r.max.x)
+ pt.x = screen.r.max.x-r.max.x;
+ if(r.max.y>screen.r.max.y)
+ pt.y = screen.r.max.y-r.max.y;
+ if(r.min.x<screen.r.min.x)
+ pt.x = screen.r.min.x-r.min.x;
+ if(r.min.y<screen.r.min.y)
+ pt.y = screen.r.min.y-r.min.y;
+ menur = raddp(r, pt);
+ textr.max.x = menur.max.x-Margin;
+ textr.min.x = textr.max.x-maxwid;
+ textr.min.y = menur.min.y+Margin;
+ textr.max.y = textr.min.y + nitemdrawn*(fontheight()+Vspacing);
+ if(scrolling){
+ scrollr = inset(menur, Border);
+ scrollr.max.x = scrollr.min.x+Scrollwid;
+ }else
+ scrollr = Rect(0, 0, 0, 0);
- b = balloc(menur, screen.ldepth);
- if(b == 0)
- b = &screen;
- bitblt(b, menur.min, &screen, menur, S);
- bitblt(&screen, menur.min, &screen, menur, 0);
- border(&screen, menur, Blackborder, F, _bgpixel);
- r = menurect(textr, lasti);
- cursorset(divpt(add(r.min, r.max), 2));
- menupaint(menu, textr, off, nitemdrawn);
- if(scrolling)
- menuscrollpaint(scrollr, off, nitem, nitemdrawn);
- r = menurect(textr, lasti);
- cursorset(divpt(add(r.min, r.max), 2));
- menupaint(menu, textr, off, nitemdrawn);
- if(scrolling)
- menuscrollpaint(scrollr, off, nitem, nitemdrawn);
- while(m->buttons & (1<<(but-1))){
- lasti = menuscan(but, m, textr, lasti);
- if(lasti >= 0)
- break;
- while(!ptinrect(m->xy, textr) && (m->buttons & (1<<(but-1)))){
- if(scrolling && ptinrect(m->xy, scrollr)){
- noff = ((m->xy.y-scrollr.min.y)*nitem)/Dy(scro…
- noff -= nitemdrawn/2;
- if(noff < 0)
- noff = 0;
- if(noff > nitem-nitemdrawn)
- noff = nitem-nitemdrawn;
- if(noff != off){
- off = noff;
- menupaint(menu, textr, off, nitemdrawn…
- menuscrollpaint(scrollr, off, nitem, n…
- }
- }
- *m = emouse();
- }
- }
- bitblt(&screen, menur.min, b, menur, S);
- if(b != &screen)
- bfree(b);
- clipr(&screen, sc);
- if(lasti >= 0){
- menu->lasthit = lasti+off;
- return menu->lasthit;
- }
- return -1;
+ b = balloc(menur, screen.ldepth);
+ if(b == 0)
+ b = &screen;
+ bitblt(b, menur.min, &screen, menur, S);
+ bitblt(&screen, menur.min, &screen, menur, 0);
+ border(&screen, menur, Blackborder, F, _bgpixel);
+ r = menurect(textr, lasti);
+ cursorset(divpt(add(r.min, r.max), 2));
+ menupaint(menu, textr, off, nitemdrawn);
+ if(scrolling)
+ menuscrollpaint(scrollr, off, nitem, nitemdrawn);
+ r = menurect(textr, lasti);
+ cursorset(divpt(add(r.min, r.max), 2));
+ menupaint(menu, textr, off, nitemdrawn);
+ if(scrolling)
+ menuscrollpaint(scrollr, off, nitem, nitemdrawn);
+ while(m->buttons & (1<<(but-1))){
+ lasti = menuscan(but, m, textr, lasti);
+ if(lasti >= 0)
+ break;
+ while(!ptinrect(m->xy, textr) && (m->buttons & (1<<(but-1)))){
+ if(scrolling && ptinrect(m->xy, scrollr)){
+ noff = ((m->xy.y-scrollr.min.y)*nitem)/Dy(scrollr);
+ noff -= nitemdrawn/2;
+ if(noff < 0)
+ noff = 0;
+ if(noff > nitem-nitemdrawn)
+ noff = nitem-nitemdrawn;
+ if(noff != off){
+ off = noff;
+ menupaint(menu, textr, off, nitemdrawn);
+ menuscrollpaint(scrollr, off, nitem, nitemdrawn);
+ }
+ }
+ *m = emouse();
+ }
+ }
+ bitblt(&screen, menur.min, b, menur, S);
+ if(b != &screen)
+ bfree(b);
+ clipr(&screen, sc);
+ if(lasti >= 0){
+ menu->lasthit = lasti+off;
+ return menu->lasthit;
+ }
+ return -1;
}
diff --git a/libXg/point.c b/libXg/point.c
@@ -7,15 +7,15 @@
void
point(Bitmap *b, Point p, int v, Fcode f)
{
- int x, y;
- GC g;
+ int x, y;
+ GC g;
- x = p.x;
- y = p.y;
- if(b->flag&SHIFT){
- x -= b->r.min.x;
- y -= b->r.min.y;
- }
- g = _getfillgc(f, b, v);
- XDrawPoint(_dpy, (Drawable)b->id, g, x, y);
+ x = p.x;
+ y = p.y;
+ if(b->flag&SHIFT){
+ x -= b->r.min.x;
+ y -= b->r.min.y;
+ }
+ g = _getfillgc(f, b, v);
+ XDrawPoint(_dpy, (Drawable)b->id, g, x, y);
}
diff --git a/libXg/polysegment.c b/libXg/polysegment.c
@@ -7,21 +7,21 @@
void
polysegment(Bitmap *d, int n, Point *pp, int v, Fcode f)
{
- XPoint *xp;
- int i;
- GC g;
+ XPoint *xp;
+ int i;
+ GC g;
- if (!(xp = (XPoint *)calloc(n, sizeof(XPoint))))
- berror("polysegment: could not allocate XPoints");
- for (i = 0; i < n; i++, pp++)
- if(d->flag&SHIFT){
- xp[i].x = pp->x - d->r.min.x;
- xp[i].y = pp->y - d->r.min.y;
- } else {
- xp[i].x = pp->x;
- xp[i].y = pp->y;
- }
- g = _getfillgc(f, d, v);
- XDrawLines(_dpy, (Drawable)d->id, g, xp, n, CoordModeOrigin);
- free(xp);
+ if (!(xp = (XPoint *)calloc(n, sizeof(XPoint))))
+ berror("polysegment: could not allocate XPoints");
+ for (i = 0; i < n; i++, pp++)
+ if(d->flag&SHIFT){
+ xp[i].x = pp->x - d->r.min.x;
+ xp[i].y = pp->y - d->r.min.y;
+ } else {
+ xp[i].x = pp->x;
+ xp[i].y = pp->y;
+ }
+ g = _getfillgc(f, d, v);
+ XDrawLines(_dpy, (Drawable)d->id, g, xp, n, CoordModeOrigin);
+ free(xp);
}
diff --git a/libXg/rdbitmap.c b/libXg/rdbitmap.c
@@ -7,57 +7,57 @@
void
rdbitmap(Bitmap *b, int miny, int maxy, unsigned char *data)
{
- XImage *gim, *eim;
- int x, y, w, h, pix, l, offset, px;
- int inld, outld;
- char *tdata;
+ XImage *gim, *eim;
+ int x, y, w, h, pix, l, offset, px;
+ int inld, outld;
+ char *tdata;
- /*
- * The XGetImage returned image may be wrong in a number of ways:
- * wrong bit order, byte order, bit pad, scanline pad,
- * and constant shift.
- * So use a SLOW loop, for now
- */
- w = Dx(b->r);
- h = maxy - miny;
- outld = b->ldepth;
- inld = (b->ldepth == 0) ? 0 : screen.ldepth;
- gim = XGetImage(_dpy, (Drawable)b->id, 0, miny - b->r.min.y,
- w, h, ~0, ZPixmap);
- px = 1<<(3-outld); /* pixels per byte */
- /* set l to number of bytes of data per scan line */
- if(b->r.min.x >= 0)
- offset = b->r.min.x % px;
- else
- offset = px - b->r.min.x % px;
- l = (-b->r.min.x+px-1)/px;
- if(b->r.max.x >= 0)
- l += (b->r.max.x+px-1)/px;
- else
- l -= b->r.max.x/px;
- l *= h;
- if(l <= 0)
- return;
- tdata = (char *)malloc(l);
- if (tdata == (char *) 0)
- berror("rdbitmap malloc");
- eim = XCreateImage(_dpy, 0, 1 << inld, ZPixmap, 0, tdata,
- w+offset, h, 8, 0);
- eim->bitmap_pad = 8;
- eim->bitmap_bit_order = MSBFirst;
- eim->byte_order = MSBFirst;
+ /*
+ * The XGetImage returned image may be wrong in a number of ways:
+ * wrong bit order, byte order, bit pad, scanline pad,
+ * and constant shift.
+ * So use a SLOW loop, for now
+ */
+ w = Dx(b->r);
+ h = maxy - miny;
+ outld = b->ldepth;
+ inld = (b->ldepth == 0) ? 0 : screen.ldepth;
+ gim = XGetImage(_dpy, (Drawable)b->id, 0, miny - b->r.min.y,
+ w, h, ~0, ZPixmap);
+ px = 1<<(3-outld); /* pixels per byte */
+ /* set l to number of bytes of data per scan line */
+ if(b->r.min.x >= 0)
+ offset = b->r.min.x % px;
+ else
+ offset = px - b->r.min.x % px;
+ l = (-b->r.min.x+px-1)/px;
+ if(b->r.max.x >= 0)
+ l += (b->r.max.x+px-1)/px;
+ else
+ l -= b->r.max.x/px;
+ l *= h;
+ if(l <= 0)
+ return;
+ tdata = (char *)malloc(l);
+ if (tdata == (char *) 0)
+ berror("rdbitmap malloc");
+ eim = XCreateImage(_dpy, 0, 1 << inld, ZPixmap, 0, tdata,
+ w+offset, h, 8, 0);
+ eim->bitmap_pad = 8;
+ eim->bitmap_bit_order = MSBFirst;
+ eim->byte_order = MSBFirst;
- for(y = 0; y < h; y++)
- for(x = 0; x < w; x++) {
- pix = XGetPixel(gim, x, y);
- XPutPixel(eim, x+offset, y, pix);
- }
+ for(y = 0; y < h; y++)
+ for(x = 0; x < w; x++) {
+ pix = XGetPixel(gim, x, y);
+ XPutPixel(eim, x+offset, y, pix);
+ }
- if (inld == outld)
- memcpy((char *)data, tdata, l);
- else
- _ldconvert(tdata, inld, (char*)data, outld, w, h);
+ if (inld == outld)
+ memcpy((char *)data, tdata, l);
+ else
+ _ldconvert(tdata, inld, (char*)data, outld, w, h);
- XDestroyImage(gim);
- XDestroyImage(eim);
+ XDestroyImage(gim);
+ XDestroyImage(eim);
}
diff --git a/libXg/rdbitmapfile.c b/libXg/rdbitmapfile.c
@@ -9,57 +9,57 @@
Bitmap*
rdbitmapfile(int fd)
{
- char hdr[5*12+1];
- unsigned char *data;
- long dy, px;
- unsigned long l, t, n;
- long miny, maxy;
- Rectangle r;
- int ld;
- Bitmap *b;
+ char hdr[5*12+1];
+ unsigned char *data;
+ long dy, px;
+ unsigned long l, t, n;
+ long miny, maxy;
+ Rectangle r;
+ int ld;
+ Bitmap *b;
- if(read(fd, hdr, 5*12)!=5*12)
- berror("rdbitmapfile read");
- ld = atoi(hdr+0*12);
- r.min.x = atoi(hdr+1*12);
- r.min.y = atoi(hdr+2*12);
- r.max.x = atoi(hdr+3*12);
- r.max.y = atoi(hdr+4*12);
- if(ld<0 || ld>1)
- berror("rdbitmapfile ldepth");
- if(r.min.x>r.max.x || r.min.y>r.max.y)
- berror("rdbitmapfile rectangle");
+ if(read(fd, hdr, 5*12)!=5*12)
+ berror("rdbitmapfile read");
+ ld = atoi(hdr+0*12);
+ r.min.x = atoi(hdr+1*12);
+ r.min.y = atoi(hdr+2*12);
+ r.max.x = atoi(hdr+3*12);
+ r.max.y = atoi(hdr+4*12);
+ if(ld<0 || ld>1)
+ berror("rdbitmapfile ldepth");
+ if(r.min.x>r.max.x || r.min.y>r.max.y)
+ berror("rdbitmapfile rectangle");
- miny = r.min.y;
- maxy = r.max.y;
- px = 1<<(3-ld); /* pixels per byte */
- /* set l to number of bytes of data per scan line */
- if(r.min.x >= 0)
- l = (r.max.x+px-1)/px - r.min.x/px;
- else{ /* make positive before divide */
- t = (-r.min.x)+px-1;
- t = (t/px)*px;
- l = (t+r.max.x+px-1)/px;
- }
- b = balloc(r, ld);
- if(b == 0)
- return 0;
- data = (unsigned char *)malloc(CHUNK);
- if(data == 0)
- berror("rdbitmapfile malloc");
- while(maxy > miny){
- dy = maxy - miny;
- if(dy*l > CHUNK)
- dy = CHUNK/l;
- n = dy*l;
- if(read(fd, data, n) != n){
- free(data);
- bfree(b);
- berror("rdbitmapfile read");
- }
- wrbitmap(b, miny, miny+dy, data);
- miny += dy;
- }
- free(data);
- return b;
+ miny = r.min.y;
+ maxy = r.max.y;
+ px = 1<<(3-ld); /* pixels per byte */
+ /* set l to number of bytes of data per scan line */
+ if(r.min.x >= 0)
+ l = (r.max.x+px-1)/px - r.min.x/px;
+ else{ /* make positive before divide */
+ t = (-r.min.x)+px-1;
+ t = (t/px)*px;
+ l = (t+r.max.x+px-1)/px;
+ }
+ b = balloc(r, ld);
+ if(b == 0)
+ return 0;
+ data = (unsigned char *)malloc(CHUNK);
+ if(data == 0)
+ berror("rdbitmapfile malloc");
+ while(maxy > miny){
+ dy = maxy - miny;
+ if(dy*l > CHUNK)
+ dy = CHUNK/l;
+ n = dy*l;
+ if(read(fd, data, n) != n){
+ free(data);
+ bfree(b);
+ berror("rdbitmapfile read");
+ }
+ wrbitmap(b, miny, miny+dy, data);
+ miny += dy;
+ }
+ free(data);
+ return b;
}
diff --git a/libXg/rectclip.c b/libXg/rectclip.c
@@ -3,23 +3,23 @@
#include <libc.h>
#include <libg.h>
-int rectclip(Rectangle *rp, Rectangle b) /* first by reference,…
+int rectclip(Rectangle *rp, Rectangle b) /* first by reference, second …
{
- Rectangle *bp = &b;
- /*
- * Expand rectXrect() in line for speed
- */
- if((rp->min.x<bp->max.x && bp->min.x<rp->max.x &&
- rp->min.y<bp->max.y && bp->min.y<rp->max.y)==0)
- return 0;
- /* They must overlap */
- if(rp->min.x < bp->min.x)
- rp->min.x = bp->min.x;
- if(rp->min.y < bp->min.y)
- rp->min.y = bp->min.y;
- if(rp->max.x > bp->max.x)
- rp->max.x = bp->max.x;
- if(rp->max.y > bp->max.y)
- rp->max.y = bp->max.y;
- return 1;
+ Rectangle *bp = &b;
+ /*
+ * Expand rectXrect() in line for speed
+ */
+ if((rp->min.x<bp->max.x && bp->min.x<rp->max.x &&
+ rp->min.y<bp->max.y && bp->min.y<rp->max.y)==0)
+ return 0;
+ /* They must overlap */
+ if(rp->min.x < bp->min.x)
+ rp->min.x = bp->min.x;
+ if(rp->min.y < bp->min.y)
+ rp->min.y = bp->min.y;
+ if(rp->max.x > bp->max.x)
+ rp->max.x = bp->max.x;
+ if(rp->max.y > bp->max.y)
+ rp->max.y = bp->max.y;
+ return 1;
}
diff --git a/libXg/rune.c b/libXg/rune.c
@@ -1,213 +1,213 @@
/* Copyright (c) 1998 Lucent Technologies - All rights reserved. */
-#include <u.h>
-#include <libc.h>
+#include <u.h>
+#include <libc.h>
#include <string.h>
enum
{
- Bit1 = 7,
- Bitx = 6,
- Bit2 = 5,
- Bit3 = 4,
- Bit4 = 3,
-
- T1 = ((1<<(Bit1+1))-1) ^ 0xFF, /* 0000 0000 */
- Tx = ((1<<(Bitx+1))-1) ^ 0xFF, /* 1000 0000 */
- T2 = ((1<<(Bit2+1))-1) ^ 0xFF, /* 1100 0000 */
- T3 = ((1<<(Bit3+1))-1) ^ 0xFF, /* 1110 0000 */
- T4 = ((1<<(Bit4+1))-1) ^ 0xFF, /* 1111 0000 */
-
- Rune1 = (1<<(Bit1+0*Bitx))-1, /* 0000 0000 0111 …
- Rune2 = (1<<(Bit2+1*Bitx))-1, /* 0000 0111 1111 …
- Rune3 = (1<<(Bit3+2*Bitx))-1, /* 1111 1111 1111 …
-
- Maskx = (1<<Bitx)-1, /* 0011 1111 */
- Testx = Maskx ^ 0xFF, /* 1100 0000 */
-
- Bad = Runeerror
+ Bit1 = 7,
+ Bitx = 6,
+ Bit2 = 5,
+ Bit3 = 4,
+ Bit4 = 3,
+
+ T1 = ((1<<(Bit1+1))-1) ^ 0xFF, /* 0000 0000 */
+ Tx = ((1<<(Bitx+1))-1) ^ 0xFF, /* 1000 0000 */
+ T2 = ((1<<(Bit2+1))-1) ^ 0xFF, /* 1100 0000 */
+ T3 = ((1<<(Bit3+1))-1) ^ 0xFF, /* 1110 0000 */
+ T4 = ((1<<(Bit4+1))-1) ^ 0xFF, /* 1111 0000 */
+
+ Rune1 = (1<<(Bit1+0*Bitx))-1, /* 0000 0000 0111 1111 */
+ Rune2 = (1<<(Bit2+1*Bitx))-1, /* 0000 0111 1111 1111 */
+ Rune3 = (1<<(Bit3+2*Bitx))-1, /* 1111 1111 1111 1111 */
+
+ Maskx = (1<<Bitx)-1, /* 0011 1111 */
+ Testx = Maskx ^ 0xFF, /* 1100 0000 */
+
+ Bad = Runeerror
};
int
chartorune(Rune *rune, char *str)
{
- int c, c1, c2;
- long l;
-
- /*
- * one character sequence
- * 00000-0007F => T1
- */
- c = *(uchar*)str;
- if(c < Tx) {
- *rune = c;
- return 1;
- }
-
- /*
- * two character sequence
- * 0080-07FF => T2 Tx
- */
- c1 = *(uchar*)(str+1) ^ Tx;
- if(c1 & Testx)
- goto bad;
- if(c < T3) {
- if(c < T2)
- goto bad;
- l = ((c << Bitx) | c1) & Rune2;
- if(l <= Rune1)
- goto bad;
- *rune = l;
- return 2;
- }
-
- /*
- * three character sequence
- * 0800-FFFF => T3 Tx Tx
- */
- c2 = *(uchar*)(str+2) ^ Tx;
- if(c2 & Testx)
- goto bad;
- if(c < T4) {
- l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3;
- if(l <= Rune2)
- goto bad;
- *rune = l;
- return 3;
- }
-
- /*
- * bad decoding
- */
+ int c, c1, c2;
+ long l;
+
+ /*
+ * one character sequence
+ * 00000-0007F => T1
+ */
+ c = *(uchar*)str;
+ if(c < Tx) {
+ *rune = c;
+ return 1;
+ }
+
+ /*
+ * two character sequence
+ * 0080-07FF => T2 Tx
+ */
+ c1 = *(uchar*)(str+1) ^ Tx;
+ if(c1 & Testx)
+ goto bad;
+ if(c < T3) {
+ if(c < T2)
+ goto bad;
+ l = ((c << Bitx) | c1) & Rune2;
+ if(l <= Rune1)
+ goto bad;
+ *rune = l;
+ return 2;
+ }
+
+ /*
+ * three character sequence
+ * 0800-FFFF => T3 Tx Tx
+ */
+ c2 = *(uchar*)(str+2) ^ Tx;
+ if(c2 & Testx)
+ goto bad;
+ if(c < T4) {
+ l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3;
+ if(l <= Rune2)
+ goto bad;
+ *rune = l;
+ return 3;
+ }
+
+ /*
+ * bad decoding
+ */
bad:
- *rune = Bad;
- return 1;
+ *rune = Bad;
+ return 1;
}
int
runetochar(char *str, Rune *rune)
{
- long c;
-
- /*
- * one character sequence
- * 00000-0007F => 00-7F
- */
- c = *rune;
- if(c <= Rune1) {
- str[0] = c;
- return 1;
- }
-
- /*
- * two character sequence
- * 0080-07FF => T2 Tx
- */
- if(c <= Rune2) {
- str[0] = T2 | (c >> 1*Bitx);
- str[1] = Tx | (c & Maskx);
- return 2;
- }
-
- /*
- * three character sequence
- * 0800-FFFF => T3 Tx Tx
- */
- str[0] = T3 | (c >> 2*Bitx);
- str[1] = Tx | ((c >> 1*Bitx) & Maskx);
- str[2] = Tx | (c & Maskx);
- return 3;
+ long c;
+
+ /*
+ * one character sequence
+ * 00000-0007F => 00-7F
+ */
+ c = *rune;
+ if(c <= Rune1) {
+ str[0] = c;
+ return 1;
+ }
+
+ /*
+ * two character sequence
+ * 0080-07FF => T2 Tx
+ */
+ if(c <= Rune2) {
+ str[0] = T2 | (c >> 1*Bitx);
+ str[1] = Tx | (c & Maskx);
+ return 2;
+ }
+
+ /*
+ * three character sequence
+ * 0800-FFFF => T3 Tx Tx
+ */
+ str[0] = T3 | (c >> 2*Bitx);
+ str[1] = Tx | ((c >> 1*Bitx) & Maskx);
+ str[2] = Tx | (c & Maskx);
+ return 3;
}
int
runelen(long c)
{
- Rune rune;
- char str[10];
+ Rune rune;
+ char str[10];
- rune = c;
- return runetochar(str, &rune);
+ rune = c;
+ return runetochar(str, &rune);
}
int
runenlen(Rune *r, int nrune)
{
- int nb, c;
-
- nb = 0;
- while(nrune--) {
- c = *r++;
- if(c <= Rune1)
- nb++;
- else
- if(c <= Rune2)
- nb += 2;
- else
- nb += 3;
- }
- return nb;
+ int nb, c;
+
+ nb = 0;
+ while(nrune--) {
+ c = *r++;
+ if(c <= Rune1)
+ nb++;
+ else
+ if(c <= Rune2)
+ nb += 2;
+ else
+ nb += 3;
+ }
+ return nb;
}
int
fullrune(char *str, int n)
{
- int c;
-
- if(n > 0) {
- c = *(uchar*)str;
- if(c < Tx)
- return 1;
- if(n > 1)
- if(c < T3 || n > 2)
- return 1;
- }
- return 0;
+ int c;
+
+ if(n > 0) {
+ c = *(uchar*)str;
+ if(c < Tx)
+ return 1;
+ if(n > 1)
+ if(c < T3 || n > 2)
+ return 1;
+ }
+ return 0;
}
char*
utfrune(char *s, long c)
{
- long c1;
- Rune r;
- int n;
-
- if(c < Runesync) /* not part of utf sequence */
- return strchr(s, c);
-
- for(;;) {
- c1 = *(uchar*)s;
- if(c1 < Runeself) { /* one byte rune */
- if(c1 == 0)
- return 0;
- if(c1 == c)
- return s;
- s++;
- continue;
- }
- n = chartorune(&r, s);
- if(r == c)
- return s;
- s += n;
- }
- return 0;
+ long c1;
+ Rune r;
+ int n;
+
+ if(c < Runesync) /* not part of utf sequence */
+ return strchr(s, c);
+
+ for(;;) {
+ c1 = *(uchar*)s;
+ if(c1 < Runeself) { /* one byte rune */
+ if(c1 == 0)
+ return 0;
+ if(c1 == c)
+ return s;
+ s++;
+ continue;
+ }
+ n = chartorune(&r, s);
+ if(r == c)
+ return s;
+ s += n;
+ }
+ return 0;
}
int
utflen(char *s)
{
- int c;
- long n;
- Rune rune;
-
- n = 0;
- for(;;) {
- c = *(uchar*)s;
- if(c < Runeself) {
- if(c == 0)
- return n;
- s++;
- } else
- s += chartorune(&rune, s);
- n++;
- }
- return 0;
+ int c;
+ long n;
+ Rune rune;
+
+ n = 0;
+ for(;;) {
+ c = *(uchar*)s;
+ if(c < Runeself) {
+ if(c == 0)
+ return n;
+ s++;
+ } else
+ s += chartorune(&rune, s);
+ n++;
+ }
+ return 0;
}
diff --git a/libXg/segment.c b/libXg/segment.c
@@ -7,19 +7,19 @@
void
segment(Bitmap *d, Point p1, Point p2, int v, Fcode f)
{
- int x1, y1, x2, y2;
- GC g;
+ int x1, y1, x2, y2;
+ GC g;
- x1 = p1.x;
- y1 = p1.y;
- x2 = p2.x;
- y2 = p2.y;
- if(d->flag&SHIFT){
- x1 -= d->r.min.x;
- y1 -= d->r.min.y;
- x2 -= d->r.min.x;
- y2 -= d->r.min.y;
- }
- g = _getfillgc(f, d, v);
- XDrawLine(_dpy, (Drawable)d->id, g, x1, y1, x2, y2);
+ x1 = p1.x;
+ y1 = p1.y;
+ x2 = p2.x;
+ y2 = p2.y;
+ if(d->flag&SHIFT){
+ x1 -= d->r.min.x;
+ y1 -= d->r.min.y;
+ x2 -= d->r.min.x;
+ y2 -= d->r.min.y;
+ }
+ g = _getfillgc(f, d, v);
+ XDrawLine(_dpy, (Drawable)d->id, g, x1, y1, x2, y2);
}
diff --git a/libXg/string.c b/libXg/string.c
@@ -5,33 +5,33 @@
#include <libg.h>
#include "libgint.h"
-enum { Max = 128 };
+enum { Max = 128 };
Point
string(Bitmap *b, Point p, XftFont *ft, char *s, Fcode f)
{
- size_t length = strlen(s);
- XGlyphInfo extents = {0};
- int x = p.x;
- int y = p.y;
+ size_t length = strlen(s);
+ XGlyphInfo extents = {0};
+ int x = p.x;
+ int y = p.y;
- XftTextExtentsUtf8(_dpy, ft, s, length, &extents);
+ XftTextExtentsUtf8(_dpy, ft, s, length, &extents);
- x = p.x;
- y = p.y;
- if (b->flag & SHIFT){
- x -= b->r.min.x;
- y -= b->r.min.y;
- }
- y += ft->ascent;
+ x = p.x;
+ y = p.y;
+ if (b->flag & SHIFT){
+ x -= b->r.min.x;
+ y -= b->r.min.y;
+ }
+ y += ft->ascent;
if (!b->fd)
- b->fd = XftDrawCreate(_dpy, (Drawable)(b->id), DefaultVisual(_dpy,…
- XftDrawStringUtf8(b->fd, &fontcolor, ft, x, y, s, length);
+ b->fd = XftDrawCreate(_dpy, (Drawable)(b->id), DefaultVisual(_dpy, Def…
+ XftDrawStringUtf8(b->fd, &fontcolor, ft, x, y, s, length);
- x += extents.xOff;
+ x += extents.xOff;
- p.x = (b->flag & SHIFT) ? x + b->r.min.x : x;
- p.x = x + b->r.min.x;
- return p;
+ p.x = (b->flag & SHIFT) ? x + b->r.min.x : x;
+ p.x = x + b->r.min.x;
+ return p;
}
diff --git a/libXg/strwidth.c b/libXg/strwidth.c
@@ -19,5 +19,5 @@ strsize(XftFont *f, char *s)
XGlyphInfo extents = {0};
XftTextExtentsUtf8(_dpy, f, s, strlen(s), &extents);
- return Pt(strwidth(f, s), extents.yOff);
+ return Pt(strwidth(f, s), extents.yOff);
}
diff --git a/libXg/texture.c b/libXg/texture.c
@@ -7,36 +7,36 @@
void
texture(Bitmap *d, Rectangle r, Bitmap *s, Fcode f)
{
- int x, y, w, h, bfunc;
- GC g;
+ int x, y, w, h, bfunc;
+ GC g;
- x = r.min.x;
- y = r.min.y;
- if(d->flag&SHIFT){
- x -= d->r.min.x;
- y -= d->r.min.y;
- }
- g = _getcopygc(f, d, s, &bfunc);
- if(d->flag&SHIFT){
- XSetTSOrigin(_dpy, g, -d->r.min.x, -d->r.min.y);
- }else
- XSetTSOrigin(_dpy, g, 0, 0);
- w = Dx(r);
- h = Dy(r);
- if(bfunc == UseFillRectangle){
- /* source isn't involved at all */
- XFillRectangle(_dpy, (Drawable)d->id, g, x, y, w, h);
- }else if(bfunc == UseCopyArea){
- XSetTile(_dpy, g, (Drawable)s->id);
- XSetFillStyle(_dpy, g, FillTiled);
- XFillRectangle(_dpy, (Drawable)d->id, g, x, y, w, h);
- XSetFillStyle(_dpy, g, FillSolid);
- }else{
- if(s->ldepth != 0)
- berror("unsupported texture");
- XSetStipple(_dpy, g, (Drawable)s->id);
- XSetFillStyle(_dpy, g, FillOpaqueStippled);
- XFillRectangle(_dpy, (Drawable)d->id, g, x, y, w, h);
- XSetFillStyle(_dpy, g, FillSolid);
- }
+ x = r.min.x;
+ y = r.min.y;
+ if(d->flag&SHIFT){
+ x -= d->r.min.x;
+ y -= d->r.min.y;
+ }
+ g = _getcopygc(f, d, s, &bfunc);
+ if(d->flag&SHIFT){
+ XSetTSOrigin(_dpy, g, -d->r.min.x, -d->r.min.y);
+ }else
+ XSetTSOrigin(_dpy, g, 0, 0);
+ w = Dx(r);
+ h = Dy(r);
+ if(bfunc == UseFillRectangle){
+ /* source isn't involved at all */
+ XFillRectangle(_dpy, (Drawable)d->id, g, x, y, w, h);
+ }else if(bfunc == UseCopyArea){
+ XSetTile(_dpy, g, (Drawable)s->id);
+ XSetFillStyle(_dpy, g, FillTiled);
+ XFillRectangle(_dpy, (Drawable)d->id, g, x, y, w, h);
+ XSetFillStyle(_dpy, g, FillSolid);
+ }else{
+ if(s->ldepth != 0)
+ berror("unsupported texture");
+ XSetStipple(_dpy, g, (Drawable)s->id);
+ XSetFillStyle(_dpy, g, FillOpaqueStippled);
+ XFillRectangle(_dpy, (Drawable)d->id, g, x, y, w, h);
+ XSetFillStyle(_dpy, g, FillSolid);
+ }
}
diff --git a/libXg/wrbitmap.c b/libXg/wrbitmap.c
@@ -12,44 +12,44 @@
void
wrbitmap(Bitmap *b, int miny, int maxy, unsigned char *data)
{
- XImage *im;
- int w, h, inld, outld, l, offset, px;
- GC g;
- char *tdata;
+ XImage *im;
+ int w, h, inld, outld, l, offset, px;
+ GC g;
+ char *tdata;
- w = Dx(b->r);
- h = maxy - miny;
- inld = b->ldepth;
- outld = (b->ldepth == 0) ? 0 : screen.ldepth;
- px = 1<<(3-outld); /* pixels per byte */
- /* set l to number of bytes of data per scan line */
- if(b->r.min.x >= 0)
- offset = b->r.min.x % px;
- else
- offset = px - b->r.min.x % px;
- l = (-b->r.min.x+px-1)/px;
- if(b->r.max.x >= 0)
- l += (b->r.max.x+px-1)/px;
- else
- l -= b->r.max.x/px;
- l *= h;
+ w = Dx(b->r);
+ h = maxy - miny;
+ inld = b->ldepth;
+ outld = (b->ldepth == 0) ? 0 : screen.ldepth;
+ px = 1<<(3-outld); /* pixels per byte */
+ /* set l to number of bytes of data per scan line */
+ if(b->r.min.x >= 0)
+ offset = b->r.min.x % px;
+ else
+ offset = px - b->r.min.x % px;
+ l = (-b->r.min.x+px-1)/px;
+ if(b->r.max.x >= 0)
+ l += (b->r.max.x+px-1)/px;
+ else
+ l -= b->r.max.x/px;
+ l *= h;
- tdata = (char *)malloc(l);
- if (tdata == (char *) 0)
- berror("wrbitmap malloc");
- if (inld == outld)
- memcpy((void*)tdata, (void*)data, l);
- else
- _ldconvert((char*)data, inld, tdata, outld, w, h);
+ tdata = (char *)malloc(l);
+ if (tdata == (char *) 0)
+ berror("wrbitmap malloc");
+ if (inld == outld)
+ memcpy((void*)tdata, (void*)data, l);
+ else
+ _ldconvert((char*)data, inld, tdata, outld, w, h);
- im = XCreateImage(_dpy, 0, 1 << outld, ZPixmap, 0, tdata, w, h, 8, 0);
+ im = XCreateImage(_dpy, 0, 1 << outld, ZPixmap, 0, tdata, w, h, 8, 0);
- /* Botched interface to XCreateImage doesn't let you set these: */
- im->bitmap_bit_order = MSBFirst;
- im->byte_order = MSBFirst;
+ /* Botched interface to XCreateImage doesn't let you set these: */
+ im->bitmap_bit_order = MSBFirst;
+ im->byte_order = MSBFirst;
- g = _getfillgc(S, b, ~0);
- XSetBackground(_dpy, g, b->flag&DP1 ? 0 : _bgpixel);
- XPutImage(_dpy, (Drawable)b->id, g, im, offset, 0, 0, miny - b->r.min.…
- XDestroyImage(im);
+ g = _getfillgc(S, b, ~0);
+ XSetBackground(_dpy, g, b->flag&DP1 ? 0 : _bgpixel);
+ XPutImage(_dpy, (Drawable)b->id, g, im, offset, 0, 0, miny - b->r.min.y, w…
+ XDestroyImage(im);
}
diff --git a/libXg/wrbitmapfile.c b/libXg/wrbitmapfile.c
@@ -4,47 +4,47 @@
#include <libg.h>
#include "libgint.h"
-#define CHUNK 4096
+#define CHUNK 4096
void
wrbitmapfile(int fd, Bitmap *b)
{
- char hdr[5*12+1];
- unsigned char *data;
- long dy, px;
- unsigned long l, t, n;
- long miny, maxy;
+ char hdr[5*12+1];
+ unsigned char *data;
+ long dy, px;
+ unsigned long l, t, n;
+ long miny, maxy;
- sprint(hdr, "%11d %11d %11d %11d %11d ",
- b->ldepth, b->r.min.x, b->r.min.y, b->r.max.x, b->r.max.y);
- if(write(fd, hdr, 5*12) != 5*12)
- berror("wrbitmapfile write");
+ sprint(hdr, "%11d %11d %11d %11d %11d ",
+ b->ldepth, b->r.min.x, b->r.min.y, b->r.max.x, b->r.max.y);
+ if(write(fd, hdr, 5*12) != 5*12)
+ berror("wrbitmapfile write");
- px = 1<<(3-b->ldepth); /* pixels per byte */
- /* set l to number of bytes of data per scan line */
- if(b->r.min.x >= 0)
- l = (b->r.max.x+px-1)/px - b->r.min.x/px;
- else{ /* make positive before divide */
- t = (-b->r.min.x)+px-1;
- t = (t/px)*px;
- l = (t+b->r.max.x+px-1)/px;
- }
- miny = b->r.min.y;
- maxy = b->r.max.y;
- data = (unsigned char *)malloc(CHUNK);
- if(data == 0)
- berror("wrbitmapfile malloc");
- while(maxy > miny){
- dy = maxy - miny;
- if(dy*l > CHUNK)
- dy = CHUNK/l;
- rdbitmap(b, miny, miny+dy, data);
- n = dy*l;
- if(write(fd, data, n) != n){
- free(data);
- berror("wrbitmapfile write");
- }
- miny += dy;
- }
- free(data);
+ px = 1<<(3-b->ldepth); /* pixels per byte */
+ /* set l to number of bytes of data per scan line */
+ if(b->r.min.x >= 0)
+ l = (b->r.max.x+px-1)/px - b->r.min.x/px;
+ else{ /* make positive before divide */
+ t = (-b->r.min.x)+px-1;
+ t = (t/px)*px;
+ l = (t+b->r.max.x+px-1)/px;
+ }
+ miny = b->r.min.y;
+ maxy = b->r.max.y;
+ data = (unsigned char *)malloc(CHUNK);
+ if(data == 0)
+ berror("wrbitmapfile malloc");
+ while(maxy > miny){
+ dy = maxy - miny;
+ if(dy*l > CHUNK)
+ dy = CHUNK/l;
+ rdbitmap(b, miny, miny+dy, data);
+ n = dy*l;
+ if(write(fd, data, n) != n){
+ free(data);
+ berror("wrbitmapfile write");
+ }
+ miny += dy;
+ }
+ free(data);
}
diff --git a/libXg/xtbinit.c b/libXg/xtbinit.c
@@ -49,23 +49,23 @@
#endif
/* libg globals */
-Bitmap screen;
-XftFont *font;
+Bitmap screen;
+XftFont *font;
XftColor fontcolor;
/* implementation globals */
extern char *machine;
-Display *_dpy;
-Widget _toplevel;
+Display *_dpy;
+Widget _toplevel;
Window _topwindow;
unsigned long _bgpixels[MAX_BACKGROUNDS];
int _nbgs;
-unsigned long _fgpixel, _bgpixel, _borderpixel;
-XColor _fgcolor, _bgcolor, _bordercolor;
-int _ld2d[6] = { 1, 2, 4, 8, 16, 24 };
-unsigned long _ld2dmask[6] = { 0x1, 0x3, 0xF, 0xFF, 0xFFFF, 0x00FFFFFF …
-Colormap _libg_cmap;
-int _cmap_installed;
+unsigned long _fgpixel, _bgpixel, _borderpixel;
+XColor _fgcolor, _bgcolor, _bordercolor;
+int _ld2d[6] = { 1, 2, 4, 8, 16, 24 };
+unsigned long _ld2dmask[6] = { 0x1, 0x3, 0xF, 0xFF, 0xFFFF, 0x00FFFFFF };
+Colormap _libg_cmap;
+int _cmap_installed;
/* xbinit implementation globals */
#ifndef R3
@@ -77,24 +77,24 @@ static Atom wm_take_focus;
static Mouse lastmouse;
typedef struct Ebuf {
- struct Ebuf *next;
- int n;
- unsigned char buf[4];
+ struct Ebuf *next;
+ int n;
+ unsigned char buf[4];
} Ebuf;
typedef struct Esrc {
- int inuse;
- int size;
- int count;
- Ebuf *head;
- Ebuf *tail;
+ int inuse;
+ int size;
+ int count;
+ Ebuf *head;
+ Ebuf *tail;
} Esrc;
-#define MAXINPUT 1024 /* number of queued input e…
-#define MAXSRC 10
+#define MAXINPUT 1024 /* number of queued input events */
+#define MAXSRC 10
-static Esrc esrc[MAXSRC];
-static int nsrc;
+static Esrc esrc[MAXSRC];
+static int nsrc;
static int einitcalled = 0;
@@ -103,19 +103,19 @@ static int Skeyboard = -1;
static int Stimer = -1;
-static void reshaped(int, int, int, int);
-static void gotchar(int, int, int, int, int);
-static void gotmouse(Gwinmouse *);
-static int ilog2(int);
-static void pixtocolor(Pixel, XColor *);
-static Ebuf *ebread(Esrc *);
-static Ebuf *ebadd(Esrc *, int);
-static void focinit(Widget);
-static void wmproto(Widget, XEvent *, String *, Cardinal *);
-static void waitevent(void);
+static void reshaped(int, int, int, int);
+static void gotchar(int, int, int, int, int);
+static void gotmouse(Gwinmouse *);
+static int ilog2(int);
+static void pixtocolor(Pixel, XColor *);
+static Ebuf *ebread(Esrc *);
+static Ebuf *ebadd(Esrc *, int);
+static void focinit(Widget);
+static void wmproto(Widget, XEvent *, String *, Cardinal *);
+static void waitevent(void);
void initlatin();
-static Errfunc onerr;
+static Errfunc onerr;
String _fallbacks[] = {
"*gwin.width: 400",
@@ -149,19 +149,19 @@ xtbinit(Errfunc f, char *class, int *pargc, char **argv, …
initlatin();
if(!class && argv[0]){
- p = strrchr(argv[0], '/');
- if(p)
- class = XtNewString(p+1);
- else
- class = XtNewString(argv[0]);
- if(class[0] >= 'a' && class[0] <= 'z')
- class[0] += 'A' - 'a';
+ p = strrchr(argv[0], '/');
+ if(p)
+ class = XtNewString(p+1);
+ else
+ class = XtNewString(argv[0]);
+ if(class[0] >= 'a' && class[0] <= 'z')
+ class[0] += 'A' - 'a';
}
onerr = f;
if (!fallbacks)
- fallbacks = _fallbacks;
+ fallbacks = _fallbacks;
n = 0;
- XtSetArg(args[n], XtNinput, TRUE); n++;
+ XtSetArg(args[n], XtNinput, TRUE); n++;
char name[512] = {0};
snprintf(name, sizeof(name) - 1, "samterm on %s", machine);
@@ -169,14 +169,14 @@ xtbinit(Errfunc f, char *class, int *pargc, char **argv, …
XtSetArg(args[n], XtNiconName, XtNewString(name)); n++;
_toplevel = XtAppInitialize(&app, class,
- optable, sizeof(optable)/sizeof(optable[0]),
- pargc, argv, fallbacks, args, n);
+ optable, sizeof(optable)/sizeof(optable[0]),
+ pargc, argv, fallbacks, args, n);
n = 0;
- XtSetArg(args[n], XtNreshaped, reshaped); n++;
- XtSetArg(args[n], XtNgotchar, gotchar); n++;
- XtSetArg(args[n], XtNgotmouse, gotmouse); n++;
+ XtSetArg(args[n], XtNreshaped, reshaped); n++;
+ XtSetArg(args[n], XtNgotchar, gotchar); n++;
+ XtSetArg(args[n], XtNgotmouse, gotmouse); n++;
widg = XtCreateManagedWidget("gwin", gwinWidgetClass, _toplevel, args, n);
_dpy = XtDisplay(widg);
@@ -199,14 +199,14 @@ xtbinit(Errfunc f, char *class, int *pargc, char **argv, …
_bgpixel = _bgpixels[0];
n = 0;
- XtSetArg(args[n], XtNdepth, &depth); n++;
- XtSetArg(args[n], XtNcomposeMod, &compose); n++;
+ XtSetArg(args[n], XtNdepth, &depth); n++;
+ XtSetArg(args[n], XtNcomposeMod, &compose); n++;
XtGetValues(widg, args, n);
if (compose < 0 || compose > 5) {
- n = 0;
- XtSetArg(args[n], XtNcomposeMod, 0); n++;
- XtSetValues(widg, args, n);
+ n = 0;
+ XtSetArg(args[n], XtNcomposeMod, 0); n++;
+ XtSetValues(widg, args, n);
}
initcursors();
@@ -233,13 +233,13 @@ xtbinit(Errfunc f, char *class, int *pargc, char **argv, …
screen.ldepth = ilog2(depth);
screen.flag = SCR;
if(_fgpixel != 0)
- screen.flag |= BL1;
+ screen.flag |= BL1;
if(depth == 1)
- screen.flag |= DP1;
+ screen.flag |= DP1;
/* leave screen rect at all zeros until reshaped() sets it */
while(!exposed) {
- XFlush(_dpy);
- XtAppProcessEvent(app, XtIMXEvent);
+ XFlush(_dpy);
+ XtAppProcessEvent(app, XtIMXEvent);
}
XFlush(_dpy);
focinit(_toplevel);
@@ -270,8 +270,8 @@ wmproto(Widget w, XEvent *e , String *p, Cardinal *np)
if(e->type == ClientMessage &&
(Atom)(e->xclient.data.l[0]) == wm_take_focus) {
- t = (Time) e->xclient.data.l[1];
- XtCallAcceptFocus(widg, &t);
+ t = (Time) e->xclient.data.l[1];
+ XtCallAcceptFocus(widg, &t);
}
}
#endif
@@ -285,19 +285,19 @@ reshaped(int minx, int miny, int maxx, int maxy)
screen.r = Rect(minx, miny, maxx, maxy);
screen.clipr = screen.r;
if (screen.id) {
- exposed = 1;
- ereshaped(screen.r);
+ exposed = 1;
+ ereshaped(screen.r);
}
if(einitcalled){
- /*
- * Cause a mouse event, so programs like sam
- * will get out of eread and REALLY do the reshape
- */
- eb = ebadd(&esrc[Smouse], 0);
- if (eb == 0)
- berror("eballoc can't malloc");
- memcpy((void*)eb->buf, (void*)&lastmouse, sizeof lastmouse);
- esrc[Smouse].count++;
+ /*
+ * Cause a mouse event, so programs like sam
+ * will get out of eread and REALLY do the reshape
+ */
+ eb = ebadd(&esrc[Smouse], 0);
+ if (eb == 0)
+ berror("eballoc can't malloc");
+ memcpy((void*)eb->buf, (void*)&lastmouse, sizeof lastmouse);
+ esrc[Smouse].count++;
}
}
@@ -308,10 +308,10 @@ gotchar(int c, int kind, int target, int x, int y)
Keystroke k;
if(!einitcalled || Skeyboard == -1)
- return;
+ return;
eb = ebadd(&esrc[Skeyboard], 0);
if (eb == NULL)
- berror("eballoc can't malloc");
+ berror("eballoc can't malloc");
k.c = c;
k.k = kind;
k.t = target;
@@ -327,7 +327,7 @@ gotmouse(Gwinmouse *gm)
Mouse m;
if(!einitcalled || Smouse == -1)
- return;
+ return;
m.buttons = gm->buttons;
m.xy.x = gm->xy.x;
m.xy.y = gm->xy.y;
@@ -335,7 +335,7 @@ gotmouse(Gwinmouse *gm)
lastmouse = m;
eb = ebadd(&esrc[Smouse], 0);
if (eb == 0)
- berror("eballoc can't malloc");
+ berror("eballoc can't malloc");
memcpy((void*)eb->buf, (void*)&m, sizeof m);
esrc[Smouse].count++;
}
@@ -348,27 +348,27 @@ gotinput(XtPointer cldata, int *pfd, XtInputId *id)
int n;
if(!einitcalled)
- return;
+ return;
es = (Esrc *)cldata;
if (es->count >= MAXINPUT)
- return;
+ return;
lasttail = es->tail;
eb = ebadd(es, 0);
if (eb == 0)
- return;
+ return;
if(es->size){
- n = read(*pfd, (char *)eb->buf, es->size);
- if (n < 0)
- n = 0;
- if(n < es->size) {
- newe = realloc(eb, sizeof(Ebuf)+n);
- newe->n = n;
- if (es->head == eb)
- es->head = newe;
- else
- lasttail->next = newe;
- es->tail = newe;
- }
+ n = read(*pfd, (char *)eb->buf, es->size);
+ if (n < 0)
+ n = 0;
+ if(n < es->size) {
+ newe = realloc(eb, sizeof(Ebuf)+n);
+ newe->n = n;
+ if (es->head == eb)
+ es->head = newe;
+ else
+ lasttail->next = newe;
+ es->tail = newe;
+ }
}
es->count++;
}
@@ -377,7 +377,7 @@ static void
gottimeout(XtPointer cldata, XtIntervalId *id)
{
if(!einitcalled || Stimer == -1)
- return;
+ return;
/*
* Don't queue up timeouts, because there's
* too big a danger that they might pile up
@@ -394,8 +394,8 @@ ilog2(int n)
int i, v;
for(i=0, v=1; i < 6; i++, v<<=1)
- if(n <= v)
- break;
+ if(n <= v)
+ break;
return i;
}
@@ -408,7 +408,7 @@ pixtocolor(Pixel p, XColor *pc)
int n;
n = 0;
- XtSetArg(args[n], XtNcolormap, &cmap); n++;
+ XtSetArg(args[n], XtNcolormap, &cmap); n++;
XtGetValues(_toplevel, args, n);
pc->pixel = p;
XQueryColor(_dpy, cmap, pc);
@@ -420,7 +420,7 @@ pixtocolor(Pixel p, XColor *pc)
xvt.size = sizeof(XColor);
xvt.addr = (XtPointer)pc;
if(!XtConvertAndStore(_toplevel, XtRPixel, &xvf, XtRColor, &xvt))
- pc->pixel = p; /* maybe that's enough */
+ pc->pixel = p; /* maybe that's enough */
#endif
}
@@ -435,30 +435,30 @@ rgbpix(Bitmap *b, RGB col)
unsigned long d, max, pixel;
if (!_cmap_installed) {
- n = 0;
- XtSetArg(args[n], XtNcolormap, &cmap); n++;
- XtGetValues(_toplevel, args, n);
- c.red = col.red>>16;
- c.green = col.green>>16;
- c.blue = col.blue>>16;
- c.flags = DoRed|DoGreen|DoBlue;
- if(XAllocColor(_dpy, cmap, &c))
- return (unsigned long)(c.pixel);
+ n = 0;
+ XtSetArg(args[n], XtNcolormap, &cmap); n++;
+ XtGetValues(_toplevel, args, n);
+ c.red = col.red>>16;
+ c.green = col.green>>16;
+ c.blue = col.blue>>16;
+ c.flags = DoRed|DoGreen|DoBlue;
+ if(XAllocColor(_dpy, cmap, &c))
+ return (unsigned long)(c.pixel);
}
depth = _ld2d[screen.ldepth];
rdcolmap(&screen, map);
max = -1;
for (n = 0, m = map; n < (1 << depth); n++, m++)
{
- dr = m->red - col.red;
- dg = m->green - col.green;
- db = m->blue - col.blue;
- d = dr*dr+dg*dg+db*db;
- if (d < max || max == -1)
- {
- max = d;
- pixel = n;
- }
+ dr = m->red - col.red;
+ dg = m->green - col.green;
+ db = m->blue - col.blue;
+ d = dr*dr+dg*dg+db*db;
+ if (d < max || max == -1)
+ {
+ max = d;
+ pixel = n;
+ }
}
return pixel;
}
@@ -472,32 +472,32 @@ rdcolmap(Bitmap *b, RGB *map)
Arg args[2];
if (_cmap_installed) {
- cmap = _libg_cmap;
+ cmap = _libg_cmap;
} else {
- i = 0;
- XtSetArg(args[i], XtNcolormap, &cmap); i++;
- XtGetValues(_toplevel, args, i);
+ i = 0;
+ XtSetArg(args[i], XtNcolormap, &cmap); i++;
+ XtGetValues(_toplevel, args, i);
}
depth = _ld2d[screen.ldepth];
n = 1 << depth;
if (depth == 1) {
- map[0].red = map[0].green = map[0].blue = ~0;
- map[1].red = map[1].green = map[1].blue = 0;
+ map[0].red = map[0].green = map[0].blue = ~0;
+ map[1].red = map[1].green = map[1].blue = 0;
}
else {
- if (n > 256) {
- berror("rdcolmap bitmap too deep");
- return;
- }
- for (i = 0; i < n; i++)
- cols[i].pixel = i;
- XQueryColors(_dpy, cmap, cols, n);
- for (i = 0; i < n; i++) {
- map[i].red = (cols[i].red << 16) | cols[i].red;
- map[i].green = (cols[i].green << 16) | cols[i].green;
- map[i].blue = (cols[i].blue << 16) | cols[i].blue;
- }
+ if (n > 256) {
+ berror("rdcolmap bitmap too deep");
+ return;
+ }
+ for (i = 0; i < n; i++)
+ cols[i].pixel = i;
+ XQueryColors(_dpy, cmap, cols, n);
+ for (i = 0; i < n; i++) {
+ map[i].red = (cols[i].red << 16) | cols[i].red;
+ map[i].green = (cols[i].green << 16) | cols[i].green;
+ map[i].blue = (cols[i].blue << 16) | cols[i].blue;
+ }
}
}
@@ -515,29 +515,29 @@ wrcolmap(Bitmap *b, RGB *map)
depth = _ld2d[screen.ldepth];
n = 1 << depth;
if (n > 256) {
- berror("wrcolmap bitmap too deep");
- return;
+ berror("wrcolmap bitmap too deep");
+ return;
} else if (depth > 1) {
- for (i = 0; i < n; i++) {
- cols[i].red = map[i].red >> 16;
- cols[i].green = map[i].green >> 16;
- cols[i].blue = map[i].blue >> 16;
- cols[i].pixel = i;
- cols[i].flags = DoRed|DoGreen|DoBlue;
- }
- if (!XMatchVisualInfo(_dpy, XScreenNumberOfScreen(scr),
- depth, PseudoColor, &vi)) {
- berror("wrcolmap can't get visual");
- return;
- }
- w = XtWindow(_toplevel);
- _libg_cmap = XCreateColormap(_dpy, w, vi.visual, AllocAll);
- XStoreColors(_dpy, _libg_cmap, cols, n);
-
- i = 0;
- XtSetArg(args[i], XtNcolormap, _libg_cmap); i++;
- XtSetValues(_toplevel, args, i);
- _cmap_installed = 1;
+ for (i = 0; i < n; i++) {
+ cols[i].red = map[i].red >> 16;
+ cols[i].green = map[i].green >> 16;
+ cols[i].blue = map[i].blue >> 16;
+ cols[i].pixel = i;
+ cols[i].flags = DoRed|DoGreen|DoBlue;
+ }
+ if (!XMatchVisualInfo(_dpy, XScreenNumberOfScreen(scr),
+ depth, PseudoColor, &vi)) {
+ berror("wrcolmap can't get visual");
+ return;
+ }
+ w = XtWindow(_toplevel);
+ _libg_cmap = XCreateColormap(_dpy, w, vi.visual, AllocAll);
+ XStoreColors(_dpy, _libg_cmap, cols, n);
+
+ i = 0;
+ XtSetArg(args[i], XtNcolormap, _libg_cmap); i++;
+ XtSetValues(_toplevel, args, i);
+ _cmap_installed = 1;
}
}
@@ -561,19 +561,19 @@ einit(unsigned long keys)
*/
nsrc = 0;
if(keys&Emouse){
- Smouse = 0;
- esrc[Smouse].inuse = 1;
- esrc[Smouse].size = sizeof(Mouse);
- esrc[Smouse].count = 0;
- nsrc = Smouse+1;
+ Smouse = 0;
+ esrc[Smouse].inuse = 1;
+ esrc[Smouse].size = sizeof(Mouse);
+ esrc[Smouse].count = 0;
+ nsrc = Smouse+1;
}
if(keys&Ekeyboard){
- Skeyboard = 1;
- esrc[Skeyboard].inuse = 1;
- esrc[Skeyboard].size = sizeof(Keystroke);
- esrc[Skeyboard].count = 0;
- if(Skeyboard >= nsrc)
- nsrc = Skeyboard+1;
+ Skeyboard = 1;
+ esrc[Skeyboard].inuse = 1;
+ esrc[Skeyboard].size = sizeof(Keystroke);
+ esrc[Skeyboard].count = 0;
+ if(Skeyboard >= nsrc)
+ nsrc = Skeyboard+1;
}
einitcalled = 1;
}
@@ -584,20 +584,20 @@ estart(unsigned long key, int fd, int n)
int i;
if(fd < 0)
- berror("bad fd to estart");
+ berror("bad fd to estart");
if(n <= 0 || n > EMAXMSG)
- n = EMAXMSG;
+ n = EMAXMSG;
for(i=0; i<MAXSRC; i++)
- if((key & ~(1<<i)) == 0 && !esrc[i].inuse){
- if(nsrc <= i)
- nsrc = i+1;
- esrc[i].inuse = 1;
- esrc[i].size = n;
- esrc[i].count = 0;
- XtAppAddInput(app, fd, (XtPointer)XtInputReadMask,
- gotinput, (XtPointer) &esrc[i]);
- return 1<<i;
- }
+ if((key & ~(1<<i)) == 0 && !esrc[i].inuse){
+ if(nsrc <= i)
+ nsrc = i+1;
+ esrc[i].inuse = 1;
+ esrc[i].size = n;
+ esrc[i].count = 0;
+ XtAppAddInput(app, fd, (XtPointer)XtInputReadMask,
+ gotinput, (XtPointer) &esrc[i]);
+ return 1<<i;
+ }
return 0;
}
@@ -607,20 +607,20 @@ etimer(unsigned long key, long n)
int i;
if(Stimer != -1)
- berror("timer started twice");
+ berror("timer started twice");
if(n <= 0)
- n = 1000;
+ n = 1000;
for(i=0; i<MAXSRC; i++)
- if((key & ~(1<<i)) == 0 && !esrc[i].inuse){
- if(nsrc <= i)
- nsrc = i+1;
- esrc[i].inuse = 1;
- esrc[i].size = 0;
- esrc[i].count = 0;
- XtAppAddTimeOut(app, n, gottimeout, (XtPointer)n);
- Stimer = i;
- return 1<<i;
- }
+ if((key & ~(1<<i)) == 0 && !esrc[i].inuse){
+ if(nsrc <= i)
+ nsrc = i+1;
+ esrc[i].inuse = 1;
+ esrc[i].size = 0;
+ esrc[i].count = 0;
+ XtAppAddTimeOut(app, n, gottimeout, (XtPointer)n);
+ Stimer = i;
+ return 1<<i;
+ }
return 0;
}
@@ -637,31 +637,31 @@ eread(unsigned long keys, Event *e)
int i;
if(keys == 0)
- return 0;
- /* Give Priority to X events */
+ return 0;
+ /* Give Priority to X events */
if (XtAppPending(app) & XtIMXEvent)
- XtAppProcessEvent(app, XtIMXEvent);
+ XtAppProcessEvent(app, XtIMXEvent);
for(;;){
- for(i=0; i<nsrc; i++)
- if((keys & (1<<i)) && esrc[i].head){
- if(i == Smouse)
- e->mouse = emouse();
- else if(i == Skeyboard)
- e->keystroke = ekbd();
- else if(i == Stimer) {
- esrc[i].head = 0;
- esrc[i].count = 0;
- } else {
- eb = ebread(&esrc[i]);
- e->n = eb->n;
- if(e->n > 0)
- memcpy((void*)e->data, (void*)eb->…
- free(eb);
- }
- return 1<<i;
- }
- waitevent();
+ for(i=0; i<nsrc; i++)
+ if((keys & (1<<i)) && esrc[i].head){
+ if(i == Smouse)
+ e->mouse = emouse();
+ else if(i == Skeyboard)
+ e->keystroke = ekbd();
+ else if(i == Stimer) {
+ esrc[i].head = 0;
+ esrc[i].count = 0;
+ } else {
+ eb = ebread(&esrc[i]);
+ e->n = eb->n;
+ if(e->n > 0)
+ memcpy((void*)e->data, (void*)eb->buf, e->n);
+ free(eb);
+ }
+ return 1<<i;
+ }
+ waitevent();
}
}
@@ -672,18 +672,18 @@ eflush(unsigned long keys)
Ebuf *eb, *enext;
if(keys == 0)
- return;
+ return;
for(i=0; i<nsrc; i++)
- if((keys & (1<<i))){
- for (eb = esrc[i].head; eb; eb = enext) {
- enext = eb->next;
- free(eb);
- }
- esrc[i].count = 0;
- esrc[i].head = 0;
- esrc[i].tail = 0;
- }
+ if((keys & (1<<i))){
+ for (eb = esrc[i].head; eb; eb = enext) {
+ enext = eb->next;
+ free(eb);
+ }
+ esrc[i].count = 0;
+ esrc[i].head = 0;
+ esrc[i].tail = 0;
+ }
}
Mouse
@@ -693,7 +693,7 @@ emouse(void)
Ebuf *eb;
if(!esrc[Smouse].inuse)
- berror("mouse events not selected");
+ berror("mouse events not selected");
eb = ebread(&esrc[Smouse]);
memcpy((void*)&m, (void*)eb->buf, sizeof(Mouse));
free(eb);
@@ -708,7 +708,7 @@ ekbd(void)
Keystroke k;
if(!esrc[Skeyboard].inuse)
- berror("keyboard events not selected");
+ berror("keyboard events not selected");
eb = ebread(&esrc[Skeyboard]);
memcpy(&k, eb->buf, sizeof(Keystroke));
free(eb);
@@ -722,10 +722,10 @@ pushkbd(int c)
Keystroke k;
if(!einitcalled || Skeyboard == -1)
- return;
+ return;
eb = ebadd(&esrc[Skeyboard], 1);
if (eb == 0)
- berror("eballoc can't malloc");
+ berror("eballoc can't malloc");
k.c = c;
k.k = Kcomposed;
memcpy(eb->buf, &k, sizeof(Keystroke));
@@ -738,14 +738,14 @@ ecanread(unsigned long keys)
int i;
for(;;){
- for(i=0; i<nsrc; i++){
- if((keys & (1<<i)) && esrc[i].head)
- return 1<<i;
- }
- if(XtAppPending(app))
- waitevent();
- else
- return 0;
+ for(i=0; i<nsrc; i++){
+ if((keys & (1<<i)) && esrc[i].head)
+ return 1<<i;
+ }
+ if(XtAppPending(app))
+ waitevent();
+ else
+ return 0;
}
}
@@ -753,7 +753,7 @@ int
ecanmouse(void)
{
if(Smouse == -1)
- berror("mouse events not selected");
+ berror("mouse events not selected");
return ecanread(Emouse);
}
@@ -761,7 +761,7 @@ int
ecankbd(void)
{
if(Skeyboard == -1)
- berror("keyboard events not selected");
+ berror("keyboard events not selected");
return ecanread(Ekeyboard);
}
@@ -771,24 +771,24 @@ ebread(Esrc *s)
Ebuf *eb;
while(s->head == 0)
- waitevent();
+ waitevent();
eb = s->head;
#ifdef COMPRESSMOUSE
if(s == &esrc[Smouse]) {
- while(eb->next) {
- s->head = eb->next;
- s->count--;
- free(eb);
- eb = s->head;
- }
+ while(eb->next) {
+ s->head = eb->next;
+ s->count--;
+ free(eb);
+ eb = s->head;
+ }
}
#endif
s->head = s->head->next;
if(s->head == 0) {
- s->tail = 0;
- s->count = 0;
+ s->tail = 0;
+ s->count = 0;
} else
- s->count--;
+ s->count--;
return eb;
}
@@ -817,11 +817,11 @@ ebadd(Esrc *s, int prepend)
m = sizeof(Ebuf);
if(s->size > 1)
- m += (s->size-1); /* overestimate, because of alignment */
+ m += (s->size-1); /* overestimate, because of alignment */
eb = (Ebuf *)malloc(m);
if(eb) {
eb->next = 0;
- eb->n = s->size;
+ eb->n = s->size;
if (prepend)
ebprepend(eb, s);
else
@@ -834,10 +834,10 @@ void
berror(char *s)
{
if(onerr)
- (*onerr)(s);
+ (*onerr)(s);
else{
- fprintf(stderr, "libg error: %s:\n", s);
- exit(1);
+ fprintf(stderr, "libg error: %s:\n", s);
+ exit(1);
}
}
@@ -845,7 +845,7 @@ void
bflush(void)
{
while(XtAppPending(app) & XtIMXEvent)
- waitevent();
+ waitevent();
}
static void
@@ -853,26 +853,26 @@ waitevent(void)
{
XFlush(_dpy);
if (XtAppPending(app) & XtIMXEvent)
- XtAppProcessEvent(app, XtIMXEvent);
+ XtAppProcessEvent(app, XtIMXEvent);
else
- XtAppProcessEvent(app, XtIMAll);
+ XtAppProcessEvent(app, XtIMAll);
}
-
+
int
snarfswap(char *s, int n, char **t)
{
*t = GwinSelectionSwap(widg, s);
if (*t)
- return strlen(*t);
+ return strlen(*t);
return 0;
}
int scrpix(int *w, int *h)
{
if (w)
- *w = WidthOfScreen(XtScreen(_toplevel));
+ *w = WidthOfScreen(XtScreen(_toplevel));
if (h)
- *h = HeightOfScreen(XtScreen(_toplevel));
+ *h = HeightOfScreen(XtScreen(_toplevel));
return 1;
}
@@ -883,11 +883,11 @@ printgc(char *msg, GC g)
XGCValues v;
XGetGCValues(_dpy, g, GCFunction|GCForeground|GCBackground|GCFont|
- GCTile|GCFillStyle|GCStipple, &v);
+ GCTile|GCFillStyle|GCStipple, &v);
fprintf(stderr, "%s: gc %x\n", msg, g);
fprintf(stderr, " fg %d bg %d func %d fillstyle %d font %x tile %x stippl…
- v.foreground, v.background, v.function, v.fill_style,
- v.font, v.tile, v.stipple);
+ v.foreground, v.background, v.function, v.fill_style,
+ v.font, v.tile, v.stipple);
}
#endif
diff --git a/libframe/frbox.c b/libframe/frbox.c
@@ -4,153 +4,153 @@
#include <libg.h>
#include <frame.h>
-#define SLOP 25
+#define SLOP 25
void
-_fraddbox(Frame *f, int bn, int n) /* add n boxes after bn, shift the r…
- * box[bn+n]==box[bn] */
+_fraddbox(Frame *f, int bn, int n) /* add n boxes after bn, shift the rest up,
+ * box[bn+n]==box[bn] */
{
- int i;
-
- if(bn > f->nbox)
- berror("_fraddbox");
- if(f->nbox+n > f->nalloc)
- _frgrowbox(f, n+SLOP);
- for(i=f->nbox; --i>=bn; )
- f->box[i+n] = f->box[i];
- f->nbox+=n;
+ int i;
+
+ if(bn > f->nbox)
+ berror("_fraddbox");
+ if(f->nbox+n > f->nalloc)
+ _frgrowbox(f, n+SLOP);
+ for(i=f->nbox; --i>=bn; )
+ f->box[i+n] = f->box[i];
+ f->nbox+=n;
}
void
-_frclosebox(Frame *f, int n0, int n1) /* inclusive */
+_frclosebox(Frame *f, int n0, int n1) /* inclusive */
{
- int i;
-
- if(n0>=f->nbox || n1>=f->nbox || n1<n0)
- berror("_frclosebox");
- n1++;
- for(i=n1; i<f->nbox; i++)
- f->box[i-(n1-n0)] = f->box[i];
- f->nbox -= n1-n0;
+ int i;
+
+ if(n0>=f->nbox || n1>=f->nbox || n1<n0)
+ berror("_frclosebox");
+ n1++;
+ for(i=n1; i<f->nbox; i++)
+ f->box[i-(n1-n0)] = f->box[i];
+ f->nbox -= n1-n0;
}
void
-_frdelbox(Frame *f, int n0, int n1) /* inclusive */
+_frdelbox(Frame *f, int n0, int n1) /* inclusive */
{
- if(n0>=f->nbox || n1>=f->nbox || n1<n0)
- berror("_frdelbox");
- _frfreebox(f, n0, n1);
- _frclosebox(f, n0, n1);
+ if(n0>=f->nbox || n1>=f->nbox || n1<n0)
+ berror("_frdelbox");
+ _frfreebox(f, n0, n1);
+ _frclosebox(f, n0, n1);
}
void
-_frfreebox(Frame *f, int n0, int n1) /* inclusive */
+_frfreebox(Frame *f, int n0, int n1) /* inclusive */
{
- int i;
-
- if(n1<n0)
- return;
- if(n0>=f->nbox || n1>=f->nbox)
- berror("_frfreebox");
- n1++;
- for(i=n0; i<n1; i++)
- if(f->box[i].nrune >= 0)
- free(f->box[i].a.ptr);
+ int i;
+
+ if(n1<n0)
+ return;
+ if(n0>=f->nbox || n1>=f->nbox)
+ berror("_frfreebox");
+ n1++;
+ for(i=n0; i<n1; i++)
+ if(f->box[i].nrune >= 0)
+ free(f->box[i].a.ptr);
}
void
_frgrowbox(Frame *f, int delta)
{
- f->nalloc += delta;
- f->box = realloc(f->box, f->nalloc*sizeof(Frbox));
- if(f->box == 0)
- berror("_frgrowbox");
+ f->nalloc += delta;
+ f->box = realloc(f->box, f->nalloc*sizeof(Frbox));
+ if(f->box == 0)
+ berror("_frgrowbox");
}
static
void
dupbox(Frame *f, int bn)
{
- uchar *p;
-
- if(f->box[bn].nrune < 0)
- berror("dupbox");
- _fraddbox(f, bn, 1);
- if(f->box[bn].nrune >= 0){
- p = _frallocstr(NBYTE(&f->box[bn])+1);
- strcpy((char*)p, (char*)f->box[bn].a.ptr);
- f->box[bn+1].a.ptr = p;
- }
+ uchar *p;
+
+ if(f->box[bn].nrune < 0)
+ berror("dupbox");
+ _fraddbox(f, bn, 1);
+ if(f->box[bn].nrune >= 0){
+ p = _frallocstr(NBYTE(&f->box[bn])+1);
+ strcpy((char*)p, (char*)f->box[bn].a.ptr);
+ f->box[bn+1].a.ptr = p;
+ }
}
static
uchar*
runeindex(uchar *p, int n)
{
- int i, w;
- Rune rune;
-
- for(i=0; i<n; i++,p+=w)
- if(*p < Runeself)
- w = 1;
- else{
- w = chartorune(&rune, (char*)p);
- USED(rune);
- }
- return p;
+ int i, w;
+ Rune rune;
+
+ for(i=0; i<n; i++,p+=w)
+ if(*p < Runeself)
+ w = 1;
+ else{
+ w = chartorune(&rune, (char*)p);
+ USED(rune);
+ }
+ return p;
}
static
void
-truncatebox(Frame *f, Frbox *b, int n) /* drop last n chars; no allocat…
+truncatebox(Frame *f, Frbox *b, int n) /* drop last n chars; no allocation do…
{
- if(b->nrune<0 || b->nrune<n)
- berror("truncatebox");
- b->nrune -= n;
- runeindex(b->a.ptr, b->nrune)[0] = 0;
- b->wid = strwidth(f->font, (char *)b->a.ptr);
+ if(b->nrune<0 || b->nrune<n)
+ berror("truncatebox");
+ b->nrune -= n;
+ runeindex(b->a.ptr, b->nrune)[0] = 0;
+ b->wid = strwidth(f->font, (char *)b->a.ptr);
}
static
void
-chopbox(Frame *f, Frbox *b, int n) /* drop first n chars; no allocation…
+chopbox(Frame *f, Frbox *b, int n) /* drop first n chars; no allocation done …
{
- if(b->nrune<0 || b->nrune<n)
- berror("chopbox");
- strcpy((char*)b->a.ptr, (char*)runeindex(b->a.ptr, n));
- b->nrune -= n;
- b->wid = strwidth(f->font, (char *)b->a.ptr);
+ if(b->nrune<0 || b->nrune<n)
+ berror("chopbox");
+ strcpy((char*)b->a.ptr, (char*)runeindex(b->a.ptr, n));
+ b->nrune -= n;
+ b->wid = strwidth(f->font, (char *)b->a.ptr);
}
void
_frsplitbox(Frame *f, int bn, int n)
{
- dupbox(f, bn);
- truncatebox(f, &f->box[bn], f->box[bn].nrune-n);
- chopbox(f, &f->box[bn+1], n);
+ dupbox(f, bn);
+ truncatebox(f, &f->box[bn], f->box[bn].nrune-n);
+ chopbox(f, &f->box[bn+1], n);
}
void
-_frmergebox(Frame *f, int bn) /* merge bn and bn+1 */
+_frmergebox(Frame *f, int bn) /* merge bn and bn+1 */
{
- Frbox *b;
-
- b = &f->box[bn];
- _frinsure(f, bn, NBYTE(&b[0])+NBYTE(&b[1])+1);
- strcpy((char*)runeindex(b[0].a.ptr, b[0].nrune), (char*)b[1].a.ptr);
- b[0].wid += b[1].wid;
- b[0].nrune += b[1].nrune;
- _frdelbox(f, bn+1, bn+1);
+ Frbox *b;
+
+ b = &f->box[bn];
+ _frinsure(f, bn, NBYTE(&b[0])+NBYTE(&b[1])+1);
+ strcpy((char*)runeindex(b[0].a.ptr, b[0].nrune), (char*)b[1].a.ptr);
+ b[0].wid += b[1].wid;
+ b[0].nrune += b[1].nrune;
+ _frdelbox(f, bn+1, bn+1);
}
int
-_frfindbox(Frame *f, int bn, ulong p, ulong q) /* find box containing q…
+_frfindbox(Frame *f, int bn, ulong p, ulong q) /* find box containing q and p…
{
- Frbox *b;
+ Frbox *b;
- for(b = &f->box[bn]; bn<f->nbox && p+NRUNE(b)<=q; bn++, b++)
- p += NRUNE(b);
- if(p != q)
- _frsplitbox(f, bn++, (int)(q-p));
- return bn;
+ for(b = &f->box[bn]; bn<f->nbox && p+NRUNE(b)<=q; bn++, b++)
+ p += NRUNE(b);
+ if(p != q)
+ _frsplitbox(f, bn++, (int)(q-p));
+ return bn;
}
diff --git a/libframe/frdelete.c b/libframe/frdelete.c
@@ -6,99 +6,99 @@
int
frdelete(Frame *f, ulong p0, ulong p1)
{
- Point pt0, pt1, ppt0;
- Frbox *b;
- int n0, n1, n;
- Rectangle r;
- int nn0;
+ Point pt0, pt1, ppt0;
+ Frbox *b;
+ int n0, n1, n;
+ Rectangle r;
+ int nn0;
- if(p0>=f->nchars || p0==p1 || f->b==0)
- return 0;
- if(p1 > f->nchars)
- p1 = f->nchars;
- n0 = _frfindbox(f, 0, (unsigned long)0, p0);
- n1 = _frfindbox(f, n0, p0, p1);
- pt0 = _frptofcharnb(f, p0, n0);
- pt1 = frptofchar(f, p1);
- if(f->p0!=p0 || f->p1!=p1) /* likely they ARE equal */
- frselectp(f, F&~D); /* can do better some day */
- frselectf(f, pt0, pt1, 0);
- if(n0 == f->nbox)
- berror("off end in frdelete");
- nn0 = n0;
- ppt0 = pt0;
- _frfreebox(f, n0, n1-1);
- f->modified = 1;
+ if(p0>=f->nchars || p0==p1 || f->b==0)
+ return 0;
+ if(p1 > f->nchars)
+ p1 = f->nchars;
+ n0 = _frfindbox(f, 0, (unsigned long)0, p0);
+ n1 = _frfindbox(f, n0, p0, p1);
+ pt0 = _frptofcharnb(f, p0, n0);
+ pt1 = frptofchar(f, p1);
+ if(f->p0!=p0 || f->p1!=p1) /* likely they ARE equal */
+ frselectp(f, F&~D); /* can do better some day */
+ frselectf(f, pt0, pt1, 0);
+ if(n0 == f->nbox)
+ berror("off end in frdelete");
+ nn0 = n0;
+ ppt0 = pt0;
+ _frfreebox(f, n0, n1-1);
+ f->modified = 1;
- /*
- * Invariants:
- * pt0 points to beginning, pt1 points to end
- * n0 is box containing beginning of stuff being deleted
- * n1, b are box containing beginning of stuff to be kept after delet…
- * region between pt0 and pt1 is clear
- */
- b = &f->box[n1];
- while(pt1.x!=pt0.x && n1<f->nbox){
- _frcklinewrap0(f, &pt0, b);
- _frcklinewrap(f, &pt1, b);
- if(b->nrune > 0){
- n = _frcanfit(f, pt0, b);
- if(n==0)
- berror("_frcanfit==0");
- if(n != b->nrune){
- _frsplitbox(f, n1, n);
- b = &f->box[n1];
- }
- r.min = pt1;
- r.max = pt1;
- r.max.x += b->wid;
- r.max.y += f->fheight;
- bitblt2(f->b, pt0, f->b, r, S, 0, f->bg);
- if(pt0.y == pt1.y)
- r.min.x = r.max.x-(pt1.x-pt0.x);
- bitblt2(f->b, r.min, f->b, r, 0, 0, f->bg);
- }
- _fradvance(f, &pt1, b);
- pt0.x += _frnewwid(f, pt0, b);
- f->box[n0++] = f->box[n1++];
- b++;
- }
- if(pt1.y != pt0.y){
- Point pt2;
+ /*
+ * Invariants:
+ * pt0 points to beginning, pt1 points to end
+ * n0 is box containing beginning of stuff being deleted
+ * n1, b are box containing beginning of stuff to be kept after deletion
+ * region between pt0 and pt1 is clear
+ */
+ b = &f->box[n1];
+ while(pt1.x!=pt0.x && n1<f->nbox){
+ _frcklinewrap0(f, &pt0, b);
+ _frcklinewrap(f, &pt1, b);
+ if(b->nrune > 0){
+ n = _frcanfit(f, pt0, b);
+ if(n==0)
+ berror("_frcanfit==0");
+ if(n != b->nrune){
+ _frsplitbox(f, n1, n);
+ b = &f->box[n1];
+ }
+ r.min = pt1;
+ r.max = pt1;
+ r.max.x += b->wid;
+ r.max.y += f->fheight;
+ bitblt2(f->b, pt0, f->b, r, S, 0, f->bg);
+ if(pt0.y == pt1.y)
+ r.min.x = r.max.x-(pt1.x-pt0.x);
+ bitblt2(f->b, r.min, f->b, r, 0, 0, f->bg);
+ }
+ _fradvance(f, &pt1, b);
+ pt0.x += _frnewwid(f, pt0, b);
+ f->box[n0++] = f->box[n1++];
+ b++;
+ }
+ if(pt1.y != pt0.y){
+ Point pt2;
- pt2 = _frptofcharptb(f, 32767, pt1, n1);
- if(pt2.y > f->r.max.y)
- berror("frptofchar in frdelete");
- if(n1 < f->nbox){
- int q0, q1, q2;
+ pt2 = _frptofcharptb(f, 32767, pt1, n1);
+ if(pt2.y > f->r.max.y)
+ berror("frptofchar in frdelete");
+ if(n1 < f->nbox){
+ int q0, q1, q2;
- q0 = pt0.y+f->fheight;
- q1 = pt1.y+f->fheight;
- q2 = pt2.y+f->fheight;
- bitblt2(f->b, pt0, f->b, Rect(pt1.x, pt1.y, f->r.max.x…
- bitblt2(f->b, Pt(f->r.min.x, q0), f->b, Rect(f->r.min.…
- frselectf(f, Pt(pt2.x, pt2.y-(pt1.y-pt0.y)), pt2, 0);
- }else
- frselectf(f, pt0, pt2, 0);
- }
- _frclosebox(f, n0, n1-1);
- if(nn0>0 && f->box[nn0-1].nrune>=0 && ppt0.x-f->box[nn0-1].wid>=(int)f…
- --nn0;
- ppt0.x -= f->box[nn0].wid;
- }
- _frclean(f, ppt0, nn0, n0<f->nbox-1? n0+1 : n0);
- if(f->p1 > p1)
- f->p1 -= p1-p0;
- else if(f->p1 > p0)
- f->p1 = p0;
- if(f->p0 > p1)
- f->p0 -= p1-p0;
- else if(f->p0 > p0)
- f->p0 = p0;
- frselectp(f, F&~D);
- f->nchars -= p1-p0;
- pt0 = frptofchar(f, f->nchars);
- n = f->nlines;
- f->nlines = (pt0.y-f->r.min.y)/f->fheight+(pt0.x>f->left);
- return n - f->nlines;
+ q0 = pt0.y+f->fheight;
+ q1 = pt1.y+f->fheight;
+ q2 = pt2.y+f->fheight;
+ bitblt2(f->b, pt0, f->b, Rect(pt1.x, pt1.y, f->r.max.x, q1), S, 0,…
+ bitblt2(f->b, Pt(f->r.min.x, q0), f->b, Rect(f->r.min.x, q1, f->r.…
+ frselectf(f, Pt(pt2.x, pt2.y-(pt1.y-pt0.y)), pt2, 0);
+ }else
+ frselectf(f, pt0, pt2, 0);
+ }
+ _frclosebox(f, n0, n1-1);
+ if(nn0>0 && f->box[nn0-1].nrune>=0 && ppt0.x-f->box[nn0-1].wid>=(int)f->le…
+ --nn0;
+ ppt0.x -= f->box[nn0].wid;
+ }
+ _frclean(f, ppt0, nn0, n0<f->nbox-1? n0+1 : n0);
+ if(f->p1 > p1)
+ f->p1 -= p1-p0;
+ else if(f->p1 > p0)
+ f->p1 = p0;
+ if(f->p0 > p1)
+ f->p0 -= p1-p0;
+ else if(f->p0 > p0)
+ f->p0 = p0;
+ frselectp(f, F&~D);
+ f->nchars -= p1-p0;
+ pt0 = frptofchar(f, f->nchars);
+ n = f->nlines;
+ f->nlines = (pt0.y-f->r.min.y)/f->fheight+(pt0.x>f->left);
+ return n - f->nlines;
}
diff --git a/libframe/frdraw.c b/libframe/frdraw.c
@@ -7,53 +7,53 @@
void
_frredraw(Frame *f, Point pt)
{
- Frbox *b;
- int nb;
- for(nb=0,b=f->box; nb<f->nbox; nb++, b++){
- _frcklinewrap(f, &pt, b);
- if(b->nrune >= 0)
- string(f->b, pt, f->font, (char *)b->a.ptr, S^D);
- pt.x += b->wid;
- }
+ Frbox *b;
+ int nb;
+ for(nb=0,b=f->box; nb<f->nbox; nb++, b++){
+ _frcklinewrap(f, &pt, b);
+ if(b->nrune >= 0)
+ string(f->b, pt, f->font, (char *)b->a.ptr, S^D);
+ pt.x += b->wid;
+ }
}
Point
_frdraw(Frame *f, Point pt)
{
- Frbox *b;
- int nb, n;
- for(b=f->box,nb=0; nb<f->nbox; nb++, b++){
- _frcklinewrap0(f, &pt, b);
- if(pt.y == f->r.max.y){
- f->nchars -= _frstrlen(f, nb);
- _frdelbox(f, nb, f->nbox-1);
- break;
- }
- if(b->nrune > 0){
- n = _frcanfit(f, pt, b);
- if(n == 0)
- berror("draw: _frcanfit==0");
- if(n != b->nrune){
- _frsplitbox(f, nb, n);
- b = &f->box[nb];
- }
- pt.x += b->wid;
- }else{
- if(b->a.b.bc == '\n')
- pt.x = f->left, pt.y+=f->fheight;
- else
- pt.x += _frnewwid(f, pt, b);
- }
- }
- return pt;
+ Frbox *b;
+ int nb, n;
+ for(b=f->box,nb=0; nb<f->nbox; nb++, b++){
+ _frcklinewrap0(f, &pt, b);
+ if(pt.y == f->r.max.y){
+ f->nchars -= _frstrlen(f, nb);
+ _frdelbox(f, nb, f->nbox-1);
+ break;
+ }
+ if(b->nrune > 0){
+ n = _frcanfit(f, pt, b);
+ if(n == 0)
+ berror("draw: _frcanfit==0");
+ if(n != b->nrune){
+ _frsplitbox(f, nb, n);
+ b = &f->box[nb];
+ }
+ pt.x += b->wid;
+ }else{
+ if(b->a.b.bc == '\n')
+ pt.x = f->left, pt.y+=f->fheight;
+ else
+ pt.x += _frnewwid(f, pt, b);
+ }
+ }
+ return pt;
}
int
_frstrlen(Frame *f, int nb)
{
- int n;
+ int n;
- for(n=0; nb<f->nbox; nb++)
- n += NRUNE(&f->box[nb]);
- return n;
+ for(n=0; nb<f->nbox; nb++)
+ n += NRUNE(&f->box[nb]);
+ return n;
}
diff --git a/libframe/frinit.c b/libframe/frinit.c
@@ -10,49 +10,49 @@ extern int expandtabs;
void
frinit(Frame *f, Rectangle r, XftFont *ft, Bitmap *b, unsigned long bg)
{
- int tabs = atoi(getenv("TABS") ? getenv("TABS") : "");
+ int tabs = atoi(getenv("TABS") ? getenv("TABS") : "");
if (tabs < 0){
tabs = -tabs;
expandtabs = 1;
}
- if (tabs > 0 && tabs <= 12)
- tabwidth = tabs;
+ if (tabs > 0 && tabs <= 12)
+ tabwidth = tabs;
- f->font = ft;
- /* ft->height is NOT CORRECT; we must use ascent + descent to
- clear the lowest edge of characters. - cks */
- f->fheight = ft->ascent + ft->descent;
- f->maxtab = tabwidth*charwidth(ft, '0');
- f->nbox = 0;
- f->nalloc = 0;
- f->nchars = 0;
- f->nlines = 0;
- f->p0 = 0;
- f->p1 = 0;
- f->box = 0;
- f->lastlinefull = 0;
+ f->font = ft;
+ /* ft->height is NOT CORRECT; we must use ascent + descent to
+ clear the lowest edge of characters. - cks */
+ f->fheight = ft->ascent + ft->descent;
+ f->maxtab = tabwidth*charwidth(ft, '0');
+ f->nbox = 0;
+ f->nalloc = 0;
+ f->nchars = 0;
+ f->nlines = 0;
+ f->p0 = 0;
+ f->p1 = 0;
+ f->box = 0;
+ f->lastlinefull = 0;
f->bg = bg;
- frsetrects(f, r, b);
+ frsetrects(f, r, b);
}
void
frsetrects(Frame *f, Rectangle r, Bitmap *b)
{
- f->b = b;
- f->entire = r;
- f->r = r;
- f->r.max.y -= (r.max.y-r.min.y)%f->fheight;
- f->left = r.min.x+1;
- f->maxlines = (r.max.y-r.min.y)/f->fheight;
+ f->b = b;
+ f->entire = r;
+ f->r = r;
+ f->r.max.y -= (r.max.y-r.min.y)%f->fheight;
+ f->left = r.min.x+1;
+ f->maxlines = (r.max.y-r.min.y)/f->fheight;
}
void
frclear(Frame *f)
{
- if(f->nbox)
- _frdelbox(f, 0, f->nbox-1);
- if(f->box)
- free(f->box);
- f->box = 0;
+ if(f->nbox)
+ _frdelbox(f, 0, f->nbox-1);
+ if(f->box)
+ free(f->box);
+ f->box = 0;
}
diff --git a/libframe/frinsert.c b/libframe/frinsert.c
@@ -4,245 +4,245 @@
#include <libg.h>
#include <frame.h>
-#define DELTA 25
-#define TMPSIZE 256
-static Frame frame;
+#define DELTA 25
+#define TMPSIZE 256
+static Frame frame;
static
Point
bxscan(Frame *f, Rune *sp, Rune *ep, Point *ppt)
{
- int w, c, nb, delta, nl, nr, rw;
- Frbox *b;
- char *s, tmp[TMPSIZE+3]; /* +3 for rune overflow */
- uchar *p;
+ int w, c, nb, delta, nl, nr, rw;
+ Frbox *b;
+ char *s, tmp[TMPSIZE+3]; /* +3 for rune overflow */
+ uchar *p;
- frame.r = f->r;
- frame.b = f->b;
- frame.font = f->font;
- frame.fheight = f->font->ascent + f->font->descent;
- frame.maxtab = f->maxtab;
- frame.left = f->left;
- frame.nbox = 0;
- frame.nchars = 0;
- delta = DELTA;
- nl = 0;
- for(nb=0; sp<ep && nl<=f->maxlines; nb++,frame.nbox++){
- if(nb == frame.nalloc){
- _frgrowbox(&frame, delta);
- if(delta < 10000)
- delta *= 2;
- }
- b = &frame.box[nb];
- c = *sp;
- if(c=='\t' || c=='\n'){
- b->a.b.bc = c;
- b->wid = 5000;
- b->a.b.minwid = (c=='\n')? 0 : charwidth(frame.font, '…
- b->nrune = -1;
- if(c=='\n')
- nl++;
- frame.nchars++;
- sp++;
- }else{
- s = tmp;
- nr = 0;
- w = 0;
- while(sp < ep){
- c = *sp;
- if(c=='\t' || c=='\n')
- break;
- rw = runetochar(s, sp);
- if(s+rw >= tmp+TMPSIZE)
- break;
- w += charwidth(frame.font, c);
- sp++;
- s += rw;
- nr++;
- }
- *s++ = 0;
- p = _frallocstr(s-tmp);
- b = &frame.box[nb];
- b->a.ptr = p;
- memmove(p, tmp, s-tmp);
- b->wid = w;
- b->nrune = nr;
- frame.nchars += nr;
- }
- }
- _frcklinewrap0(f, ppt, &frame.box[0]);
- return _frdraw(&frame, *ppt);
+ frame.r = f->r;
+ frame.b = f->b;
+ frame.font = f->font;
+ frame.fheight = f->font->ascent + f->font->descent;
+ frame.maxtab = f->maxtab;
+ frame.left = f->left;
+ frame.nbox = 0;
+ frame.nchars = 0;
+ delta = DELTA;
+ nl = 0;
+ for(nb=0; sp<ep && nl<=f->maxlines; nb++,frame.nbox++){
+ if(nb == frame.nalloc){
+ _frgrowbox(&frame, delta);
+ if(delta < 10000)
+ delta *= 2;
+ }
+ b = &frame.box[nb];
+ c = *sp;
+ if(c=='\t' || c=='\n'){
+ b->a.b.bc = c;
+ b->wid = 5000;
+ b->a.b.minwid = (c=='\n')? 0 : charwidth(frame.font, ' ');
+ b->nrune = -1;
+ if(c=='\n')
+ nl++;
+ frame.nchars++;
+ sp++;
+ }else{
+ s = tmp;
+ nr = 0;
+ w = 0;
+ while(sp < ep){
+ c = *sp;
+ if(c=='\t' || c=='\n')
+ break;
+ rw = runetochar(s, sp);
+ if(s+rw >= tmp+TMPSIZE)
+ break;
+ w += charwidth(frame.font, c);
+ sp++;
+ s += rw;
+ nr++;
+ }
+ *s++ = 0;
+ p = _frallocstr(s-tmp);
+ b = &frame.box[nb];
+ b->a.ptr = p;
+ memmove(p, tmp, s-tmp);
+ b->wid = w;
+ b->nrune = nr;
+ frame.nchars += nr;
+ }
+ }
+ _frcklinewrap0(f, ppt, &frame.box[0]);
+ return _frdraw(&frame, *ppt);
}
static
void
chopframe(Frame *f, Point pt, ulong p, int bn)
{
- Frbox *b;
+ Frbox *b;
- for(b = &f->box[bn]; ; b++){
- if(b >= &f->box[f->nbox])
- berror("endofframe");
- _frcklinewrap(f, &pt, b);
- if(pt.y >= f->r.max.y)
- break;
- p += NRUNE(b);
- _fradvance(f, &pt, b);
- }
- f->nchars = p;
- f->nlines = f->maxlines;
- if(b<&f->box[f->nbox]) /* BUG */
- _frdelbox(f, (int)(b-f->box), f->nbox-1);
+ for(b = &f->box[bn]; ; b++){
+ if(b >= &f->box[f->nbox])
+ berror("endofframe");
+ _frcklinewrap(f, &pt, b);
+ if(pt.y >= f->r.max.y)
+ break;
+ p += NRUNE(b);
+ _fradvance(f, &pt, b);
+ }
+ f->nchars = p;
+ f->nlines = f->maxlines;
+ if(b<&f->box[f->nbox]) /* BUG */
+ _frdelbox(f, (int)(b-f->box), f->nbox-1);
}
void
frinsert(Frame *f, Rune *sp, Rune *ep, ulong p0)
{
- Point pt0, pt1, ppt0, ppt1, pt;
- Frbox *b;
- int n, n0, nn0, y;
- Rectangle r;
- static struct{
- Point pt0, pt1;
- }*pts;
- static int nalloc=0;
- int npts;
+ Point pt0, pt1, ppt0, ppt1, pt;
+ Frbox *b;
+ int n, n0, nn0, y;
+ Rectangle r;
+ static struct{
+ Point pt0, pt1;
+ }*pts;
+ static int nalloc=0;
+ int npts;
- if(p0>f->nchars || sp==ep || f->b==0)
- return;
- n0 = _frfindbox(f, 0, 0, p0);
- nn0 = n0;
- pt0 = _frptofcharnb(f, p0, n0);
- ppt0 = pt0;
- pt1 = bxscan(f, sp, ep, &ppt0);
- ppt1 = pt1;
- if(n0 < f->nbox){
- _frcklinewrap(f, &pt0, b = &f->box[n0]); /* for frselec…
- _frcklinewrap0(f, &ppt1, b);
- }
- f->modified = 1;
- /*
- * ppt0 and ppt1 are start and end of insertion as they will appear wh…
- * insertion is complete. pt0 is current location of insertion position
- * (p0); pt1 is terminal point (without line wrap) of insertion.
- */
- if(p0==f->p0 && p0==f->p1) /* quite likely */
- frselectf(f, pt0, pt0, F&~D);
- else
- frselectp(f, F&~D);
- /*
- * Find point where old and new x's line up
- * Invariants:
- * pt0 is where the next box (b, n0) is now
- * pt1 is where it will be after then insertion
- * If pt1 goes off the rectangle, we can toss everything from there on
- */
- for(b = &f->box[n0],npts=0;
- pt1.x!=pt0.x && pt1.y!=f->r.max.y && n0<f->nbox; b++,n0++,npts++){
- _frcklinewrap(f, &pt0, b);
- _frcklinewrap0(f, &pt1, b);
- if(b->nrune > 0){
- n = _frcanfit(f, pt1, b);
- if(n == 0)
- berror("_frcanfit==0");
- if(n != b->nrune){
- _frsplitbox(f, n0, n);
- b = &f->box[n0];
- }
- }
- if(npts == nalloc){
- pts = realloc(pts, (npts+DELTA)*sizeof(pts[0]));
- nalloc += DELTA;
- b = &f->box[n0];
- }
- pts[npts].pt0 = pt0;
- pts[npts].pt1 = pt1;
- /* has a text box overflowed off the frame? */
- if(pt1.y == f->r.max.y)
- break;
- _fradvance(f, &pt0, b);
- pt1.x += _frnewwid(f, pt1, b);
- }
- if(pt1.y > f->r.max.y)
- berror("frinsert pt1 too far");
- if(pt1.y==f->r.max.y && n0<f->nbox){
- f->nchars -= _frstrlen(f, n0);
- _frdelbox(f, n0, f->nbox-1);
- }
- if(n0 == f->nbox)
- f->nlines = (pt1.y-f->r.min.y)/f->fheight+(pt1.x>f->left);
- else if(pt1.y!=pt0.y){
- int q0, q1;
+ if(p0>f->nchars || sp==ep || f->b==0)
+ return;
+ n0 = _frfindbox(f, 0, 0, p0);
+ nn0 = n0;
+ pt0 = _frptofcharnb(f, p0, n0);
+ ppt0 = pt0;
+ pt1 = bxscan(f, sp, ep, &ppt0);
+ ppt1 = pt1;
+ if(n0 < f->nbox){
+ _frcklinewrap(f, &pt0, b = &f->box[n0]); /* for frselectf() */
+ _frcklinewrap0(f, &ppt1, b);
+ }
+ f->modified = 1;
+ /*
+ * ppt0 and ppt1 are start and end of insertion as they will appear when
+ * insertion is complete. pt0 is current location of insertion position
+ * (p0); pt1 is terminal point (without line wrap) of insertion.
+ */
+ if(p0==f->p0 && p0==f->p1) /* quite likely */
+ frselectf(f, pt0, pt0, F&~D);
+ else
+ frselectp(f, F&~D);
+ /*
+ * Find point where old and new x's line up
+ * Invariants:
+ * pt0 is where the next box (b, n0) is now
+ * pt1 is where it will be after then insertion
+ * If pt1 goes off the rectangle, we can toss everything from there on
+ */
+ for(b = &f->box[n0],npts=0;
+ pt1.x!=pt0.x && pt1.y!=f->r.max.y && n0<f->nbox; b++,n0++,npts++){
+ _frcklinewrap(f, &pt0, b);
+ _frcklinewrap0(f, &pt1, b);
+ if(b->nrune > 0){
+ n = _frcanfit(f, pt1, b);
+ if(n == 0)
+ berror("_frcanfit==0");
+ if(n != b->nrune){
+ _frsplitbox(f, n0, n);
+ b = &f->box[n0];
+ }
+ }
+ if(npts == nalloc){
+ pts = realloc(pts, (npts+DELTA)*sizeof(pts[0]));
+ nalloc += DELTA;
+ b = &f->box[n0];
+ }
+ pts[npts].pt0 = pt0;
+ pts[npts].pt1 = pt1;
+ /* has a text box overflowed off the frame? */
+ if(pt1.y == f->r.max.y)
+ break;
+ _fradvance(f, &pt0, b);
+ pt1.x += _frnewwid(f, pt1, b);
+ }
+ if(pt1.y > f->r.max.y)
+ berror("frinsert pt1 too far");
+ if(pt1.y==f->r.max.y && n0<f->nbox){
+ f->nchars -= _frstrlen(f, n0);
+ _frdelbox(f, n0, f->nbox-1);
+ }
+ if(n0 == f->nbox)
+ f->nlines = (pt1.y-f->r.min.y)/f->fheight+(pt1.x>f->left);
+ else if(pt1.y!=pt0.y){
+ int q0, q1;
- y = f->r.max.y;
- q0 = pt0.y+f->fheight;
- q1 = pt1.y+f->fheight;
- f->nlines += (q1-q0)/f->fheight;
- if(f->nlines > f->maxlines)
- chopframe(f, ppt1, p0, nn0);
- if(pt1.y < y){
- r = f->r;
- r.min.y = q0;
- r.max.y = y-(q1-q0);
- if(q1 < y)
- bitblt2(f->b, Pt(f->r.min.x, q1), f->b, r, S, …
- r.min = pt0;
- r.max.y = q0;
- bitblt2(f->b, pt1, f->b, r, S, 0, f->bg);
- }
- }
- /*
- * Move the old stuff down to make room. The loop will move the stuff
- * between the insertion and the point where the x's lined up.
- * The bitblt2 above moved everything down after the point they lined …
- */
- for((y=pt1.y==f->r.max.y?pt1.y:0),b = &f->box[n0-1]; --npts>=0; --b){
- pt = pts[npts].pt1;
- if(b->nrune > 0){
- r.min = pts[npts].pt0;
- r.max = r.min;
- r.max.x += b->wid;
- r.max.y += f->fheight;
- bitblt2(f->b, pt, f->b, r, S, 0, f->bg);
- if(pt.y < y){ /* clear bit hanging off right */
- r.min = pt;
- r.max = pt;
- r.min.x += b->wid;
- r.max.x = f->r.max.x;
- r.max.y += f->fheight;
- bitblt2(f->b, r.min, f->b, r, 0, 0, f->bg);
- }
- y = pt.y;
- }else{
- r.min = pt;
- r.max = pt;
- r.max.x += b->wid;
- r.max.y += f->fheight;
- if(r.max.x >= f->r.max.x)
- r.max.x = f->r.max.x;
- bitblt2(f->b, r.min, f->b, r, 0, 0, f->bg);
- y = (pt.x == f->left)? pt.y : 0;
- }
- }
- frselectf(f, ppt0, ppt1, 0);
- _frredraw(&frame, ppt0);
- _fraddbox(f, nn0, frame.nbox);
- for(n=0; n<frame.nbox; n++)
- f->box[nn0+n] = frame.box[n];
- if(nn0>0 && f->box[nn0-1].nrune>=0 && ppt0.x-f->box[nn0-1].wid>=(int)f…
- --nn0;
- ppt0.x -= f->box[nn0].wid;
- }
- n0 += frame.nbox;
- _frclean(f, ppt0, nn0, n0<f->nbox-1? n0+1 : n0);
- f->nchars += frame.nchars;
- if(f->p0 >= p0)
- f->p0 += frame.nchars;
- if(f->p0 > f->nchars)
- f->p0 = f->nchars;
- if(f->p1 >= p0)
- f->p1 += frame.nchars;
- if(f->p1 > f->nchars)
- f->p1 = f->nchars;
- frselectp(f, F&~D);
+ y = f->r.max.y;
+ q0 = pt0.y+f->fheight;
+ q1 = pt1.y+f->fheight;
+ f->nlines += (q1-q0)/f->fheight;
+ if(f->nlines > f->maxlines)
+ chopframe(f, ppt1, p0, nn0);
+ if(pt1.y < y){
+ r = f->r;
+ r.min.y = q0;
+ r.max.y = y-(q1-q0);
+ if(q1 < y)
+ bitblt2(f->b, Pt(f->r.min.x, q1), f->b, r, S, 0, f->bg);
+ r.min = pt0;
+ r.max.y = q0;
+ bitblt2(f->b, pt1, f->b, r, S, 0, f->bg);
+ }
+ }
+ /*
+ * Move the old stuff down to make room. The loop will move the stuff
+ * between the insertion and the point where the x's lined up.
+ * The bitblt2 above moved everything down after the point they lined up.
+ */
+ for((y=pt1.y==f->r.max.y?pt1.y:0),b = &f->box[n0-1]; --npts>=0; --b){
+ pt = pts[npts].pt1;
+ if(b->nrune > 0){
+ r.min = pts[npts].pt0;
+ r.max = r.min;
+ r.max.x += b->wid;
+ r.max.y += f->fheight;
+ bitblt2(f->b, pt, f->b, r, S, 0, f->bg);
+ if(pt.y < y){ /* clear bit hanging off right */
+ r.min = pt;
+ r.max = pt;
+ r.min.x += b->wid;
+ r.max.x = f->r.max.x;
+ r.max.y += f->fheight;
+ bitblt2(f->b, r.min, f->b, r, 0, 0, f->bg);
+ }
+ y = pt.y;
+ }else{
+ r.min = pt;
+ r.max = pt;
+ r.max.x += b->wid;
+ r.max.y += f->fheight;
+ if(r.max.x >= f->r.max.x)
+ r.max.x = f->r.max.x;
+ bitblt2(f->b, r.min, f->b, r, 0, 0, f->bg);
+ y = (pt.x == f->left)? pt.y : 0;
+ }
+ }
+ frselectf(f, ppt0, ppt1, 0);
+ _frredraw(&frame, ppt0);
+ _fraddbox(f, nn0, frame.nbox);
+ for(n=0; n<frame.nbox; n++)
+ f->box[nn0+n] = frame.box[n];
+ if(nn0>0 && f->box[nn0-1].nrune>=0 && ppt0.x-f->box[nn0-1].wid>=(int)f->le…
+ --nn0;
+ ppt0.x -= f->box[nn0].wid;
+ }
+ n0 += frame.nbox;
+ _frclean(f, ppt0, nn0, n0<f->nbox-1? n0+1 : n0);
+ f->nchars += frame.nchars;
+ if(f->p0 >= p0)
+ f->p0 += frame.nchars;
+ if(f->p0 > f->nchars)
+ f->p0 = f->nchars;
+ if(f->p1 >= p0)
+ f->p1 += frame.nchars;
+ if(f->p1 > f->nchars)
+ f->p1 = f->nchars;
+ frselectp(f, F&~D);
}
diff --git a/libframe/frptofchar.c b/libframe/frptofchar.c
@@ -7,110 +7,110 @@
Point
_frptofcharptb(Frame *f, ulong p, Point pt, int bn)
{
- uchar *s;
- Frbox *b;
- int w, l;
- Rune r;
+ uchar *s;
+ Frbox *b;
+ int w, l;
+ Rune r;
- for(b = &f->box[bn]; bn<f->nbox; bn++,b++){
- _frcklinewrap(f, &pt, b);
- if(p < (l=NRUNE(b))){
- if(b->nrune > 0)
- for(s=b->a.ptr; p>0; s+=w, p--){
- if((r = *s) < Runeself)
- w = 1;
- else
- w = chartorune(&r, (char*)s);
- pt.x += charwidth(f->font, r);
- if(r==0 || pt.x>f->r.max.x)
- berror("frptofchar");
- }
- break;
- }
- p -= l;
- _fradvance(f, &pt, b);
- }
- return pt;
+ for(b = &f->box[bn]; bn<f->nbox; bn++,b++){
+ _frcklinewrap(f, &pt, b);
+ if(p < (l=NRUNE(b))){
+ if(b->nrune > 0)
+ for(s=b->a.ptr; p>0; s+=w, p--){
+ if((r = *s) < Runeself)
+ w = 1;
+ else
+ w = chartorune(&r, (char*)s);
+ pt.x += charwidth(f->font, r);
+ if(r==0 || pt.x>f->r.max.x)
+ berror("frptofchar");
+ }
+ break;
+ }
+ p -= l;
+ _fradvance(f, &pt, b);
+ }
+ return pt;
}
Point
frptofchar(Frame *f, ulong p)
{
- return _frptofcharptb(f, p, Pt(f->left, f->r.min.y), 0);
+ return _frptofcharptb(f, p, Pt(f->left, f->r.min.y), 0);
}
Point
-_frptofcharnb(Frame *f, ulong p, int nb) /* doesn't do final _fradvance…
+_frptofcharnb(Frame *f, ulong p, int nb) /* doesn't do final _fradvance to …
{
- Point pt;
- int nbox;
+ Point pt;
+ int nbox;
- nbox = f->nbox;
- f->nbox = nb;
- pt = _frptofcharptb(f, p, Pt(f->left, f->r.min.y), 0);
- f->nbox = nbox;
- return pt;
+ nbox = f->nbox;
+ f->nbox = nb;
+ pt = _frptofcharptb(f, p, Pt(f->left, f->r.min.y), 0);
+ f->nbox = nbox;
+ return pt;
}
static
Point
_frgrid(Frame *f, Point p)
{
- p.y -= f->r.min.y;
- p.y -= p.y%f->fheight;
- p.y += f->r.min.y;
- if(p.x > f->r.max.x)
- p.x = f->r.max.x;
- return p;
+ p.y -= f->r.min.y;
+ p.y -= p.y%f->fheight;
+ p.y += f->r.min.y;
+ if(p.x > f->r.max.x)
+ p.x = f->r.max.x;
+ return p;
}
ulong
frcharofpt(Frame *f, Point pt)
{
- Point qt;
- int w, bn;
- uchar *s;
- Frbox *b;
- ulong p;
- Rune r;
+ Point qt;
+ int w, bn;
+ uchar *s;
+ Frbox *b;
+ ulong p;
+ Rune r;
- pt = _frgrid(f, pt);
- qt.x = f->left;
- qt.y = f->r.min.y;
- for(b=f->box,bn=0,p=0; bn<f->nbox && qt.y<pt.y; bn++,b++){
- _frcklinewrap(f, &qt, b);
- if(qt.y >= pt.y)
- break;
- _fradvance(f, &qt, b);
- p += NRUNE(b);
- }
- for(; bn<f->nbox && qt.x<=pt.x; bn++,b++){
- _frcklinewrap(f, &qt, b);
- if(qt.y > pt.y)
- break;
- if(qt.x+b->wid > pt.x){
- if(b->nrune < 0)
- _fradvance(f, &qt, b);
- else{
- s = b->a.ptr;
- for(;;){
- if((r = *s) < Runeself)
- w = 1;
- else
- w = chartorune(&r, (char*)s);
- if(r == 0)
- berror("end of string in frcha…
- s += w;
- qt.x += charwidth(f->font, r);
- if(qt.x > pt.x)
- break;
- p++;
- }
- }
- }else{
- p += NRUNE(b);
- _fradvance(f, &qt, b);
- }
- }
- return p;
+ pt = _frgrid(f, pt);
+ qt.x = f->left;
+ qt.y = f->r.min.y;
+ for(b=f->box,bn=0,p=0; bn<f->nbox && qt.y<pt.y; bn++,b++){
+ _frcklinewrap(f, &qt, b);
+ if(qt.y >= pt.y)
+ break;
+ _fradvance(f, &qt, b);
+ p += NRUNE(b);
+ }
+ for(; bn<f->nbox && qt.x<=pt.x; bn++,b++){
+ _frcklinewrap(f, &qt, b);
+ if(qt.y > pt.y)
+ break;
+ if(qt.x+b->wid > pt.x){
+ if(b->nrune < 0)
+ _fradvance(f, &qt, b);
+ else{
+ s = b->a.ptr;
+ for(;;){
+ if((r = *s) < Runeself)
+ w = 1;
+ else
+ w = chartorune(&r, (char*)s);
+ if(r == 0)
+ berror("end of string in frcharofpt");
+ s += w;
+ qt.x += charwidth(f->font, r);
+ if(qt.x > pt.x)
+ break;
+ p++;
+ }
+ }
+ }else{
+ p += NRUNE(b);
+ _fradvance(f, &qt, b);
+ }
+ }
+ return p;
}
diff --git a/libframe/frselect.c b/libframe/frselect.c
@@ -5,90 +5,90 @@
#include <frame.h>
void
-frselect(Frame *f, Mouse *m) /* when called, button 1 is down */
+frselect(Frame *f, Mouse *m) /* when called, button 1 is down */
{
- ulong p0, p1, q;
- Point mp, pt0, pt1, qt;
+ ulong p0, p1, q;
+ Point mp, pt0, pt1, qt;
- mp = m->xy;
+ mp = m->xy;
Again:
- f->modified = 0;
- frselectp(f, F&~D);
- p0 = p1 = frcharofpt(f, mp);
- pt0 = frptofchar(f, p0);
- pt1 = frptofchar(f, p1);
- frselectf(f, pt0, pt1, F&~D);
- do{
- if(f->modified) /* special hack so 8½ can frselect in …
- goto Again;
- q = frcharofpt(f, m->xy);
- if(p1 != q){
- if(p0 == p1)
- frselectf(f, pt0, pt1, F&~D);
- qt = frptofchar(f, q);
- if(p1 < q)
- frselectf(f, pt1, qt, F&~D);
- else
- frselectf(f, qt, pt1, F&~D);
- p1 = q;
- pt1 = qt;
- if(p0 == p1)
- frselectf(f, pt0, pt1, F&~D);
- }
- f->modified = 0;
- if(p0 < p1)
- f->p0 = p0, f->p1 = p1;
- else
- f->p0 = p1, f->p1 = p0;
- frgetmouse();
- }while((m->buttons & 7) == 1);
+ f->modified = 0;
+ frselectp(f, F&~D);
+ p0 = p1 = frcharofpt(f, mp);
+ pt0 = frptofchar(f, p0);
+ pt1 = frptofchar(f, p1);
+ frselectf(f, pt0, pt1, F&~D);
+ do{
+ if(f->modified) /* special hack so 8½ can frselect in parallel */
+ goto Again;
+ q = frcharofpt(f, m->xy);
+ if(p1 != q){
+ if(p0 == p1)
+ frselectf(f, pt0, pt1, F&~D);
+ qt = frptofchar(f, q);
+ if(p1 < q)
+ frselectf(f, pt1, qt, F&~D);
+ else
+ frselectf(f, qt, pt1, F&~D);
+ p1 = q;
+ pt1 = qt;
+ if(p0 == p1)
+ frselectf(f, pt0, pt1, F&~D);
+ }
+ f->modified = 0;
+ if(p0 < p1)
+ f->p0 = p0, f->p1 = p1;
+ else
+ f->p0 = p1, f->p1 = p0;
+ frgetmouse();
+ }while((m->buttons & 7) == 1);
}
/* it is assumed p0<=p1 and both were generated by frptofchar() */
void
frselectf(Frame *f, Point p0, Point p1, Fcode c)
{
- int n;
- Point q0, q1;
+ int n;
+ Point q0, q1;
- if(p0.x == f->left)
- p0.x = f->r.min.x;
- if(p1.x == f->left)
- p1.x = f->r.min.x;
- q0 = p0;
- q1 = p1;
- q0.y += f->fheight;
- q1.y += f->fheight;
- n = (p1.y-p0.y)/f->fheight;
- if(f->b == 0)
- berror("frselectf b==0");
- if(p0.y == f->r.max.y)
- return;
- if(n == 0){
- if(p0.x == p1.x)
- if(p0.x == f->r.min.x)
- q1.x++;
- else
- p0.x--;
- bitblt2(f->b, p0, f->b, Rpt(p0, q1), c, 0, f->bg);
- }else{
- if(p0.x >= f->r.max.x)
- p0.x = f->r.max.x-1;
- bitblt2(f->b, p0, f->b, Rect(p0.x, p0.y, f->r.max.x, q0.y), c,…
- if(n > 1)
- bitblt2(f->b, Pt(f->r.min.x, q0.y),
- f->b, Rect(f->r.min.x, q0.y, f->r.max.x, p1.y)…
- bitblt2(f->b, Pt(f->r.min.x, p1.y),
- f->b, Rect(f->r.min.x, p1.y, q1.x, q1.y), c, 0…
- }
+ if(p0.x == f->left)
+ p0.x = f->r.min.x;
+ if(p1.x == f->left)
+ p1.x = f->r.min.x;
+ q0 = p0;
+ q1 = p1;
+ q0.y += f->fheight;
+ q1.y += f->fheight;
+ n = (p1.y-p0.y)/f->fheight;
+ if(f->b == 0)
+ berror("frselectf b==0");
+ if(p0.y == f->r.max.y)
+ return;
+ if(n == 0){
+ if(p0.x == p1.x)
+ if(p0.x == f->r.min.x)
+ q1.x++;
+ else
+ p0.x--;
+ bitblt2(f->b, p0, f->b, Rpt(p0, q1), c, 0, f->bg);
+ }else{
+ if(p0.x >= f->r.max.x)
+ p0.x = f->r.max.x-1;
+ bitblt2(f->b, p0, f->b, Rect(p0.x, p0.y, f->r.max.x, q0.y), c, 0, f->b…
+ if(n > 1)
+ bitblt2(f->b, Pt(f->r.min.x, q0.y),
+ f->b, Rect(f->r.min.x, q0.y, f->r.max.x, p1.y), c, 0, f->bg);
+ bitblt2(f->b, Pt(f->r.min.x, p1.y),
+ f->b, Rect(f->r.min.x, p1.y, q1.x, q1.y), c, 0, f->bg);
+ }
}
void
frselectp(Frame *f, Fcode c)
{
- Point pt0, pt1;
+ Point pt0, pt1;
- pt0 = frptofchar(f, f->p0);
- pt1 = (f->p0==f->p1)? pt0 : frptofchar(f, f->p1);
- frselectf(f, pt0, pt1, c);
+ pt0 = frptofchar(f, f->p0);
+ pt1 = (f->p0==f->p1)? pt0 : frptofchar(f, f->p1);
+ frselectf(f, pt0, pt1, c);
}
diff --git a/libframe/frstr.c b/libframe/frstr.c
@@ -8,34 +8,34 @@
* The code here and elsewhere requires that strings not be gcalloc()ed
*/
-#define CHUNK 16
-#define ROUNDUP(n) ((n+CHUNK)&~(CHUNK-1))
+#define CHUNK 16
+#define ROUNDUP(n) ((n+CHUNK)&~(CHUNK-1))
uchar *
_frallocstr(unsigned n)
{
- uchar *p;
+ uchar *p;
- p = malloc(ROUNDUP(n));
- if(p == 0)
- berror("out of memory");
- return p;
+ p = malloc(ROUNDUP(n));
+ if(p == 0)
+ berror("out of memory");
+ return p;
}
void
_frinsure(Frame *f, int bn, unsigned n)
{
- Frbox *b;
- uchar *p;
+ Frbox *b;
+ uchar *p;
- b = &f->box[bn];
- if(b->nrune < 0)
- berror("_frinsure");
- if(ROUNDUP(b->nrune) > n) /* > guarantees room for terminal NUL…
- return;
- p = _frallocstr(n);
- b = &f->box[bn];
- memmove(p, b->a.ptr, NBYTE(b)+1);
- free(b->a.ptr);
- b->a.ptr = p;
+ b = &f->box[bn];
+ if(b->nrune < 0)
+ berror("_frinsure");
+ if(ROUNDUP(b->nrune) > n) /* > guarantees room for terminal NUL */
+ return;
+ p = _frallocstr(n);
+ b = &f->box[bn];
+ memmove(p, b->a.ptr, NBYTE(b)+1);
+ free(b->a.ptr);
+ b->a.ptr = p;
}
diff --git a/libframe/frutil.c b/libframe/frutil.c
@@ -7,101 +7,101 @@
int
_frcanfit(Frame *f, Point pt, Frbox *b)
{
- int left, w, nr;
- uchar *p;
- Rune r;
+ int left, w, nr;
+ uchar *p;
+ Rune r;
- left = f->r.max.x-pt.x;
- if(b->nrune < 0)
- return b->a.b.minwid <= left;
- if(left >= b->wid)
- return b->nrune;
- for(nr=0,p=b->a.ptr; *p; p+=w,nr++){
- r = *p;
- if(r < Runeself)
- w = 1;
- else
- w = chartorune(&r, (char*)p);
- left -= charwidth(f->font, r);
- if(left < 0)
- return nr;
- }
- berror("_frcanfit can't");
- return 0;
+ left = f->r.max.x-pt.x;
+ if(b->nrune < 0)
+ return b->a.b.minwid <= left;
+ if(left >= b->wid)
+ return b->nrune;
+ for(nr=0,p=b->a.ptr; *p; p+=w,nr++){
+ r = *p;
+ if(r < Runeself)
+ w = 1;
+ else
+ w = chartorune(&r, (char*)p);
+ left -= charwidth(f->font, r);
+ if(left < 0)
+ return nr;
+ }
+ berror("_frcanfit can't");
+ return 0;
}
void
_frcklinewrap(Frame *f, Point *p, Frbox *b)
{
- if((b->nrune<0? b->a.b.minwid : b->wid) > f->r.max.x-p->x){
- p->x = f->left;
- p->y += f->fheight;
- }
+ if((b->nrune<0? b->a.b.minwid : b->wid) > f->r.max.x-p->x){
+ p->x = f->left;
+ p->y += f->fheight;
+ }
}
void
_frcklinewrap0(Frame *f, Point *p, Frbox *b)
{
- if(_frcanfit(f, *p, b) == 0){
- p->x = f->left;
- p->y += f->fheight;
- }
+ if(_frcanfit(f, *p, b) == 0){
+ p->x = f->left;
+ p->y += f->fheight;
+ }
}
void
_fradvance(Frame *f, Point *p, Frbox *b)
{
- if(b->nrune<0 && b->a.b.bc=='\n'){
- p->x = f->left;
- p->y += f->fheight;
- }else
- p->x += b->wid;
+ if(b->nrune<0 && b->a.b.bc=='\n'){
+ p->x = f->left;
+ p->y += f->fheight;
+ }else
+ p->x += b->wid;
}
int
_frnewwid(Frame *f, Point pt, Frbox *b)
{
- int c, x;
+ int c, x;
- c = f->r.max.x;
- x = pt.x;
- if(b->nrune >= 0)
- return b->wid;
- if(b->a.b.bc == '\t'){
- if(x+b->a.b.minwid > c)
- x = pt.x = f->left;
- x += f->maxtab;
- x -= (x-f->left)%f->maxtab;
- if(x-pt.x<b->a.b.minwid || x>c)
- x = pt.x+b->a.b.minwid;
- b->wid = x-pt.x;
- }
- return b->wid;
+ c = f->r.max.x;
+ x = pt.x;
+ if(b->nrune >= 0)
+ return b->wid;
+ if(b->a.b.bc == '\t'){
+ if(x+b->a.b.minwid > c)
+ x = pt.x = f->left;
+ x += f->maxtab;
+ x -= (x-f->left)%f->maxtab;
+ if(x-pt.x<b->a.b.minwid || x>c)
+ x = pt.x+b->a.b.minwid;
+ b->wid = x-pt.x;
+ }
+ return b->wid;
}
void
-_frclean(Frame *f, Point pt, int n0, int n1) /* look for mergeable boxe…
+_frclean(Frame *f, Point pt, int n0, int n1) /* look for mergeable boxes */
{
- Frbox *b;
- int nb, c;
+ Frbox *b;
+ int nb, c;
- c = f->r.max.x;
- for(nb=n0; nb<n1-1; nb++){
- b = &f->box[nb];
- _frcklinewrap(f, &pt, b);
- while(b[0].nrune>=0 && nb<n1-1 && b[1].nrune>=0 && pt.x+b[0].w…
- _frmergebox(f, nb);
- n1--;
- b = &f->box[nb];
- }
- _fradvance(f, &pt, &f->box[nb]);
- }
- for(; nb<f->nbox; nb++){
- b = &f->box[nb];
- _frcklinewrap(f, &pt, b);
- _fradvance(f, &pt, &f->box[nb]);
- }
- f->lastlinefull = 0;
- if(pt.y >= f->r.max.y)
- f->lastlinefull = 1;
+ c = f->r.max.x;
+ for(nb=n0; nb<n1-1; nb++){
+ b = &f->box[nb];
+ _frcklinewrap(f, &pt, b);
+ while(b[0].nrune>=0 && nb<n1-1 && b[1].nrune>=0 && pt.x+b[0].wid+b[1].…
+ _frmergebox(f, nb);
+ n1--;
+ b = &f->box[nb];
+ }
+ _fradvance(f, &pt, &f->box[nb]);
+ }
+ for(; nb<f->nbox; nb++){
+ b = &f->box[nb];
+ _frcklinewrap(f, &pt, b);
+ _fradvance(f, &pt, &f->box[nb]);
+ }
+ f->lastlinefull = 0;
+ if(pt.y >= f->r.max.y)
+ f->lastlinefull = 1;
}
diff --git a/libframe/misc.c b/libframe/misc.c
@@ -1,47 +1,47 @@
/* Copyright (c) 1998 Lucent Technologies - All rights reserved. */
-#include <u.h>
-#include <libc.h>
-#include <pwd.h>
-#ifdef NEEDVARARG
-#include <varargs.h>
+#include <u.h>
+#include <libc.h>
+#include <pwd.h>
+#ifdef NEEDVARARG
+#include <varargs.h>
#else
-#include <stdarg.h>
+#include <stdarg.h>
#endif
#include <errno.h>
int errstr(char *buf)
{
- strncpy(buf, strerror(errno), ERRLEN);
- return 1;
+ strncpy(buf, strerror(errno), ERRLEN);
+ return 1;
}
char*
getuser(void)
{
- struct passwd *p;
+ struct passwd *p;
- static char *user = 0;
+ static char *user = 0;
- if (!user) {
- p = getpwuid(getuid());
- if (p && p->pw_name) {
- user = malloc(strlen(p->pw_name)+1);
- if (user)
- strcpy(user, p->pw_name);
- }
- }
- if(!user)
- user = "unknown";
- return user;
+ if (!user) {
+ p = getpwuid(getuid());
+ if (p && p->pw_name) {
+ user = malloc(strlen(p->pw_name)+1);
+ if (user)
+ strcpy(user, p->pw_name);
+ }
+ }
+ if(!user)
+ user = "unknown";
+ return user;
}
#ifdef NEEDSTRERROR
char *
strerror(int n)
{
- extern char *sys_errlist[];
- return sys_errlist[n];
+ extern char *sys_errlist[];
+ return sys_errlist[n];
}
#endif /* NEEDSTRERROR */
@@ -52,30 +52,30 @@ strerror(int n)
void*
memmove(void *a1, const void *a2, size_t n)
{
- char *s1;
- const char *s2;
+ char *s1;
+ const char *s2;
- s1 = a1;
- s2 = a2;
- if(s1 > s2)
- goto back;
- if(s1 + n <= s2)
- return memcpy(a1, a2, n);
- while(n > 0) {
- *s1++ = *s2++;
- n--;
- }
- return a1;
+ s1 = a1;
+ s2 = a2;
+ if(s1 > s2)
+ goto back;
+ if(s1 + n <= s2)
+ return memcpy(a1, a2, n);
+ while(n > 0) {
+ *s1++ = *s2++;
+ n--;
+ }
+ return a1;
back:
- s2 += n;
- if(s2 <= s1)
- return memcpy(a1, a2, n);
- s1 += n;
- while(n > 0) {
- *--s1 = *--s2;
- n--;
- }
- return a1;
+ s2 += n;
+ if(s2 <= s1)
+ return memcpy(a1, a2, n);
+ s1 += n;
+ while(n > 0) {
+ *--s1 = *--s2;
+ n--;
+ }
+ return a1;
}
#endif /* NEEDMEMMOVE */
diff --git a/sam/address.c b/sam/address.c
@@ -2,240 +2,240 @@
#include "sam.h"
#include "parse.h"
-Address addr;
-String lastpat;
-int patset;
-File *menu;
+Address addr;
+String lastpat;
+int patset;
+File *menu;
-File *matchfile(String*);
-Address charaddr(Posn, Address, int);
+File *matchfile(String*);
+Address charaddr(Posn, Address, int);
Address
address(Addr *ap, Address a, int sign)
{
- File *f = a.f;
- Address a1, a2;
-
- do{
- switch(ap->type){
- case 'l':
- case '#':
- a = (*(ap->type=='#'?charaddr:lineaddr))(ap->num, a, s…
- break;
-
- case '.':
- a = f->dot;
- break;
-
- case '$':
- a.r.p1 = a.r.p2 = f->nrunes;
- break;
-
- case '\'':
- a.r = f->mark;
- break;
-
- case '?':
- sign = -sign;
- if(sign == 0)
- sign = -1;
- /* fall through */
- case '/':
- nextmatch(f, ap->are, sign>=0? a.r.p2 : a.r.p1, sign);
- a.r = sel.p[0];
- break;
-
- case '"':
- a = matchfile(ap->are)->dot;
- f = a.f;
- if(f->state == Unread)
- load(f);
- break;
-
- case '*':
- a.r.p1 = 0, a.r.p2 = f->nrunes;
- return a;
-
- case ',':
- case ';':
- if(ap->left)
- a1 = address(ap->left, a, 0);
- else
- a1.f = a.f, a1.r.p1 = a1.r.p2 = 0;
- if(ap->type == ';'){
- f = a1.f;
- f->dot = a = a1;
- }
- if(ap->next)
- a2 = address(ap->next, a, 0);
- else
- a2.f = a.f, a2.r.p1 = a2.r.p2 = f->nrunes;
- if(a1.f != a2.f)
- error(Eorder);
- a.f = a1.f, a.r.p1 = a1.r.p1, a.r.p2 = a2.r.p2;
- if(a.r.p2 < a.r.p1)
- error(Eorder);
- return a;
-
- case '+':
- case '-':
- sign = 1;
- if(ap->type == '-')
- sign = -1;
- if(ap->next==0 || ap->next->type=='+' || ap->next->typ…
- a = lineaddr(1L, a, sign);
- break;
- default:
- panic("address");
- return a;
- }
- }while(ap = ap->next); /* assign = */
- return a;
+ File *f = a.f;
+ Address a1, a2;
+
+ do{
+ switch(ap->type){
+ case 'l':
+ case '#':
+ a = (*(ap->type=='#'?charaddr:lineaddr))(ap->num, a, sign);
+ break;
+
+ case '.':
+ a = f->dot;
+ break;
+
+ case '$':
+ a.r.p1 = a.r.p2 = f->nrunes;
+ break;
+
+ case '\'':
+ a.r = f->mark;
+ break;
+
+ case '?':
+ sign = -sign;
+ if(sign == 0)
+ sign = -1;
+ /* fall through */
+ case '/':
+ nextmatch(f, ap->are, sign>=0? a.r.p2 : a.r.p1, sign);
+ a.r = sel.p[0];
+ break;
+
+ case '"':
+ a = matchfile(ap->are)->dot;
+ f = a.f;
+ if(f->state == Unread)
+ load(f);
+ break;
+
+ case '*':
+ a.r.p1 = 0, a.r.p2 = f->nrunes;
+ return a;
+
+ case ',':
+ case ';':
+ if(ap->left)
+ a1 = address(ap->left, a, 0);
+ else
+ a1.f = a.f, a1.r.p1 = a1.r.p2 = 0;
+ if(ap->type == ';'){
+ f = a1.f;
+ f->dot = a = a1;
+ }
+ if(ap->next)
+ a2 = address(ap->next, a, 0);
+ else
+ a2.f = a.f, a2.r.p1 = a2.r.p2 = f->nrunes;
+ if(a1.f != a2.f)
+ error(Eorder);
+ a.f = a1.f, a.r.p1 = a1.r.p1, a.r.p2 = a2.r.p2;
+ if(a.r.p2 < a.r.p1)
+ error(Eorder);
+ return a;
+
+ case '+':
+ case '-':
+ sign = 1;
+ if(ap->type == '-')
+ sign = -1;
+ if(ap->next==0 || ap->next->type=='+' || ap->next->type=='-')
+ a = lineaddr(1L, a, sign);
+ break;
+ default:
+ panic("address");
+ return a;
+ }
+ }while(ap = ap->next); /* assign = */
+ return a;
}
void
nextmatch(File *f, String *r, Posn p, int sign)
{
- compile(r);
- if(sign >= 0){
- if(!execute(f, p, INFINITY))
- error(Esearch);
- if(sel.p[0].p1==sel.p[0].p2 && sel.p[0].p1==p){
- if(++p>f->nrunes)
- p = 0;
- if(!execute(f, p, INFINITY))
- panic("address");
- }
- }else{
- if(!bexecute(f, p))
- error(Esearch);
- if(sel.p[0].p1==sel.p[0].p2 && sel.p[0].p2==p){
- if(--p<0)
- p = f->nrunes;
- if(!bexecute(f, p))
- panic("address");
- }
- }
+ compile(r);
+ if(sign >= 0){
+ if(!execute(f, p, INFINITY))
+ error(Esearch);
+ if(sel.p[0].p1==sel.p[0].p2 && sel.p[0].p1==p){
+ if(++p>f->nrunes)
+ p = 0;
+ if(!execute(f, p, INFINITY))
+ panic("address");
+ }
+ }else{
+ if(!bexecute(f, p))
+ error(Esearch);
+ if(sel.p[0].p1==sel.p[0].p2 && sel.p[0].p2==p){
+ if(--p<0)
+ p = f->nrunes;
+ if(!bexecute(f, p))
+ panic("address");
+ }
+ }
}
File *
matchfile(String *r)
{
- File *f;
- File *match = 0;
- int i;
-
- for(i = 0; i<file.nused; i++){
- f = file.filepptr[i];
- if(f == cmd)
- continue;
- if(filematch(f, r)){
- if(match)
- error(Emanyfiles);
- match = f;
- }
- }
- if(!match)
- error(Efsearch);
- return match;
+ File *f;
+ File *match = 0;
+ int i;
+
+ for(i = 0; i<file.nused; i++){
+ f = file.filepptr[i];
+ if(f == cmd)
+ continue;
+ if(filematch(f, r)){
+ if(match)
+ error(Emanyfiles);
+ match = f;
+ }
+ }
+ if(!match)
+ error(Efsearch);
+ return match;
}
int
filematch(File *f, String *r)
{
- char *c, buf[STRSIZE+100];
- String *t;
-
- c = Strtoc(&f->name);
- sprint(buf, "%c%c%c %s\n", " '"[f->state==Dirty],
- "-+"[f->rasp!=0], " ."[f==curfile], c);
- free(c);
- t = tmpcstr(buf);
- Strduplstr(&genstr, t);
- freetmpstr(t);
- /* A little dirty... */
- if(menu == 0)
- (menu=Fopen())->state=Clean;
- Bdelete(menu->buf, 0, menu->buf->nrunes);
- Binsert(menu->buf, &genstr, 0);
- menu->nrunes = menu->buf->nrunes;
- compile(r);
- return execute(menu, 0, menu->nrunes);
+ char *c, buf[STRSIZE+100];
+ String *t;
+
+ c = Strtoc(&f->name);
+ sprint(buf, "%c%c%c %s\n", " '"[f->state==Dirty],
+ "-+"[f->rasp!=0], " ."[f==curfile], c);
+ free(c);
+ t = tmpcstr(buf);
+ Strduplstr(&genstr, t);
+ freetmpstr(t);
+ /* A little dirty... */
+ if(menu == 0)
+ (menu=Fopen())->state=Clean;
+ Bdelete(menu->buf, 0, menu->buf->nrunes);
+ Binsert(menu->buf, &genstr, 0);
+ menu->nrunes = menu->buf->nrunes;
+ compile(r);
+ return execute(menu, 0, menu->nrunes);
}
Address
charaddr(Posn l, Address addr, int sign)
{
- if(sign == 0)
- addr.r.p1 = addr.r.p2 = l;
- else if(sign < 0)
- addr.r.p2 = addr.r.p1-=l;
- else if(sign > 0)
- addr.r.p1 = addr.r.p2+=l;
- if(addr.r.p1<0 || addr.r.p2>addr.f->nrunes)
- error(Erange);
- return addr;
+ if(sign == 0)
+ addr.r.p1 = addr.r.p2 = l;
+ else if(sign < 0)
+ addr.r.p2 = addr.r.p1-=l;
+ else if(sign > 0)
+ addr.r.p1 = addr.r.p2+=l;
+ if(addr.r.p1<0 || addr.r.p2>addr.f->nrunes)
+ error(Erange);
+ return addr;
}
Address
lineaddr(Posn l, Address addr, int sign)
{
- int n;
- int c;
- File *f = addr.f;
- Address a;
-
- SET(c);
- a.f = f;
- if(sign >= 0){
- if(l == 0){
- if(sign==0 || addr.r.p2==0){
- a.r.p1 = a.r.p2 = 0;
- return a;
- }
- a.r.p1 = addr.r.p2;
- Fgetcset(f, addr.r.p2-1);
- }else{
- if(sign==0 || addr.r.p2==0){
- Fgetcset(f, (Posn)0);
- n = 1;
- }else{
- Fgetcset(f, addr.r.p2-1);
- n = Fgetc(f)=='\n';
- }
- for(; n<l; ){
- c = Fgetc(f);
- if(c == -1)
- error(Erange);
- else if(c == '\n')
- n++;
- }
- a.r.p1 = f->getcp;
- }
- do; while((c=Fgetc(f))!='\n' && c!=-1);
- a.r.p2 = f->getcp;
- }else{
- Fbgetcset(f, addr.r.p1);
- if(l == 0)
- a.r.p2 = addr.r.p1;
- else{
- for(n = 0; n<l; ){ /* always runs once */
- c = Fbgetc(f);
- if(c == '\n')
- n++;
- else if(c == -1){
- if(++n != l)
- error(Erange);
- }
- }
- a.r.p2 = f->getcp;
- if(c == '\n')
- a.r.p2++; /* lines start after a newlin…
- }
- do; while((c=Fbgetc(f))!='\n' && c!=-1);
- a.r.p1 = f->getcp;
- if(c == '\n')
- a.r.p1++; /* lines start after a newline */
- }
- return a;
+ int n;
+ int c;
+ File *f = addr.f;
+ Address a;
+
+ SET(c);
+ a.f = f;
+ if(sign >= 0){
+ if(l == 0){
+ if(sign==0 || addr.r.p2==0){
+ a.r.p1 = a.r.p2 = 0;
+ return a;
+ }
+ a.r.p1 = addr.r.p2;
+ Fgetcset(f, addr.r.p2-1);
+ }else{
+ if(sign==0 || addr.r.p2==0){
+ Fgetcset(f, (Posn)0);
+ n = 1;
+ }else{
+ Fgetcset(f, addr.r.p2-1);
+ n = Fgetc(f)=='\n';
+ }
+ for(; n<l; ){
+ c = Fgetc(f);
+ if(c == -1)
+ error(Erange);
+ else if(c == '\n')
+ n++;
+ }
+ a.r.p1 = f->getcp;
+ }
+ do; while((c=Fgetc(f))!='\n' && c!=-1);
+ a.r.p2 = f->getcp;
+ }else{
+ Fbgetcset(f, addr.r.p1);
+ if(l == 0)
+ a.r.p2 = addr.r.p1;
+ else{
+ for(n = 0; n<l; ){ /* always runs once */
+ c = Fbgetc(f);
+ if(c == '\n')
+ n++;
+ else if(c == -1){
+ if(++n != l)
+ error(Erange);
+ }
+ }
+ a.r.p2 = f->getcp;
+ if(c == '\n')
+ a.r.p2++; /* lines start after a newline */
+ }
+ do; while((c=Fbgetc(f))!='\n' && c!=-1);
+ a.r.p1 = f->getcp;
+ if(c == '\n')
+ a.r.p1++; /* lines start after a newline */
+ }
+ return a;
}
diff --git a/sam/buffer.c b/sam/buffer.c
@@ -1,172 +1,172 @@
/* Copyright (c) 1998 Lucent Technologies - All rights reserved. */
#include "sam.h"
-int incache(Buffer*, Posn, Posn);
+int incache(Buffer*, Posn, Posn);
Buffer *
Bopen(Discdesc *dd)
{
- Buffer *b;
+ Buffer *b;
- b = emalloc(sizeof(Buffer));
- b->disc = Dopen(dd);
- Strinit(&b->cache);
- return b;
+ b = emalloc(sizeof(Buffer));
+ b->disc = Dopen(dd);
+ Strinit(&b->cache);
+ return b;
}
void
Bterm(Buffer *b)
{
- Dclose(b->disc);
- Strclose(&b->cache);
- free(b);
+ Dclose(b->disc);
+ Strclose(&b->cache);
+ free(b);
}
int
Bread(Buffer *b, Rune *addr, int n, Posn p0)
{
- int m;
+ int m;
- if(b->c2>b->disc->nrunes || b->c1>b->disc->nrunes)
- panic("bread cache");
- if(p0 < 0)
- panic("Bread p0<0");
- if(p0+n > b->nrunes){
- n = b->nrunes-p0;
- if(n < 0)
- panic("Bread<0");
- }
- if(!incache(b, p0, p0+n)){
- Bflush(b);
- if(n>=BLOCKSIZE/2)
- return Dread(b->disc, addr, n, p0);
- else{
- Posn minp;
- if(b->nrunes-p0>BLOCKSIZE/2)
- m = BLOCKSIZE/2;
- else
- m = b->nrunes-p0;
- if(m<n)
- m = n;
- minp = p0-BLOCKSIZE/2;
- if(minp<0)
- minp = 0;
- m += p0-minp;
- Strinsure(&b->cache, m);
- if(Dread(b->disc, b->cache.s, m, minp)!=m)
- panic("Bread");
- b->cache.n = m;
- b->c1 = minp;
- b->c2 = minp+m;
- b->dirty = FALSE;
- }
- }
- memmove(addr, &b->cache.s[p0-b->c1], n*RUNESIZE);
- return n;
+ if(b->c2>b->disc->nrunes || b->c1>b->disc->nrunes)
+ panic("bread cache");
+ if(p0 < 0)
+ panic("Bread p0<0");
+ if(p0+n > b->nrunes){
+ n = b->nrunes-p0;
+ if(n < 0)
+ panic("Bread<0");
+ }
+ if(!incache(b, p0, p0+n)){
+ Bflush(b);
+ if(n>=BLOCKSIZE/2)
+ return Dread(b->disc, addr, n, p0);
+ else{
+ Posn minp;
+ if(b->nrunes-p0>BLOCKSIZE/2)
+ m = BLOCKSIZE/2;
+ else
+ m = b->nrunes-p0;
+ if(m<n)
+ m = n;
+ minp = p0-BLOCKSIZE/2;
+ if(minp<0)
+ minp = 0;
+ m += p0-minp;
+ Strinsure(&b->cache, m);
+ if(Dread(b->disc, b->cache.s, m, minp)!=m)
+ panic("Bread");
+ b->cache.n = m;
+ b->c1 = minp;
+ b->c2 = minp+m;
+ b->dirty = FALSE;
+ }
+ }
+ memmove(addr, &b->cache.s[p0-b->c1], n*RUNESIZE);
+ return n;
}
void
Binsert(Buffer *b, String *s, Posn p0)
{
- if(b->c2>b->disc->nrunes || b->c1>b->disc->nrunes)
- panic("binsert cache");
- if(p0<0)
- panic("Binsert p0<0");
- if(s->n == 0)
- return;
- if(incache(b, p0, p0) && b->cache.n+s->n<=STRSIZE){
- Strinsert(&b->cache, s, p0-b->c1);
- b->dirty = TRUE;
- if(b->cache.n > BLOCKSIZE*2){
- b->nrunes += s->n;
- Bflush(b);
- /* try to leave some cache around p0 */
- if(p0 >= b->c1+BLOCKSIZE){
- /* first BLOCKSIZE can go */
- Strdelete(&b->cache, 0, BLOCKSIZE);
- b->c1 += BLOCKSIZE;
- }else if(p0 <= b->c2-BLOCKSIZE){
- /* last BLOCKSIZE can go */
- b->cache.n -= BLOCKSIZE;
- b->c2 -= BLOCKSIZE;
- }else{
- /* too hard; negate the cache and pick up next…
- Strzero(&b->cache);
- b->c1 = b->c2 = 0;
- }
- return;
- }
- }else{
- Bflush(b);
- if(s->n >= BLOCKSIZE/2){
- b->cache.n = 0;
- b->c1 = b->c2 = 0;
- Dinsert(b->disc, s->s, s->n, p0);
- }else{
- int m;
- Posn minp;
- if(b->nrunes-p0 > BLOCKSIZE/2)
- m = BLOCKSIZE/2;
- else
- m = b->nrunes-p0;
- minp = p0-BLOCKSIZE/2;
- if(minp < 0)
- minp = 0;
- m += p0-minp;
- Strinsure(&b->cache, m);
- if(Dread(b->disc, b->cache.s, m, minp)!=m)
- panic("Bread");
- b->cache.n = m;
- b->c1 = minp;
- b->c2 = minp+m;
- Strinsert(&b->cache, s, p0-b->c1);
- b->dirty = TRUE;
- }
- }
- b->nrunes += s->n;
+ if(b->c2>b->disc->nrunes || b->c1>b->disc->nrunes)
+ panic("binsert cache");
+ if(p0<0)
+ panic("Binsert p0<0");
+ if(s->n == 0)
+ return;
+ if(incache(b, p0, p0) && b->cache.n+s->n<=STRSIZE){
+ Strinsert(&b->cache, s, p0-b->c1);
+ b->dirty = TRUE;
+ if(b->cache.n > BLOCKSIZE*2){
+ b->nrunes += s->n;
+ Bflush(b);
+ /* try to leave some cache around p0 */
+ if(p0 >= b->c1+BLOCKSIZE){
+ /* first BLOCKSIZE can go */
+ Strdelete(&b->cache, 0, BLOCKSIZE);
+ b->c1 += BLOCKSIZE;
+ }else if(p0 <= b->c2-BLOCKSIZE){
+ /* last BLOCKSIZE can go */
+ b->cache.n -= BLOCKSIZE;
+ b->c2 -= BLOCKSIZE;
+ }else{
+ /* too hard; negate the cache and pick up next time */
+ Strzero(&b->cache);
+ b->c1 = b->c2 = 0;
+ }
+ return;
+ }
+ }else{
+ Bflush(b);
+ if(s->n >= BLOCKSIZE/2){
+ b->cache.n = 0;
+ b->c1 = b->c2 = 0;
+ Dinsert(b->disc, s->s, s->n, p0);
+ }else{
+ int m;
+ Posn minp;
+ if(b->nrunes-p0 > BLOCKSIZE/2)
+ m = BLOCKSIZE/2;
+ else
+ m = b->nrunes-p0;
+ minp = p0-BLOCKSIZE/2;
+ if(minp < 0)
+ minp = 0;
+ m += p0-minp;
+ Strinsure(&b->cache, m);
+ if(Dread(b->disc, b->cache.s, m, minp)!=m)
+ panic("Bread");
+ b->cache.n = m;
+ b->c1 = minp;
+ b->c2 = minp+m;
+ Strinsert(&b->cache, s, p0-b->c1);
+ b->dirty = TRUE;
+ }
+ }
+ b->nrunes += s->n;
}
void
Bdelete(Buffer *b, Posn p1, Posn p2)
{
- if(p1<0 || p2<0)
- panic("Bdelete p<0");
- if(b->c2>b->disc->nrunes || b->c1>b->disc->nrunes)
- panic("bdelete cache");
- if(p1 == p2)
- return;
- if(incache(b, p1, p2)){
- Strdelete(&b->cache, p1-b->c1, p2-b->c1);
- b->dirty = TRUE;
- }else{
- Bflush(b);
- Ddelete(b->disc, p1, p2);
- b->cache.n = 0;
- b->c1 = b->c2 = 0;
- }
- b->nrunes -= p2-p1;
+ if(p1<0 || p2<0)
+ panic("Bdelete p<0");
+ if(b->c2>b->disc->nrunes || b->c1>b->disc->nrunes)
+ panic("bdelete cache");
+ if(p1 == p2)
+ return;
+ if(incache(b, p1, p2)){
+ Strdelete(&b->cache, p1-b->c1, p2-b->c1);
+ b->dirty = TRUE;
+ }else{
+ Bflush(b);
+ Ddelete(b->disc, p1, p2);
+ b->cache.n = 0;
+ b->c1 = b->c2 = 0;
+ }
+ b->nrunes -= p2-p1;
}
void
Bflush(Buffer *b)
{
- if(b->dirty){
- Dreplace(b->disc, b->c1, b->c2, b->cache.s, b->cache.n);
- b->c2 = b->c1+b->cache.n;
- b->dirty = FALSE;
- if(b->nrunes != b->disc->nrunes)
- panic("Bflush");
- }
+ if(b->dirty){
+ Dreplace(b->disc, b->c1, b->c2, b->cache.s, b->cache.n);
+ b->c2 = b->c1+b->cache.n;
+ b->dirty = FALSE;
+ if(b->nrunes != b->disc->nrunes)
+ panic("Bflush");
+ }
}
void
Bclean(Buffer *b)
{
- if(b->dirty){
- Bflush(b);
- b->c1 = b->c2 = 0;
- Strzero(&b->cache);
- }
+ if(b->dirty){
+ Bflush(b);
+ b->c1 = b->c2 = 0;
+ Strzero(&b->cache);
+ }
}
/*int hits, misses; /**/
@@ -174,6 +174,6 @@ Bclean(Buffer *b)
int
incache(Buffer *b, Posn p1, Posn p2)
{
- /*if(b->c1<=p1 && p2<=b->c1+b->cache.n)hits++; else misses++;/**/
- return b->c1<=p1 && p2<=b->c1+b->cache.n;
+ /*if(b->c1<=p1 && p2<=b->c1+b->cache.n)hits++; else misses++;/**/
+ return b->c1<=p1 && p2<=b->c1+b->cache.n;
}
diff --git a/sam/cmd.c b/sam/cmd.c
@@ -2,590 +2,590 @@
#include "sam.h"
#include "parse.h"
-static char linex[]="\n";
-static char wordx[]=" \t\n";
+static char linex[]="\n";
+static char wordx[]=" \t\n";
struct cmdtab cmdtab[]={
-/* cmdc text regexp addr defcmd defa…
- '\n', 0, 0, 0, 0, aDot, 0, …
- 'a', 1, 0, 0, 0, aDot, 0, …
- 'b', 0, 0, 0, 0, aNo, 0, …
- 'B', 0, 0, 0, 0, aNo, 0, …
- 'c', 1, 0, 0, 0, aDot, 0, …
- 'd', 0, 0, 0, 0, aDot, 0, …
- 'D', 0, 0, 0, 0, aNo, 0, …
- 'e', 0, 0, 0, 0, aNo, 0, …
- 'f', 0, 0, 0, 0, aNo, 0, …
- 'g', 0, 1, 0, 'p', aDot, 0, …
- 'i', 1, 0, 0, 0, aDot, 0, …
- 'k', 0, 0, 0, 0, aDot, 0, …
- 'm', 0, 0, 1, 0, aDot, 0, …
- 'n', 0, 0, 0, 0, aNo, 0, …
- 'p', 0, 0, 0, 0, aDot, 0, …
- 'q', 0, 0, 0, 0, aNo, 0, …
- 'r', 0, 0, 0, 0, aDot, 0, …
- 's', 0, 1, 0, 0, aDot, 1, …
- 't', 0, 0, 1, 0, aDot, 0, …
- 'u', 0, 0, 0, 0, aNo, 1, …
- 'v', 0, 1, 0, 'p', aDot, 0, …
- 'w', 0, 0, 0, 0, aAll, 0, …
- 'x', 0, 1, 0, 'p', aDot, 0, …
- 'y', 0, 1, 0, 'p', aDot, 0, …
- 'X', 0, 1, 0, 'f', aNo, 0, …
- 'Y', 0, 1, 0, 'f', aNo, 0, …
- '!', 0, 0, 0, 0, aNo, 0, …
- '>', 0, 0, 0, 0, aDot, 0, …
- '<', 0, 0, 0, 0, aDot, 0, …
- '|', 0, 0, 0, 0, aDot, 0, …
- '=', 0, 0, 0, 0, aDot, 0, …
- 'c'|0x100,0, 0, 0, 0, aNo, 0, …
- 0, 0, 0, 0, 0, 0, 0, …
+/* cmdc text regexp addr defcmd defaddr count token fn */
+ '\n', 0, 0, 0, 0, aDot, 0, 0, nl_cmd,
+ 'a', 1, 0, 0, 0, aDot, 0, 0, a_cmd,
+ 'b', 0, 0, 0, 0, aNo, 0, linex, b_cmd,
+ 'B', 0, 0, 0, 0, aNo, 0, linex, b_cmd,
+ 'c', 1, 0, 0, 0, aDot, 0, 0, c_cmd,
+ 'd', 0, 0, 0, 0, aDot, 0, 0, d_cmd,
+ 'D', 0, 0, 0, 0, aNo, 0, linex, D_cmd,
+ 'e', 0, 0, 0, 0, aNo, 0, wordx, e_cmd,
+ 'f', 0, 0, 0, 0, aNo, 0, wordx, f_cmd,
+ 'g', 0, 1, 0, 'p', aDot, 0, 0, g_cmd,
+ 'i', 1, 0, 0, 0, aDot, 0, 0, i_cmd,
+ 'k', 0, 0, 0, 0, aDot, 0, 0, k_cmd,
+ 'm', 0, 0, 1, 0, aDot, 0, 0, m_cmd,
+ 'n', 0, 0, 0, 0, aNo, 0, 0, n_cmd,
+ 'p', 0, 0, 0, 0, aDot, 0, 0, p_cmd,
+ 'q', 0, 0, 0, 0, aNo, 0, 0, q_cmd,
+ 'r', 0, 0, 0, 0, aDot, 0, wordx, e_cmd,
+ 's', 0, 1, 0, 0, aDot, 1, 0, s_cmd,
+ 't', 0, 0, 1, 0, aDot, 0, 0, m_cmd,
+ 'u', 0, 0, 0, 0, aNo, 1, 0, u_cmd,
+ 'v', 0, 1, 0, 'p', aDot, 0, 0, g_cmd,
+ 'w', 0, 0, 0, 0, aAll, 0, wordx, w_cmd,
+ 'x', 0, 1, 0, 'p', aDot, 0, 0, x_cmd,
+ 'y', 0, 1, 0, 'p', aDot, 0, 0, x_cmd,
+ 'X', 0, 1, 0, 'f', aNo, 0, 0, X_cmd,
+ 'Y', 0, 1, 0, 'f', aNo, 0, 0, X_cmd,
+ '!', 0, 0, 0, 0, aNo, 0, linex, plan9_cmd,
+ '>', 0, 0, 0, 0, aDot, 0, linex, plan9_cmd,
+ '<', 0, 0, 0, 0, aDot, 0, linex, plan9_cmd,
+ '|', 0, 0, 0, 0, aDot, 0, linex, plan9_cmd,
+ '=', 0, 0, 0, 0, aDot, 0, linex, eq_cmd,
+ 'c'|0x100,0, 0, 0, 0, aNo, 0, wordx, cd_cmd,
+ 0, 0, 0, 0, 0, 0, 0, 0,
};
-Cmd *parsecmd(int);
-Addr *compoundaddr(void);
-Addr *simpleaddr(void);
-void freecmd(void);
-void okdelim(int);
-
-Rune line[BLOCKSIZE];
-Rune termline[BLOCKSIZE];
-Rune *linep = line;
-Rune *terminp = termline;
-Rune *termoutp = termline;
-List cmdlist;
-List addrlist;
-List relist;
-List stringlist;
-int eof;
+Cmd *parsecmd(int);
+Addr *compoundaddr(void);
+Addr *simpleaddr(void);
+void freecmd(void);
+void okdelim(int);
+
+Rune line[BLOCKSIZE];
+Rune termline[BLOCKSIZE];
+Rune *linep = line;
+Rune *terminp = termline;
+Rune *termoutp = termline;
+List cmdlist;
+List addrlist;
+List relist;
+List stringlist;
+int eof;
void
resetcmd(void)
{
- linep = line;
- *linep = 0;
- terminp = termoutp = termline;
- freecmd();
+ linep = line;
+ *linep = 0;
+ terminp = termoutp = termline;
+ freecmd();
}
int
inputc(void)
{
- int n, nbuf;
- char buf[3];
- Rune r;
+ int n, nbuf;
+ char buf[3];
+ Rune r;
Again:
- nbuf = 0;
- if(downloaded){
- while(termoutp == terminp){
- cmdupdate();
- if(patset)
- tellpat();
- while(termlocked > 0){
- outT0(Hunlock);
- termlocked--;
- }
- if(rcv() == 0)
- return -1;
- }
- r = *termoutp++;
- if(termoutp == terminp)
- terminp = termoutp = termline;
- }else{
- do{
- n = read(0, buf+nbuf, 1);
- if(n <= 0)
- return -1;
- nbuf += n;
- }while(!fullrune(buf, nbuf));
- chartorune(&r, buf);
- }
- if(r == 0){
- warn(Wnulls);
- goto Again;
- }
- return r;
+ nbuf = 0;
+ if(downloaded){
+ while(termoutp == terminp){
+ cmdupdate();
+ if(patset)
+ tellpat();
+ while(termlocked > 0){
+ outT0(Hunlock);
+ termlocked--;
+ }
+ if(rcv() == 0)
+ return -1;
+ }
+ r = *termoutp++;
+ if(termoutp == terminp)
+ terminp = termoutp = termline;
+ }else{
+ do{
+ n = read(0, buf+nbuf, 1);
+ if(n <= 0)
+ return -1;
+ nbuf += n;
+ }while(!fullrune(buf, nbuf));
+ chartorune(&r, buf);
+ }
+ if(r == 0){
+ warn(Wnulls);
+ goto Again;
+ }
+ return r;
}
int
inputline(void)
{
- int i, c;
-
- linep = line;
- i = 0;
- do{
- if((c = inputc())<=0)
- return -1;
- if(i == (sizeof line)/RUNESIZE-1)
- error(Etoolong);
- }while((line[i++]=c) != '\n');
- line[i] = 0;
- return 1;
+ int i, c;
+
+ linep = line;
+ i = 0;
+ do{
+ if((c = inputc())<=0)
+ return -1;
+ if(i == (sizeof line)/RUNESIZE-1)
+ error(Etoolong);
+ }while((line[i++]=c) != '\n');
+ line[i] = 0;
+ return 1;
}
int
getch(void)
{
- if(eof)
- return -1;
- if(*linep==0 && inputline()<0){
- eof = TRUE;
- return -1;
- }
- return *linep++;
+ if(eof)
+ return -1;
+ if(*linep==0 && inputline()<0){
+ eof = TRUE;
+ return -1;
+ }
+ return *linep++;
}
int
nextc(void)
{
- if(*linep == 0)
- return -1;
- return *linep;
+ if(*linep == 0)
+ return -1;
+ return *linep;
}
void
ungetch(void)
{
- if(--linep < line)
- panic("ungetch");
+ if(--linep < line)
+ panic("ungetch");
}
Posn
getnum(void)
{
- Posn n=0;
- int c;
-
- if((c=nextc())<'0' || '9'<c) /* no number defaults to 1 */
- return 1;
- while('0'<=(c=getch()) && c<='9')
- n = n*10 + (c-'0');
- ungetch();
- return n;
+ Posn n=0;
+ int c;
+
+ if((c=nextc())<'0' || '9'<c) /* no number defaults to 1 */
+ return 1;
+ while('0'<=(c=getch()) && c<='9')
+ n = n*10 + (c-'0');
+ ungetch();
+ return n;
}
int
skipbl(void)
{
- int c;
- do
- c = getch();
- while(c==' ' || c=='\t');
- if(c >= 0)
- ungetch();
- return c;
+ int c;
+ do
+ c = getch();
+ while(c==' ' || c=='\t');
+ if(c >= 0)
+ ungetch();
+ return c;
}
void
termcommand(void)
{
- Posn p;
-
- Fgetcset(cmd, cmdpt);
- for(p=cmdpt; p<cmd->nrunes; p++){
- if(terminp >= &termline[BLOCKSIZE]){
- cmdpt = cmd->nrunes;
- error(Etoolong);
- }
- *terminp++ = Fgetc(cmd);
- }
- cmdpt = cmd->nrunes;
+ Posn p;
+
+ Fgetcset(cmd, cmdpt);
+ for(p=cmdpt; p<cmd->nrunes; p++){
+ if(terminp >= &termline[BLOCKSIZE]){
+ cmdpt = cmd->nrunes;
+ error(Etoolong);
+ }
+ *terminp++ = Fgetc(cmd);
+ }
+ cmdpt = cmd->nrunes;
}
void
cmdloop(void)
{
- Cmd *cmdp;
- File *ocurfile;
- int loaded;
-
- for(;;){
- if(!downloaded && curfile && curfile->state==Unread)
- load(curfile);
- if((cmdp = parsecmd(0))==0){
- if(downloaded){
- rescue();
- exits("eof");
- }
- break;
- }
- ocurfile = curfile;
- loaded = curfile && curfile->state!=Unread;
- if(cmdexec(curfile, cmdp) == 0)
- break;
- freecmd();
- cmdupdate();
- update();
- if(downloaded && curfile &&
- (ocurfile!=curfile || (!loaded && curfile->state!=Unread)))
- outTs(Hcurrent, curfile->tag);
- /* don't allow type ahead on files that aren't bound */
- if(downloaded && curfile && curfile->rasp == 0)
- terminp = termoutp;
- }
+ Cmd *cmdp;
+ File *ocurfile;
+ int loaded;
+
+ for(;;){
+ if(!downloaded && curfile && curfile->state==Unread)
+ load(curfile);
+ if((cmdp = parsecmd(0))==0){
+ if(downloaded){
+ rescue();
+ exits("eof");
+ }
+ break;
+ }
+ ocurfile = curfile;
+ loaded = curfile && curfile->state!=Unread;
+ if(cmdexec(curfile, cmdp) == 0)
+ break;
+ freecmd();
+ cmdupdate();
+ update();
+ if(downloaded && curfile &&
+ (ocurfile!=curfile || (!loaded && curfile->state!=Unread)))
+ outTs(Hcurrent, curfile->tag);
+ /* don't allow type ahead on files that aren't bound */
+ if(downloaded && curfile && curfile->rasp == 0)
+ terminp = termoutp;
+ }
}
Cmd *
newcmd(void){
- Cmd *p;
+ Cmd *p;
- p = emalloc(sizeof(Cmd));
- inslist(&cmdlist, cmdlist.nused, (long)p);
- return p;
+ p = emalloc(sizeof(Cmd));
+ inslist(&cmdlist, cmdlist.nused, (long)p);
+ return p;
}
Addr*
newaddr(void)
{
- Addr *p;
+ Addr *p;
- p = emalloc(sizeof(Addr));
- inslist(&addrlist, addrlist.nused, (long)p);
- return p;
+ p = emalloc(sizeof(Addr));
+ inslist(&addrlist, addrlist.nused, (long)p);
+ return p;
}
String*
newre(void)
{
- String *p;
+ String *p;
- p = emalloc(sizeof(String));
- inslist(&relist, relist.nused, (long)p);
- Strinit(p);
- return p;
+ p = emalloc(sizeof(String));
+ inslist(&relist, relist.nused, (long)p);
+ Strinit(p);
+ return p;
}
String*
newstring(void)
{
- String *p;
+ String *p;
- p = emalloc(sizeof(String));
- inslist(&stringlist, stringlist.nused, (long)p);
- Strinit(p);
- return p;
+ p = emalloc(sizeof(String));
+ inslist(&stringlist, stringlist.nused, (long)p);
+ Strinit(p);
+ return p;
}
void
freecmd(void)
{
- int i;
-
- while(cmdlist.nused > 0)
- free(cmdlist.ucharpptr[--cmdlist.nused]);
- while(addrlist.nused > 0)
- free(addrlist.ucharpptr[--addrlist.nused]);
- while(relist.nused > 0){
- i = --relist.nused;
- Strclose(relist.stringpptr[i]);
- free(relist.stringpptr[i]);
- }
- while(stringlist.nused>0){
- i = --stringlist.nused;
- Strclose(stringlist.stringpptr[i]);
- free(stringlist.stringpptr[i]);
- }
+ int i;
+
+ while(cmdlist.nused > 0)
+ free(cmdlist.ucharpptr[--cmdlist.nused]);
+ while(addrlist.nused > 0)
+ free(addrlist.ucharpptr[--addrlist.nused]);
+ while(relist.nused > 0){
+ i = --relist.nused;
+ Strclose(relist.stringpptr[i]);
+ free(relist.stringpptr[i]);
+ }
+ while(stringlist.nused>0){
+ i = --stringlist.nused;
+ Strclose(stringlist.stringpptr[i]);
+ free(stringlist.stringpptr[i]);
+ }
}
int
lookup(int c)
{
- int i;
+ int i;
- for(i=0; cmdtab[i].cmdc; i++)
- if(cmdtab[i].cmdc == c)
- return i;
- return -1;
+ for(i=0; cmdtab[i].cmdc; i++)
+ if(cmdtab[i].cmdc == c)
+ return i;
+ return -1;
}
void
okdelim(int c)
{
- if(c=='\\' || ('a'<=c && c<='z')
- || ('A'<=c && c<='Z') || ('0'<=c && c<='9'))
- error_c(Edelim, c);
+ if(c=='\\' || ('a'<=c && c<='z')
+ || ('A'<=c && c<='Z') || ('0'<=c && c<='9'))
+ error_c(Edelim, c);
}
void
atnl(void)
{
- skipbl();
- if(getch() != '\n')
- error(Enewline);
+ skipbl();
+ if(getch() != '\n')
+ error(Enewline);
}
void
getrhs(String *s, int delim, int cmd)
{
- int c;
-
- while((c = getch())>0 && c!=delim && c!='\n'){
- if(c == '\\'){
- if((c=getch()) <= 0)
- error(Ebadrhs);
- if(c == '\n'){
- ungetch();
- c='\\';
- }else if(c == 'n')
- c='\n';
- else if(c!=delim && (cmd=='s' || c!='\\')) /* s…
- Straddc(s, '\\');
- }
- Straddc(s, c);
- }
- ungetch(); /* let client read whether delimeter, '\n' or whatev…
+ int c;
+
+ while((c = getch())>0 && c!=delim && c!='\n'){
+ if(c == '\\'){
+ if((c=getch()) <= 0)
+ error(Ebadrhs);
+ if(c == '\n'){
+ ungetch();
+ c='\\';
+ }else if(c == 'n')
+ c='\n';
+ else if(c!=delim && (cmd=='s' || c!='\\')) /* s does its own */
+ Straddc(s, '\\');
+ }
+ Straddc(s, c);
+ }
+ ungetch(); /* let client read whether delimeter, '\n' or whatever */
}
String *
collecttoken(char *end)
{
- String *s = newstring();
- int c;
-
- while((c=nextc())==' ' || c=='\t')
- Straddc(s, getch()); /* blanks significant for getname() */
- while((c=getch())>0 && utfrune(end, c)==0)
- Straddc(s, c);
- Straddc(s, 0);
- if(c != '\n')
- atnl();
- return s;
+ String *s = newstring();
+ int c;
+
+ while((c=nextc())==' ' || c=='\t')
+ Straddc(s, getch()); /* blanks significant for getname() */
+ while((c=getch())>0 && utfrune(end, c)==0)
+ Straddc(s, c);
+ Straddc(s, 0);
+ if(c != '\n')
+ atnl();
+ return s;
}
String *
collecttext(void)
{
- String *s = newstring();
- int begline, i, c, delim;
-
- if(skipbl()=='\n'){
- getch();
- i = 0;
- do{
- begline = i;
- while((c = getch())>0 && c!='\n')
- i++, Straddc(s, c);
- i++, Straddc(s, '\n');
- if(c < 0)
- goto Return;
- }while(s->s[begline]!='.' || s->s[begline+1]!='\n');
- Strdelete(s, s->n-2, s->n);
- }else{
- okdelim(delim = getch());
- getrhs(s, delim, 'a');
- if(nextc()==delim)
- getch();
- atnl();
- }
+ String *s = newstring();
+ int begline, i, c, delim;
+
+ if(skipbl()=='\n'){
+ getch();
+ i = 0;
+ do{
+ begline = i;
+ while((c = getch())>0 && c!='\n')
+ i++, Straddc(s, c);
+ i++, Straddc(s, '\n');
+ if(c < 0)
+ goto Return;
+ }while(s->s[begline]!='.' || s->s[begline+1]!='\n');
+ Strdelete(s, s->n-2, s->n);
+ }else{
+ okdelim(delim = getch());
+ getrhs(s, delim, 'a');
+ if(nextc()==delim)
+ getch();
+ atnl();
+ }
Return:
- Straddc(s, 0); /* JUST FOR CMDPRINT() */
- return s;
+ Straddc(s, 0); /* JUST FOR CMDPRINT() */
+ return s;
}
Cmd *
parsecmd(int nest)
{
- int i, c;
- struct cmdtab *ct;
- Cmd *cp, *ncp;
- Cmd cmd;
-
- cmd.next = cmd.ccmd = 0;
- cmd.re = 0;
- cmd.flag = cmd.num = 0;
- cmd.addr = compoundaddr();
- if(skipbl() == -1)
- return 0;
- if((c=getch())==-1)
- return 0;
- cmd.cmdc = c;
- if(cmd.cmdc=='c' && nextc()=='d'){ /* sleazy two-character case…
- getch(); /* the 'd' */
- cmd.cmdc='c'|0x100;
- }
- i = lookup(cmd.cmdc);
- if(i >= 0){
- if(cmd.cmdc == '\n')
- goto Return; /* let nl_cmd work it all out */
- ct = &cmdtab[i];
- if(ct->defaddr==aNo && cmd.addr)
- error(Enoaddr);
- if(ct->count)
- cmd.num = getnum();
- if(ct->regexp){
- /* x without pattern -> .*\n, indicated by cmd.re==0 */
- /* X without pattern is all files */
- if((ct->cmdc!='x' && ct->cmdc!='X') ||
- ((c = nextc())!=' ' && c!='\t' && c!='\n')){
- skipbl();
- if((c = getch())=='\n' || c<0)
- error(Enopattern);
- okdelim(c);
- cmd.re = getregexp(c);
- if(ct->cmdc == 's'){
- cmd.ctext = newstring();
- getrhs(cmd.ctext, c, 's');
- if(nextc() == c){
- getch();
- if(nextc() == 'g')
- cmd.flag = getch();
- }
-
- }
- }
- }
- if(ct->addr && (cmd.caddr=simpleaddr())==0)
- error(Eaddress);
- if(ct->defcmd){
- if(skipbl() == '\n'){
- getch();
- cmd.ccmd = newcmd();
- cmd.ccmd->cmdc = ct->defcmd;
- }else if((cmd.ccmd = parsecmd(nest))==0)
- panic("defcmd");
- }else if(ct->text)
- cmd.ctext = collecttext();
- else if(ct->token)
- cmd.ctext = collecttoken(ct->token);
- else
- atnl();
- }else
- switch(cmd.cmdc){
- case '{':
- cp = 0;
- do{
- if(skipbl()=='\n')
- getch();
- ncp = parsecmd(nest+1);
- if(cp)
- cp->next = ncp;
- else
- cmd.ccmd = ncp;
- }while(cp = ncp);
- break;
- case '}':
- atnl();
- if(nest==0)
- error(Enolbrace);
- return 0;
- default:
- error_c(Eunk, cmd.cmdc);
- }
+ int i, c;
+ struct cmdtab *ct;
+ Cmd *cp, *ncp;
+ Cmd cmd;
+
+ cmd.next = cmd.ccmd = 0;
+ cmd.re = 0;
+ cmd.flag = cmd.num = 0;
+ cmd.addr = compoundaddr();
+ if(skipbl() == -1)
+ return 0;
+ if((c=getch())==-1)
+ return 0;
+ cmd.cmdc = c;
+ if(cmd.cmdc=='c' && nextc()=='d'){ /* sleazy two-character case */
+ getch(); /* the 'd' */
+ cmd.cmdc='c'|0x100;
+ }
+ i = lookup(cmd.cmdc);
+ if(i >= 0){
+ if(cmd.cmdc == '\n')
+ goto Return; /* let nl_cmd work it all out */
+ ct = &cmdtab[i];
+ if(ct->defaddr==aNo && cmd.addr)
+ error(Enoaddr);
+ if(ct->count)
+ cmd.num = getnum();
+ if(ct->regexp){
+ /* x without pattern -> .*\n, indicated by cmd.re==0 */
+ /* X without pattern is all files */
+ if((ct->cmdc!='x' && ct->cmdc!='X') ||
+ ((c = nextc())!=' ' && c!='\t' && c!='\n')){
+ skipbl();
+ if((c = getch())=='\n' || c<0)
+ error(Enopattern);
+ okdelim(c);
+ cmd.re = getregexp(c);
+ if(ct->cmdc == 's'){
+ cmd.ctext = newstring();
+ getrhs(cmd.ctext, c, 's');
+ if(nextc() == c){
+ getch();
+ if(nextc() == 'g')
+ cmd.flag = getch();
+ }
+
+ }
+ }
+ }
+ if(ct->addr && (cmd.caddr=simpleaddr())==0)
+ error(Eaddress);
+ if(ct->defcmd){
+ if(skipbl() == '\n'){
+ getch();
+ cmd.ccmd = newcmd();
+ cmd.ccmd->cmdc = ct->defcmd;
+ }else if((cmd.ccmd = parsecmd(nest))==0)
+ panic("defcmd");
+ }else if(ct->text)
+ cmd.ctext = collecttext();
+ else if(ct->token)
+ cmd.ctext = collecttoken(ct->token);
+ else
+ atnl();
+ }else
+ switch(cmd.cmdc){
+ case '{':
+ cp = 0;
+ do{
+ if(skipbl()=='\n')
+ getch();
+ ncp = parsecmd(nest+1);
+ if(cp)
+ cp->next = ncp;
+ else
+ cmd.ccmd = ncp;
+ }while(cp = ncp);
+ break;
+ case '}':
+ atnl();
+ if(nest==0)
+ error(Enolbrace);
+ return 0;
+ default:
+ error_c(Eunk, cmd.cmdc);
+ }
Return:
- cp = newcmd();
- *cp = cmd;
- return cp;
+ cp = newcmd();
+ *cp = cmd;
+ return cp;
}
-String* /* BUGGERED */
+String* /* BUGGERED */
getregexp(int delim)
{
- String *r = newre();
- int c;
-
- for(Strzero(&genstr); ; Straddc(&genstr, c))
- if((c = getch())=='\\'){
- if(nextc()==delim)
- c = getch();
- else if(nextc()=='\\'){
- Straddc(&genstr, c);
- c = getch();
- }
- }else if(c==delim || c=='\n')
- break;
- if(c!=delim && c)
- ungetch();
- if(genstr.n > 0){
- patset = TRUE;
- Strduplstr(&lastpat, &genstr);
- Straddc(&lastpat, '\0');
- }
- if(lastpat.n <= 1)
- error(Epattern);
- Strduplstr(r, &lastpat);
- return r;
+ String *r = newre();
+ int c;
+
+ for(Strzero(&genstr); ; Straddc(&genstr, c))
+ if((c = getch())=='\\'){
+ if(nextc()==delim)
+ c = getch();
+ else if(nextc()=='\\'){
+ Straddc(&genstr, c);
+ c = getch();
+ }
+ }else if(c==delim || c=='\n')
+ break;
+ if(c!=delim && c)
+ ungetch();
+ if(genstr.n > 0){
+ patset = TRUE;
+ Strduplstr(&lastpat, &genstr);
+ Straddc(&lastpat, '\0');
+ }
+ if(lastpat.n <= 1)
+ error(Epattern);
+ Strduplstr(r, &lastpat);
+ return r;
}
Addr *
simpleaddr(void)
{
- Addr addr;
- Addr *ap, *nap;
-
- addr.next = 0;
- addr.left = 0;
- switch(skipbl()){
- case '#':
- addr.type = getch();
- addr.num = getnum();
- break;
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- addr.num = getnum();
- addr.type='l';
- break;
- case '/': case '?': case '"':
- addr.are = getregexp(addr.type = getch());
- break;
- case '.':
- case '$':
- case '+':
- case '-':
- case '\'':
- addr.type = getch();
- break;
- default:
- return 0;
- }
- if(addr.next = simpleaddr())
- switch(addr.next->type){
- case '.':
- case '$':
- case '\'':
- if(addr.type!='"')
- case '"':
- error(Eaddress);
- break;
- case 'l':
- case '#':
- if(addr.type=='"')
- break;
- /* fall through */
- case '/':
- case '?':
- if(addr.type!='+' && addr.type!='-'){
- /* insert the missing '+' */
- nap = newaddr();
- nap->type='+';
- nap->next = addr.next;
- addr.next = nap;
- }
- break;
- case '+':
- case '-':
- break;
- default:
- panic("simpleaddr");
- }
- ap = newaddr();
- *ap = addr;
- return ap;
+ Addr addr;
+ Addr *ap, *nap;
+
+ addr.next = 0;
+ addr.left = 0;
+ switch(skipbl()){
+ case '#':
+ addr.type = getch();
+ addr.num = getnum();
+ break;
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ addr.num = getnum();
+ addr.type='l';
+ break;
+ case '/': case '?': case '"':
+ addr.are = getregexp(addr.type = getch());
+ break;
+ case '.':
+ case '$':
+ case '+':
+ case '-':
+ case '\'':
+ addr.type = getch();
+ break;
+ default:
+ return 0;
+ }
+ if(addr.next = simpleaddr())
+ switch(addr.next->type){
+ case '.':
+ case '$':
+ case '\'':
+ if(addr.type!='"')
+ case '"':
+ error(Eaddress);
+ break;
+ case 'l':
+ case '#':
+ if(addr.type=='"')
+ break;
+ /* fall through */
+ case '/':
+ case '?':
+ if(addr.type!='+' && addr.type!='-'){
+ /* insert the missing '+' */
+ nap = newaddr();
+ nap->type='+';
+ nap->next = addr.next;
+ addr.next = nap;
+ }
+ break;
+ case '+':
+ case '-':
+ break;
+ default:
+ panic("simpleaddr");
+ }
+ ap = newaddr();
+ *ap = addr;
+ return ap;
}
Addr *
compoundaddr(void)
{
- Addr addr;
- Addr *ap, *next;
-
- addr.left = simpleaddr();
- if((addr.type = skipbl())!=',' && addr.type!=';')
- return addr.left;
- getch();
- next = addr.next = compoundaddr();
- if(next && (next->type==',' || next->type==';') && next->left==0)
- error(Eaddress);
- ap = newaddr();
- *ap = addr;
- return ap;
+ Addr addr;
+ Addr *ap, *next;
+
+ addr.left = simpleaddr();
+ if((addr.type = skipbl())!=',' && addr.type!=';')
+ return addr.left;
+ getch();
+ next = addr.next = compoundaddr();
+ if(next && (next->type==',' || next->type==';') && next->left==0)
+ error(Eaddress);
+ ap = newaddr();
+ *ap = addr;
+ return ap;
}
diff --git a/sam/disc.c b/sam/disc.c
@@ -1,335 +1,335 @@
/* Copyright (c) 1998 Lucent Technologies - All rights reserved. */
#include "sam.h"
-#define BLOCKFILL (BLOCKSIZE/2)
+#define BLOCKFILL (BLOCKSIZE/2)
-static Discdesc desc[NBUFFILES];
+static Discdesc desc[NBUFFILES];
-void bkalloc(Disc*, int);
-void bkfree(Disc*, int);
-void bkwrite(Disc*, Rune*, int, int, int);
-void bkread(Disc*, Rune*, int, int, int);
+void bkalloc(Disc*, int);
+void bkfree(Disc*, int);
+void bkwrite(Disc*, Rune*, int, int, int);
+void bkread(Disc*, Rune*, int, int, int);
Discdesc *
Dstart(void)
{
- int i, fd;
- Discdesc *dd;
+ int i, fd;
+ Discdesc *dd;
- for(i=0, dd=desc; dd->fd; i++, dd++)
- if(i == NBUFFILES-1)
- panic("too many buffer files");
- fd = newtmp();
- if(fd < 0)
- panic("can't create buffer file");
- dd->fd = fd;
- return dd;
+ for(i=0, dd=desc; dd->fd; i++, dd++)
+ if(i == NBUFFILES-1)
+ panic("too many buffer files");
+ fd = newtmp();
+ if(fd < 0)
+ panic("can't create buffer file");
+ dd->fd = fd;
+ return dd;
}
Disc *
Dopen(Discdesc *dd)
{
- Disc *d;
+ Disc *d;
- d = emalloc(sizeof(Disc));
- d->desc = dd;
- return d;
+ d = emalloc(sizeof(Disc));
+ d->desc = dd;
+ return d;
}
void
Dclose(Disc *d)
{
- int i;
+ int i;
- for(i=d->block.nused; --i>=0; ) /* backwards because bkfree() s…
- bkfree(d, i);
- free(d->block.listptr);
- free(d);
+ for(i=d->block.nused; --i>=0; ) /* backwards because bkfree() stacks */
+ bkfree(d, i);
+ free(d->block.listptr);
+ free(d);
}
int
Dread(Disc *d, Rune *addr, int n, Posn p1)
{
- int i, nb, nr;
- Posn p = 0, p2 = p1+n;
+ int i, nb, nr;
+ Posn p = 0, p2 = p1+n;
- for(i=0; i<d->block.nused; i++){
- if((p+=d->block.blkptr[i].nrunes) > p1){
- p -= d->block.blkptr[i].nrunes;
- goto out;
- }
- }
- if(p == p1)
- return 0; /* eof */
- return -1; /* past eof */
+ for(i=0; i<d->block.nused; i++){
+ if((p+=d->block.blkptr[i].nrunes) > p1){
+ p -= d->block.blkptr[i].nrunes;
+ goto out;
+ }
+ }
+ if(p == p1)
+ return 0; /* eof */
+ return -1; /* past eof */
out:
- n = 0;
- if(p != p1){ /* trailing partial block */
- nb = d->block.blkptr[i].nrunes;
- if(p2 > p+nb)
- nr = nb-(p1-p);
- else
- nr = p2-p1;
- bkread(d, addr, nr, i, p1-p);
- /* advance to next block */
- p += nb;
- addr += nr;
- n += nr;
- i++;
- }
- /* whole blocks */
- while(p<p2 && (nb = d->block.blkptr[i].nrunes)<=p2-p){
- if(i >= d->block.nused)
- return n; /* eof */
- bkread(d, addr, nb, i, 0);
- p += nb;
- addr += nb;
- n += nb;
- i++;
- }
- if(p < p2){ /* any initial partial block left? */
- nr = p2-p;
- nb = d->block.blkptr[i].nrunes;
- if(nr>nb)
- nr = nb; /* eof */
- /* just read in the part that survives */
- bkread(d, addr, nr, i, 0);
- n += nr;
- }
- return n;
+ n = 0;
+ if(p != p1){ /* trailing partial block */
+ nb = d->block.blkptr[i].nrunes;
+ if(p2 > p+nb)
+ nr = nb-(p1-p);
+ else
+ nr = p2-p1;
+ bkread(d, addr, nr, i, p1-p);
+ /* advance to next block */
+ p += nb;
+ addr += nr;
+ n += nr;
+ i++;
+ }
+ /* whole blocks */
+ while(p<p2 && (nb = d->block.blkptr[i].nrunes)<=p2-p){
+ if(i >= d->block.nused)
+ return n; /* eof */
+ bkread(d, addr, nb, i, 0);
+ p += nb;
+ addr += nb;
+ n += nb;
+ i++;
+ }
+ if(p < p2){ /* any initial partial block left? */
+ nr = p2-p;
+ nb = d->block.blkptr[i].nrunes;
+ if(nr>nb)
+ nr = nb; /* eof */
+ /* just read in the part that survives */
+ bkread(d, addr, nr, i, 0);
+ n += nr;
+ }
+ return n;
}
void
Dinsert(Disc *d, Rune *addr, int n, Posn p0) /* if addr null, just make space …
{
- int i, nb, ni;
- Posn p = 0;
- Rune hold[BLOCKSIZE];
- int nhold;
+ int i, nb, ni;
+ Posn p = 0;
+ Rune hold[BLOCKSIZE];
+ int nhold;
- for(i=0; i<d->block.nused; i++){
- if((p+=d->block.blkptr[i].nrunes) >= p0){
- p -= d->block.blkptr[i].nrunes;
- goto out;
- }
- }
- if(p != p0)
- panic("Dinsert"); /* beyond eof */
+ for(i=0; i<d->block.nused; i++){
+ if((p+=d->block.blkptr[i].nrunes) >= p0){
+ p -= d->block.blkptr[i].nrunes;
+ goto out;
+ }
+ }
+ if(p != p0)
+ panic("Dinsert"); /* beyond eof */
out:
- d->nrunes += n;
- nhold = 0;
- if(i<d->block.nused && (nb=d->block.blkptr[i].nrunes)>p0-p){
- nhold = nb-(p0-p);
- bkread(d, hold, nhold, i, p0-p);
- d->block.blkptr[i].nrunes -= nhold; /* no write necessa…
- }
- /* insertion point is now at end of block i (which may not exist) */
- while(n > 0){
- if(i < d->block.nused
- && (nb=d->block.blkptr[i].nrunes) < BLOCKFILL){
- /* fill this block */
- if(nb+n > BLOCKSIZE)
- ni = BLOCKFILL-nb;
- else
- ni = n;
- if(addr)
- bkwrite(d, addr, ni, i, nb);
- nb += ni;
- }else{ /* make new block */
- if(i < d->block.nused)
- i++; /* put after this block, if it exi…
- bkalloc(d, i);
- if(n > BLOCKSIZE)
- ni = BLOCKFILL;
- else
- ni = n;
- if(addr)
- bkwrite(d, addr, ni, i, 0);
- nb = ni;
- }
- d->block.blkptr[i].nrunes = nb;
- if(addr)
- addr += ni;
- n -= ni;
- }
- if(nhold){
- if(i < d->block.nused
- && (nb=d->block.blkptr[i].nrunes)+nhold < BLOCKSIZE){
- /* fill this block */
- bkwrite(d, hold, nhold, i, nb);
- nb += nhold;
- }else{ /* make new block */
- if(i < d->block.nused)
- i++; /* put after this block, if it exi…
- bkalloc(d, i);
- bkwrite(d, hold, nhold, i, 0);
- nb = nhold;
- }
- d->block.blkptr[i].nrunes = nb;
- }
+ d->nrunes += n;
+ nhold = 0;
+ if(i<d->block.nused && (nb=d->block.blkptr[i].nrunes)>p0-p){
+ nhold = nb-(p0-p);
+ bkread(d, hold, nhold, i, p0-p);
+ d->block.blkptr[i].nrunes -= nhold; /* no write necessary */
+ }
+ /* insertion point is now at end of block i (which may not exist) */
+ while(n > 0){
+ if(i < d->block.nused
+ && (nb=d->block.blkptr[i].nrunes) < BLOCKFILL){
+ /* fill this block */
+ if(nb+n > BLOCKSIZE)
+ ni = BLOCKFILL-nb;
+ else
+ ni = n;
+ if(addr)
+ bkwrite(d, addr, ni, i, nb);
+ nb += ni;
+ }else{ /* make new block */
+ if(i < d->block.nused)
+ i++; /* put after this block, if it exists */
+ bkalloc(d, i);
+ if(n > BLOCKSIZE)
+ ni = BLOCKFILL;
+ else
+ ni = n;
+ if(addr)
+ bkwrite(d, addr, ni, i, 0);
+ nb = ni;
+ }
+ d->block.blkptr[i].nrunes = nb;
+ if(addr)
+ addr += ni;
+ n -= ni;
+ }
+ if(nhold){
+ if(i < d->block.nused
+ && (nb=d->block.blkptr[i].nrunes)+nhold < BLOCKSIZE){
+ /* fill this block */
+ bkwrite(d, hold, nhold, i, nb);
+ nb += nhold;
+ }else{ /* make new block */
+ if(i < d->block.nused)
+ i++; /* put after this block, if it exists */
+ bkalloc(d, i);
+ bkwrite(d, hold, nhold, i, 0);
+ nb = nhold;
+ }
+ d->block.blkptr[i].nrunes = nb;
+ }
}
void
Ddelete(Disc *d, Posn p1, Posn p2)
{
- int i, nb, nd;
- Posn p = 0;
- Rune buf[BLOCKSIZE];
+ int i, nb, nd;
+ Posn p = 0;
+ Rune buf[BLOCKSIZE];
- for(i = 0; i<d->block.nused; i++){
- if((p+=d->block.blkptr[i].nrunes) > p1){
- p -= d->block.blkptr[i].nrunes;
- goto out;
- }
- }
- if(p1!=d->nrunes || p2!=p1)
- panic("Ddelete");
- return; /* beyond eof */
+ for(i = 0; i<d->block.nused; i++){
+ if((p+=d->block.blkptr[i].nrunes) > p1){
+ p -= d->block.blkptr[i].nrunes;
+ goto out;
+ }
+ }
+ if(p1!=d->nrunes || p2!=p1)
+ panic("Ddelete");
+ return; /* beyond eof */
out:
- d->nrunes -= p2-p1;
- if(p != p1){ /* throw away partial block */
- nb = d->block.blkptr[i].nrunes;
- bkread(d, buf, nb, i, 0);
- if(p2 >= p+nb)
- nd = nb-(p1-p);
- else{
- nd = p2-p1;
- memmove(buf+(p1-p), buf+(p1-p)+nd, RUNESIZE*(nb-((p1-p…
- }
- nb -= nd;
- bkwrite(d, buf, nb, i, 0);
- d->block.blkptr[i].nrunes = nb;
- p2 -= nd;
- /* advance to next block */
- p += nb;
- i++;
- }
- /* throw away whole blocks */
- while(p<p2 && (nb = d->block.blkptr[i].nrunes)<=p2-p){
- if(i >= d->block.nused)
- panic("Ddelete 2");
- bkfree(d, i);
- p2 -= nb;
- }
- if(p >= p2) /* any initial partial block left to delete? */
- return; /* no */
- nd = p2-p;
- nb = d->block.blkptr[i].nrunes;
- /* just read in the part that survives */
- bkread(d, buf, nb-=nd, i, nd);
- /* a little block merging */
- if(nb<BLOCKSIZE/2 && i>0 && (nd = d->block.blkptr[i-1].nrunes)<BLOCKSI…
- memmove(buf+nd, buf, RUNESIZE*nb);
- bkread(d, buf, nd, --i, 0);
- bkfree(d, i);
- nb += nd;
- }
- bkwrite(d, buf, nb, i, 0);
- d->block.blkptr[i].nrunes = nb;
+ d->nrunes -= p2-p1;
+ if(p != p1){ /* throw away partial block */
+ nb = d->block.blkptr[i].nrunes;
+ bkread(d, buf, nb, i, 0);
+ if(p2 >= p+nb)
+ nd = nb-(p1-p);
+ else{
+ nd = p2-p1;
+ memmove(buf+(p1-p), buf+(p1-p)+nd, RUNESIZE*(nb-((p1-p)+nd)));
+ }
+ nb -= nd;
+ bkwrite(d, buf, nb, i, 0);
+ d->block.blkptr[i].nrunes = nb;
+ p2 -= nd;
+ /* advance to next block */
+ p += nb;
+ i++;
+ }
+ /* throw away whole blocks */
+ while(p<p2 && (nb = d->block.blkptr[i].nrunes)<=p2-p){
+ if(i >= d->block.nused)
+ panic("Ddelete 2");
+ bkfree(d, i);
+ p2 -= nb;
+ }
+ if(p >= p2) /* any initial partial block left to delete? */
+ return; /* no */
+ nd = p2-p;
+ nb = d->block.blkptr[i].nrunes;
+ /* just read in the part that survives */
+ bkread(d, buf, nb-=nd, i, nd);
+ /* a little block merging */
+ if(nb<BLOCKSIZE/2 && i>0 && (nd = d->block.blkptr[i-1].nrunes)<BLOCKSIZE/2…
+ memmove(buf+nd, buf, RUNESIZE*nb);
+ bkread(d, buf, nd, --i, 0);
+ bkfree(d, i);
+ nb += nd;
+ }
+ bkwrite(d, buf, nb, i, 0);
+ d->block.blkptr[i].nrunes = nb;
}
void
Dreplace(Disc *d, Posn p1, Posn p2, Rune *addr, int n)
{
- int i, nb, nr;
- Posn p = 0;
- Rune buf[BLOCKSIZE];
+ int i, nb, nr;
+ Posn p = 0;
+ Rune buf[BLOCKSIZE];
- if(p2-p1 > n)
- Ddelete(d, p1+n, p2);
- else if(p2-p1 < n)
- Dinsert(d, 0, n-(p2-p1), p2);
- if(n == 0)
- return;
- p2 = p1+n;
- /* they're now conformal; replace in place */
- for(i=0; i<d->block.nused; i++){
- if((p+=d->block.blkptr[i].nrunes) > p1){
- p -= d->block.blkptr[i].nrunes;
- goto out;
- }
- }
- panic("Dreplace");
+ if(p2-p1 > n)
+ Ddelete(d, p1+n, p2);
+ else if(p2-p1 < n)
+ Dinsert(d, 0, n-(p2-p1), p2);
+ if(n == 0)
+ return;
+ p2 = p1+n;
+ /* they're now conformal; replace in place */
+ for(i=0; i<d->block.nused; i++){
+ if((p+=d->block.blkptr[i].nrunes) > p1){
+ p -= d->block.blkptr[i].nrunes;
+ goto out;
+ }
+ }
+ panic("Dreplace");
out:
- if(p != p1){ /* trailing partial block */
- nb = d->block.blkptr[i].nrunes;
- bkread(d, buf, nb, i, 0);
- if(p2 > p+nb)
- nr = nb-(p1-p);
- else
- nr = p2-p1;
- memmove(buf+p1-p, addr, RUNESIZE*nr);
- bkwrite(d, buf, nb, i, 0);
- /* advance to next block */
- p += nb;
- addr += nr;
- i++;
- }
- /* whole blocks */
- while(p<p2 && (nb = d->block.blkptr[i].nrunes)<=p2-p){
- if(i >= d->block.nused)
- panic("Dreplace 2");
- bkwrite(d, addr, nb, i, 0);
- p += nb;
- addr += nb;
- i++;
- }
- if(p < p2){ /* any initial partial block left? */
- nr = p2-p;
- nb = d->block.blkptr[i].nrunes;
- /* just read in the part that survives */
- bkread(d, buf+nr, nb-nr, i, nr);
- memmove(buf, addr, RUNESIZE*nr);
- bkwrite(d, buf, nb, i, 0);
- }
+ if(p != p1){ /* trailing partial block */
+ nb = d->block.blkptr[i].nrunes;
+ bkread(d, buf, nb, i, 0);
+ if(p2 > p+nb)
+ nr = nb-(p1-p);
+ else
+ nr = p2-p1;
+ memmove(buf+p1-p, addr, RUNESIZE*nr);
+ bkwrite(d, buf, nb, i, 0);
+ /* advance to next block */
+ p += nb;
+ addr += nr;
+ i++;
+ }
+ /* whole blocks */
+ while(p<p2 && (nb = d->block.blkptr[i].nrunes)<=p2-p){
+ if(i >= d->block.nused)
+ panic("Dreplace 2");
+ bkwrite(d, addr, nb, i, 0);
+ p += nb;
+ addr += nb;
+ i++;
+ }
+ if(p < p2){ /* any initial partial block left? */
+ nr = p2-p;
+ nb = d->block.blkptr[i].nrunes;
+ /* just read in the part that survives */
+ bkread(d, buf+nr, nb-nr, i, nr);
+ memmove(buf, addr, RUNESIZE*nr);
+ bkwrite(d, buf, nb, i, 0);
+ }
}
void
bkread(Disc *d, Rune *loc, int n, int bk, int off)
{
- Seek(d->desc->fd, RUNESIZE*(BLOCKSIZE*d->block.blkptr[bk].bnum+off), 0…
- Read(d->desc->fd, loc, n*RUNESIZE);
+ Seek(d->desc->fd, RUNESIZE*(BLOCKSIZE*d->block.blkptr[bk].bnum+off), 0);
+ Read(d->desc->fd, loc, n*RUNESIZE);
}
void
bkwrite(Disc *d, Rune *loc, int n, int bk, int off)
{
- Seek(d->desc->fd, RUNESIZE*(BLOCKSIZE*d->block.blkptr[bk].bnum+off), 0…
- Write(d->desc->fd, loc, n*RUNESIZE);
- /*
- * sleazy hack to avoid silly SGI kernel bug
- * fill partial block with garbage
- */
- if (off+n >= d->block.blkptr[bk].nrunes && off+n < BLOCKSIZE)
- Write(d->desc->fd, genbuf, (BLOCKSIZE-(off+n))*RUNESIZE);
+ Seek(d->desc->fd, RUNESIZE*(BLOCKSIZE*d->block.blkptr[bk].bnum+off), 0);
+ Write(d->desc->fd, loc, n*RUNESIZE);
+ /*
+ * sleazy hack to avoid silly SGI kernel bug
+ * fill partial block with garbage
+ */
+ if (off+n >= d->block.blkptr[bk].nrunes && off+n < BLOCKSIZE)
+ Write(d->desc->fd, genbuf, (BLOCKSIZE-(off+n))*RUNESIZE);
}
void
bkalloc(Disc *d, int n)
{
- Discdesc *dd = d->desc;
- ulong bnum;
+ Discdesc *dd = d->desc;
+ ulong bnum;
- if(dd->free.nused)
- bnum = dd->free.longptr[--dd->free.nused];
- else
- bnum = dd->nbk++;
- if(bnum >= 1<<(8*(sizeof(((Block*)0)->bnum))))
- error(Etmpovfl);
- inslist(&d->block, n, 0L);
- d->block.blkptr[n].bnum = bnum;
+ if(dd->free.nused)
+ bnum = dd->free.longptr[--dd->free.nused];
+ else
+ bnum = dd->nbk++;
+ if(bnum >= 1<<(8*(sizeof(((Block*)0)->bnum))))
+ error(Etmpovfl);
+ inslist(&d->block, n, 0L);
+ d->block.blkptr[n].bnum = bnum;
}
void
bkfree(Disc *d, int n)
{
- Discdesc *dd = d->desc;
+ Discdesc *dd = d->desc;
- inslist(&dd->free, dd->free.nused, d->block.blkptr[n].bnum);
- dellist(&d->block, n);
+ inslist(&dd->free, dd->free.nused, d->block.blkptr[n].bnum);
+ dellist(&d->block, n);
}
diff --git a/sam/error.c b/sam/error.c
@@ -2,131 +2,131 @@
#include "sam.h"
static char *emsg[]={
- /* error_s */
- "can't open",
- "can't create",
- "not in menu:",
- "changes to",
- "I/O error:",
- /* error_c */
- "unknown command",
- "no operand for",
- "bad delimiter",
- /* error */
- "can't fork",
- "interrupt",
- "address",
- "search",
- "pattern",
- "newline expected",
- "blank expected",
- "pattern expected",
- "can't nest X or Y",
- "unmatched `}'",
- "command takes no address",
- "addresses overlap",
- "substitution",
- "& match too long",
- "bad \\ in rhs",
- "address range",
- "changes not in sequence",
- "addresses out of order",
- "no file name",
- "unmatched `('",
- "unmatched `)'",
- "malformed `[]'",
- "malformed regexp",
- "reg. exp. list overflow",
- "plan 9 command",
- "can't pipe",
- "no current file",
- "string too long",
- "changed files",
- "empty string",
- "file search",
- "non-unique match for \"\"",
- "tag match too long",
- "too many subexpressions",
- "temporary file too large",
- "file is append-only",
+ /* error_s */
+ "can't open",
+ "can't create",
+ "not in menu:",
+ "changes to",
+ "I/O error:",
+ /* error_c */
+ "unknown command",
+ "no operand for",
+ "bad delimiter",
+ /* error */
+ "can't fork",
+ "interrupt",
+ "address",
+ "search",
+ "pattern",
+ "newline expected",
+ "blank expected",
+ "pattern expected",
+ "can't nest X or Y",
+ "unmatched `}'",
+ "command takes no address",
+ "addresses overlap",
+ "substitution",
+ "& match too long",
+ "bad \\ in rhs",
+ "address range",
+ "changes not in sequence",
+ "addresses out of order",
+ "no file name",
+ "unmatched `('",
+ "unmatched `)'",
+ "malformed `[]'",
+ "malformed regexp",
+ "reg. exp. list overflow",
+ "plan 9 command",
+ "can't pipe",
+ "no current file",
+ "string too long",
+ "changed files",
+ "empty string",
+ "file search",
+ "non-unique match for \"\"",
+ "tag match too long",
+ "too many subexpressions",
+ "temporary file too large",
+ "file is append-only",
};
static char *wmsg[]={
- /* warn_s */
- "duplicate file name",
- "no such file",
- "write might change good version of",
- /* warn_S */
- "files might be aliased",
- /* warn */
- "null characters elided",
- "can't run pwd",
- "last char not newline",
- "exit status not 0",
+ /* warn_s */
+ "duplicate file name",
+ "no such file",
+ "write might change good version of",
+ /* warn_S */
+ "files might be aliased",
+ /* warn */
+ "null characters elided",
+ "can't run pwd",
+ "last char not newline",
+ "exit status not 0",
};
void
error(Err s)
{
- char buf[512];
+ char buf[512];
- sprint(buf, "?%s", emsg[s]);
- hiccough(buf);
+ sprint(buf, "?%s", emsg[s]);
+ hiccough(buf);
}
void
error_s(Err s, char *a)
{
- char buf[512];
+ char buf[512];
- sprint(buf, "?%s \"%s\"", emsg[s], a);
- hiccough(buf);
+ sprint(buf, "?%s \"%s\"", emsg[s], a);
+ hiccough(buf);
}
void
error_c(Err s, int c)
{
- char buf[512];
+ char buf[512];
- sprint(buf, "?%s `%c'", emsg[s], c);
- hiccough(buf);
+ sprint(buf, "?%s `%c'", emsg[s], c);
+ hiccough(buf);
}
void
warn(Warn s)
{
- dprint("?warning: %s\n", wmsg[s]);
+ dprint("?warning: %s\n", wmsg[s]);
}
void
warn_S(Warn s, String *a)
{
- print_s(wmsg[s], a);
+ print_s(wmsg[s], a);
}
void
warn_SS(Warn s, String *a, String *b)
{
- print_ss(wmsg[s], a, b);
+ print_ss(wmsg[s], a, b);
}
void
warn_s(Warn s, char *a)
{
- dprint("?warning: %s `%s'\n", wmsg[s], a);
+ dprint("?warning: %s `%s'\n", wmsg[s], a);
}
void
termwrite(char *s)
{
- String *p;
+ String *p;
- if(downloaded){
- p = tmpcstr(s);
- if(cmd)
- Finsert(cmd, p, cmdpt);
- else
- Strinsert(&cmdstr, p, cmdstr.n);
- cmdptadv += p->n;
- }else
- Write(2, s, strlen(s));
+ if(downloaded){
+ p = tmpcstr(s);
+ if(cmd)
+ Finsert(cmd, p, cmdpt);
+ else
+ Strinsert(&cmdstr, p, cmdstr.n);
+ cmdptadv += p->n;
+ }else
+ Write(2, s, strlen(s));
}
diff --git a/sam/errors.h b/sam/errors.h
@@ -1,63 +1,63 @@
/* Copyright (c) 1998 Lucent Technologies - All rights reserved. */
typedef enum Err{
- /* error_s */
- Eopen,
- Ecreate,
- Emenu,
- Emodified,
- Eio,
- /* error_c */
- Eunk,
- Emissop,
- Edelim,
- /* error */
- Efork,
- Eintr,
- Eaddress,
- Esearch,
- Epattern,
- Enewline,
- Eblank,
- Enopattern,
- EnestXY,
- Enolbrace,
- Enoaddr,
- Eoverlap,
- Enosub,
- Elongrhs,
- Ebadrhs,
- Erange,
- Esequence,
- Eorder,
- Enoname,
- Eleftpar,
- Erightpar,
- Ebadclass,
- Ebadregexp,
- Eoverflow,
- Enocmd,
- Epipe,
- Enofile,
- Etoolong,
- Echanges,
- Eempty,
- Efsearch,
- Emanyfiles,
- Elongtag,
- Esubexp,
- Etmpovfl,
- Eappend
+ /* error_s */
+ Eopen,
+ Ecreate,
+ Emenu,
+ Emodified,
+ Eio,
+ /* error_c */
+ Eunk,
+ Emissop,
+ Edelim,
+ /* error */
+ Efork,
+ Eintr,
+ Eaddress,
+ Esearch,
+ Epattern,
+ Enewline,
+ Eblank,
+ Enopattern,
+ EnestXY,
+ Enolbrace,
+ Enoaddr,
+ Eoverlap,
+ Enosub,
+ Elongrhs,
+ Ebadrhs,
+ Erange,
+ Esequence,
+ Eorder,
+ Enoname,
+ Eleftpar,
+ Erightpar,
+ Ebadclass,
+ Ebadregexp,
+ Eoverflow,
+ Enocmd,
+ Epipe,
+ Enofile,
+ Etoolong,
+ Echanges,
+ Eempty,
+ Efsearch,
+ Emanyfiles,
+ Elongtag,
+ Esubexp,
+ Etmpovfl,
+ Eappend
}Err;
typedef enum Warn{
- /* warn_s */
- Wdupname,
- Wfile,
- Wdate,
- /* warn_ss */
- Wdupfile,
- /* warn */
- Wnulls,
- Wpwd,
- Wnotnewline,
- Wbadstatus
+ /* warn_s */
+ Wdupname,
+ Wfile,
+ Wdate,
+ /* warn_ss */
+ Wdupfile,
+ /* warn */
+ Wnulls,
+ Wpwd,
+ Wnotnewline,
+ Wbadstatus
}Warn;
diff --git a/sam/file.c b/sam/file.c
@@ -3,211 +3,211 @@
/*
* Files are splayed out a factor of NDISC to reduce indirect block access
*/
-Discdesc *files[NDISC];
-Discdesc *transcripts[NDISC];
-Buffer *undobuf;
-static String *ftempstr(Rune*, int);
-int fcount;
-File *lastfile;
-
-void puthdr_csl(Buffer*, char, short, Posn);
-void puthdr_cs(Buffer*, char, short);
-void puthdr_M(Buffer*, Posn, Range, Range, Mod, short);
-void puthdr_cll(Buffer*, char, Posn, Posn);
-void Fflush(File*);
+Discdesc *files[NDISC];
+Discdesc *transcripts[NDISC];
+Buffer *undobuf;
+static String *ftempstr(Rune*, int);
+int fcount;
+File *lastfile;
+
+void puthdr_csl(Buffer*, char, short, Posn);
+void puthdr_cs(Buffer*, char, short);
+void puthdr_M(Buffer*, Posn, Range, Range, Mod, short);
+void puthdr_cll(Buffer*, char, Posn, Posn);
+void Fflush(File*);
enum{
- SKIP=50, /* max dist between file changes folded togeth…
- MAXCACHE=STRSIZE /* max length of cache. must be < 32K-BLOCKSIZ…
+ SKIP=50, /* max dist between file changes folded together */
+ MAXCACHE=STRSIZE /* max length of cache. must be < 32K-BLOCKSIZE */
};
void
Fstart(void)
{
- undobuf = Bopen(Dstart());
- snarfbuf = Bopen(Dstart());
- plan9buf = Bopen(Dstart());
+ undobuf = Bopen(Dstart());
+ snarfbuf = Bopen(Dstart());
+ plan9buf = Bopen(Dstart());
}
void
Fmark(File *f, Mod m)
{
- Buffer *t = f->transcript;
- Posn p;
-
- if(f->state == Readerr)
- return;
- if(f->state == Unread) /* this is implicit 'e' of a file */
- return;
- p = m==0? -1 : f->markp;
- f->markp = t->nrunes;
- puthdr_M(t, p, f->dot.r, f->mark, f->mod, f->state);
- f->ndot = f->dot;
- f->marked = TRUE;
- f->mod = m;
- f->hiposn = -1;
- /* Safety first */
- f->cp1 = f->cp2 = 0;
+ Buffer *t = f->transcript;
+ Posn p;
+
+ if(f->state == Readerr)
+ return;
+ if(f->state == Unread) /* this is implicit 'e' of a file */
+ return;
+ p = m==0? -1 : f->markp;
+ f->markp = t->nrunes;
+ puthdr_M(t, p, f->dot.r, f->mark, f->mod, f->state);
+ f->ndot = f->dot;
+ f->marked = TRUE;
+ f->mod = m;
+ f->hiposn = -1;
+ /* Safety first */
+ f->cp1 = f->cp2 = 0;
}
File *
Fopen(void)
{
- File *f;
-
- f = emalloc(sizeof(File));
- if(files[fcount] == 0){
- files[fcount] = Dstart();
- transcripts[fcount] = Dstart();
- }
- f->buf = Bopen(files[fcount]);
- f->transcript = Bopen(transcripts[fcount]);
- if(++fcount == NDISC)
- fcount = 0;
- f->nrunes = 0;
- f->markp = 0;
- f->mod = 0;
- f->dot.f = f;
- f->ndot.f = f;
- f->dev = ~0;
- f->qid = ~0;
- Strinit0(&f->name);
- Strinit(&f->cache);
- f->state = Unread;
- Fmark(f, (Mod)0);
- return f;
+ File *f;
+
+ f = emalloc(sizeof(File));
+ if(files[fcount] == 0){
+ files[fcount] = Dstart();
+ transcripts[fcount] = Dstart();
+ }
+ f->buf = Bopen(files[fcount]);
+ f->transcript = Bopen(transcripts[fcount]);
+ if(++fcount == NDISC)
+ fcount = 0;
+ f->nrunes = 0;
+ f->markp = 0;
+ f->mod = 0;
+ f->dot.f = f;
+ f->ndot.f = f;
+ f->dev = ~0;
+ f->qid = ~0;
+ Strinit0(&f->name);
+ Strinit(&f->cache);
+ f->state = Unread;
+ Fmark(f, (Mod)0);
+ return f;
}
void
Fclose(File *f)
{
- if(f == lastfile)
- lastfile = 0;
- Bterm(f->buf);
- Bterm(f->transcript);
- Strclose(&f->name);
- Strclose(&f->cache);
- if(f->rasp)
- listfree(f->rasp);
- free(f);
+ if(f == lastfile)
+ lastfile = 0;
+ Bterm(f->buf);
+ Bterm(f->transcript);
+ Strclose(&f->name);
+ Strclose(&f->cache);
+ if(f->rasp)
+ listfree(f->rasp);
+ free(f);
}
void
Finsert(File *f, String *str, Posn p1)
{
- Buffer *t = f->transcript;
-
- if(f->state == Readerr)
- return;
- if(str->n == 0)
- return;
- if(str->n<0 || str->n>STRSIZE)
- panic("Finsert");
- if(f->mod < modnum)
- Fmark(f, modnum);
- if(p1 < f->hiposn)
- error(Esequence);
- if(str->n >= BLOCKSIZE){ /* don't bother with the cache */
- Fflush(f);
- puthdr_csl(t, 'i', str->n, p1);
- Binsert(t, str, t->nrunes);
- }else{ /* insert into the cache instead of the transcript */
- if(f->cp2==0 && f->cp1==0 && f->cache.n==0) /* empty ca…
- f->cp1 = f->cp2 = p1;
- if(p1-f->cp2>SKIP || f->cache.n+str->n>MAXCACHE-SKIP){
- Fflush(f);
- f->cp1 = f->cp2 = p1;
- }
- if(f->cp2 != p1){ /* grab the piece in between */
- Rune buf[SKIP];
- String s;
- Fchars(f, buf, f->cp2, p1);
- s.s = buf;
- s.n = p1-f->cp2;
- Strinsert(&f->cache, &s, f->cache.n);
- f->cp2 = p1;
- }
- Strinsert(&f->cache, str, f->cache.n);
- }
- if(f != cmd)
- quitok = FALSE;
- f->closeok = FALSE;
- if(f->state == Clean)
- state(f, Dirty);
- f->hiposn = p1;
+ Buffer *t = f->transcript;
+
+ if(f->state == Readerr)
+ return;
+ if(str->n == 0)
+ return;
+ if(str->n<0 || str->n>STRSIZE)
+ panic("Finsert");
+ if(f->mod < modnum)
+ Fmark(f, modnum);
+ if(p1 < f->hiposn)
+ error(Esequence);
+ if(str->n >= BLOCKSIZE){ /* don't bother with the cache */
+ Fflush(f);
+ puthdr_csl(t, 'i', str->n, p1);
+ Binsert(t, str, t->nrunes);
+ }else{ /* insert into the cache instead of the transcript */
+ if(f->cp2==0 && f->cp1==0 && f->cache.n==0) /* empty cache */
+ f->cp1 = f->cp2 = p1;
+ if(p1-f->cp2>SKIP || f->cache.n+str->n>MAXCACHE-SKIP){
+ Fflush(f);
+ f->cp1 = f->cp2 = p1;
+ }
+ if(f->cp2 != p1){ /* grab the piece in between */
+ Rune buf[SKIP];
+ String s;
+ Fchars(f, buf, f->cp2, p1);
+ s.s = buf;
+ s.n = p1-f->cp2;
+ Strinsert(&f->cache, &s, f->cache.n);
+ f->cp2 = p1;
+ }
+ Strinsert(&f->cache, str, f->cache.n);
+ }
+ if(f != cmd)
+ quitok = FALSE;
+ f->closeok = FALSE;
+ if(f->state == Clean)
+ state(f, Dirty);
+ f->hiposn = p1;
}
void
Fdelete(File *f, Posn p1, Posn p2)
{
- if(f->state == Readerr)
- return;
- if(p1==p2)
- return;
- if(f->mod<modnum)
- Fmark(f, modnum);
- if(p1<f->hiposn)
- error(Esequence);
- if(p1-f->cp2>SKIP)
- Fflush(f);
- if(f->cp2==0 && f->cp1==0 && f->cache.n==0) /* empty cache */
- f->cp1 = f->cp2 = p1;
- if(f->cp2 != p1){ /* grab the piece in between */
- if(f->cache.n+(p1-f->cp2)>MAXCACHE){
- Fflush(f);
- f->cp1 = f->cp2 = p1;
- }else{
- Rune buf[SKIP];
- String s;
- Fchars(f, buf, f->cp2, p1);
- s.s = buf;
- s.n = p1-f->cp2;
- Strinsert(&f->cache, &s, f->cache.n);
- }
- }
- f->cp2 = p2;
- if(f!=cmd)
- quitok = FALSE;
- f->closeok = FALSE;
- if(f->state==Clean)
- state(f, Dirty);
- f->hiposn = p2;
+ if(f->state == Readerr)
+ return;
+ if(p1==p2)
+ return;
+ if(f->mod<modnum)
+ Fmark(f, modnum);
+ if(p1<f->hiposn)
+ error(Esequence);
+ if(p1-f->cp2>SKIP)
+ Fflush(f);
+ if(f->cp2==0 && f->cp1==0 && f->cache.n==0) /* empty cache */
+ f->cp1 = f->cp2 = p1;
+ if(f->cp2 != p1){ /* grab the piece in between */
+ if(f->cache.n+(p1-f->cp2)>MAXCACHE){
+ Fflush(f);
+ f->cp1 = f->cp2 = p1;
+ }else{
+ Rune buf[SKIP];
+ String s;
+ Fchars(f, buf, f->cp2, p1);
+ s.s = buf;
+ s.n = p1-f->cp2;
+ Strinsert(&f->cache, &s, f->cache.n);
+ }
+ }
+ f->cp2 = p2;
+ if(f!=cmd)
+ quitok = FALSE;
+ f->closeok = FALSE;
+ if(f->state==Clean)
+ state(f, Dirty);
+ f->hiposn = p2;
}
void
Fflush(File *f)
{
- Buffer *t = f->transcript;
- Posn p1 = f->cp1, p2 = f->cp2;
-
- if(f->state == Readerr)
- return;
- if(p1 != p2)
- puthdr_cll(t, 'd', p1, p2);
- if(f->cache.n){
- puthdr_csl(t, 'i', f->cache.n, p2);
- Binsert(t, &f->cache, t->nrunes);
- Strzero(&f->cache);
- }
- f->cp1 = f->cp2 = 0;
+ Buffer *t = f->transcript;
+ Posn p1 = f->cp1, p2 = f->cp2;
+
+ if(f->state == Readerr)
+ return;
+ if(p1 != p2)
+ puthdr_cll(t, 'd', p1, p2);
+ if(f->cache.n){
+ puthdr_csl(t, 'i', f->cache.n, p2);
+ Binsert(t, &f->cache, t->nrunes);
+ Strzero(&f->cache);
+ }
+ f->cp1 = f->cp2 = 0;
}
void
Fsetname(File *f, String *s)
{
- Buffer *t = f->transcript;
-
- if(f->state == Readerr)
- return;
- if(f->state == Unread){ /* This is setting initial file name */
- Strduplstr(&f->name, s);
- sortname(f);
- }else{
- if(f->mod < modnum)
- Fmark(f, modnum);
- puthdr_cs(t, 'f', s->n);
- Binsert(t, s, t->nrunes);
- }
+ Buffer *t = f->transcript;
+
+ if(f->state == Readerr)
+ return;
+ if(f->state == Unread){ /* This is setting initial file name */
+ Strduplstr(&f->name, s);
+ sortname(f);
+ }else{
+ if(f->mod < modnum)
+ Fmark(f, modnum);
+ puthdr_cs(t, 'f', s->n);
+ Binsert(t, s, t->nrunes);
+ }
}
/*
@@ -222,244 +222,244 @@ Fsetname(File *f, String *s)
int
Fupdate(File *f, int mktrans, int toterm)
{
- Buffer *t = f->transcript;
- Buffer *u = undobuf;
- int n, ni;
- Posn p0, p1, p2, p, deltadot = 0, deltamark = 0, delta = 0;
- int changes = FALSE;
- union Hdr buf;
- Rune tmp[BLOCKSIZE+1]; /* +1 for NUL in 'f' case */
-
- if(f->state == Readerr)
- return FALSE;
- if(lastfile && f!=lastfile)
- Bclean(lastfile->transcript); /* save memory when multi…
- lastfile = f;
- Fflush(f);
- if(f->marked)
- p0 = f->markp+sizeof(Mark)/RUNESIZE;
- else
- p0 = 0;
- f->dot = f->ndot;
- while((n=Bread(t, (Rune*)&buf, sizeof buf/RUNESIZE, p0)) > 0){
- switch(buf.cs.c){
- default:
- panic("unknown in Fupdate");
- case 'd':
- p1 = buf.cll.l;
- p2 = buf.cll.l1;
- p0 += sizeof(struct _cll)/RUNESIZE;
- if(p2 <= f->dot.r.p1)
- deltadot -= p2-p1;
- if(p2 <= f->mark.p1)
- deltamark -= p2-p1;
- p1 += delta, p2+=delta;
- delta -= p2-p1;
- if(!mktrans)
- for(p = p1; p<p2; p+=ni){
- if(p2-p>BLOCKSIZE)
- ni = BLOCKSIZE;
- else
- ni = p2-p;
- puthdr_csl(u, 'i', ni, p1);
- Bread(f->buf, tmp, ni, p);
- Binsert(u, ftempstr(tmp, ni), u->nrune…
- }
- f->nrunes -= p2-p1;
- Bdelete(f->buf, p1, p2);
- changes = TRUE;
- break;
-
- case 'f':
- n = buf.cs.s;
- p0 += sizeof(struct _cs)/RUNESIZE;
- Strinsure(&genstr, n+1);
- Bread(t, tmp, n, p0);
- tmp[n] = 0;
- p0 += n;
- Strdupl(&genstr, tmp);
- if(!mktrans){
- puthdr_cs(u, 'f', f->name.n);
- Binsert(u, &f->name, u->nrunes);
- }
- Strduplstr(&f->name, &genstr);
- sortname(f);
- changes = TRUE;
- break;
-
- case 'i':
- n = buf.csl.s;
- p1 = buf.csl.l;
- p0 += sizeof(struct _csl)/RUNESIZE;
- if(p1 < f->dot.r.p1)
- deltadot += n;
- if(p1 < f->mark.p1)
- deltamark += n;
- p1 += delta;
- delta += n;
- if(!mktrans)
- puthdr_cll(u, 'd', p1, p1+n);
- changes = TRUE;
- f->nrunes += n;
- while(n > 0){
- if(n > BLOCKSIZE)
- ni = BLOCKSIZE;
- else
- ni = n;
- Bread(t, tmp, ni, p0);
- Binsert(f->buf, ftempstr(tmp, ni), p1);
- n -= ni;
- p1 += ni;
- p0 += ni;
- }
- break;
- }
- }
- toterminal(f, toterm);
- f->dot.r.p1 += deltadot;
- f->dot.r.p2 += deltadot;
- if(f->dot.r.p1 > f->nrunes)
- f->dot.r.p1 = f->nrunes;
- if(f->dot.r.p2 > f->nrunes)
- f->dot.r.p2 = f->nrunes;
- f->mark.p1 += deltamark;
- f->mark.p2 += deltamark;
- if(f->mark.p1 > f->nrunes)
- f->mark.p1 = f->nrunes;
- if(f->mark.p2 > f->nrunes)
- f->mark.p2 = f->nrunes;
- if(n < 0)
- panic("Fupdate read");
- if(f == cmd)
- f->mod = 0; /* can't undo command file */
- if(p0 > f->markp+sizeof(Posn)/RUNESIZE){ /* for undo, this thro…
- if(f->mod > 0){ /* can't undo the dawn of time */
- Bdelete(t, f->markp+sizeof(Mark)/RUNESIZE, t->nrunes);
- /* copy the undo list back into the transcript */
- for(p = 0; p<u->nrunes; p+=ni){
- if(u->nrunes-p>BLOCKSIZE)
- ni = BLOCKSIZE;
- else
- ni = u->nrunes-p;
- Bread(u, tmp, ni, p);
- Binsert(t, ftempstr(tmp, ni), t->nrunes);
- }
- }
- Bdelete(u, (Posn)0, u->nrunes);
- }
- return f==cmd? FALSE : changes;
+ Buffer *t = f->transcript;
+ Buffer *u = undobuf;
+ int n, ni;
+ Posn p0, p1, p2, p, deltadot = 0, deltamark = 0, delta = 0;
+ int changes = FALSE;
+ union Hdr buf;
+ Rune tmp[BLOCKSIZE+1]; /* +1 for NUL in 'f' case */
+
+ if(f->state == Readerr)
+ return FALSE;
+ if(lastfile && f!=lastfile)
+ Bclean(lastfile->transcript); /* save memory when multifile */
+ lastfile = f;
+ Fflush(f);
+ if(f->marked)
+ p0 = f->markp+sizeof(Mark)/RUNESIZE;
+ else
+ p0 = 0;
+ f->dot = f->ndot;
+ while((n=Bread(t, (Rune*)&buf, sizeof buf/RUNESIZE, p0)) > 0){
+ switch(buf.cs.c){
+ default:
+ panic("unknown in Fupdate");
+ case 'd':
+ p1 = buf.cll.l;
+ p2 = buf.cll.l1;
+ p0 += sizeof(struct _cll)/RUNESIZE;
+ if(p2 <= f->dot.r.p1)
+ deltadot -= p2-p1;
+ if(p2 <= f->mark.p1)
+ deltamark -= p2-p1;
+ p1 += delta, p2+=delta;
+ delta -= p2-p1;
+ if(!mktrans)
+ for(p = p1; p<p2; p+=ni){
+ if(p2-p>BLOCKSIZE)
+ ni = BLOCKSIZE;
+ else
+ ni = p2-p;
+ puthdr_csl(u, 'i', ni, p1);
+ Bread(f->buf, tmp, ni, p);
+ Binsert(u, ftempstr(tmp, ni), u->nrunes);
+ }
+ f->nrunes -= p2-p1;
+ Bdelete(f->buf, p1, p2);
+ changes = TRUE;
+ break;
+
+ case 'f':
+ n = buf.cs.s;
+ p0 += sizeof(struct _cs)/RUNESIZE;
+ Strinsure(&genstr, n+1);
+ Bread(t, tmp, n, p0);
+ tmp[n] = 0;
+ p0 += n;
+ Strdupl(&genstr, tmp);
+ if(!mktrans){
+ puthdr_cs(u, 'f', f->name.n);
+ Binsert(u, &f->name, u->nrunes);
+ }
+ Strduplstr(&f->name, &genstr);
+ sortname(f);
+ changes = TRUE;
+ break;
+
+ case 'i':
+ n = buf.csl.s;
+ p1 = buf.csl.l;
+ p0 += sizeof(struct _csl)/RUNESIZE;
+ if(p1 < f->dot.r.p1)
+ deltadot += n;
+ if(p1 < f->mark.p1)
+ deltamark += n;
+ p1 += delta;
+ delta += n;
+ if(!mktrans)
+ puthdr_cll(u, 'd', p1, p1+n);
+ changes = TRUE;
+ f->nrunes += n;
+ while(n > 0){
+ if(n > BLOCKSIZE)
+ ni = BLOCKSIZE;
+ else
+ ni = n;
+ Bread(t, tmp, ni, p0);
+ Binsert(f->buf, ftempstr(tmp, ni), p1);
+ n -= ni;
+ p1 += ni;
+ p0 += ni;
+ }
+ break;
+ }
+ }
+ toterminal(f, toterm);
+ f->dot.r.p1 += deltadot;
+ f->dot.r.p2 += deltadot;
+ if(f->dot.r.p1 > f->nrunes)
+ f->dot.r.p1 = f->nrunes;
+ if(f->dot.r.p2 > f->nrunes)
+ f->dot.r.p2 = f->nrunes;
+ f->mark.p1 += deltamark;
+ f->mark.p2 += deltamark;
+ if(f->mark.p1 > f->nrunes)
+ f->mark.p1 = f->nrunes;
+ if(f->mark.p2 > f->nrunes)
+ f->mark.p2 = f->nrunes;
+ if(n < 0)
+ panic("Fupdate read");
+ if(f == cmd)
+ f->mod = 0; /* can't undo command file */
+ if(p0 > f->markp+sizeof(Posn)/RUNESIZE){ /* for undo, this throws away …
+ if(f->mod > 0){ /* can't undo the dawn of time */
+ Bdelete(t, f->markp+sizeof(Mark)/RUNESIZE, t->nrunes);
+ /* copy the undo list back into the transcript */
+ for(p = 0; p<u->nrunes; p+=ni){
+ if(u->nrunes-p>BLOCKSIZE)
+ ni = BLOCKSIZE;
+ else
+ ni = u->nrunes-p;
+ Bread(u, tmp, ni, p);
+ Binsert(t, ftempstr(tmp, ni), t->nrunes);
+ }
+ }
+ Bdelete(u, (Posn)0, u->nrunes);
+ }
+ return f==cmd? FALSE : changes;
}
void
puthdr_csl(Buffer *b, char c, short s, Posn p)
{
- struct _csl buf;
-
- if(p < 0)
- panic("puthdr_csP");
- buf.c = c;
- buf.s = s;
- buf.l = p;
- Binsert(b, ftempstr((Rune*)&buf, sizeof buf/RUNESIZE), b->nrunes);
+ struct _csl buf;
+
+ if(p < 0)
+ panic("puthdr_csP");
+ buf.c = c;
+ buf.s = s;
+ buf.l = p;
+ Binsert(b, ftempstr((Rune*)&buf, sizeof buf/RUNESIZE), b->nrunes);
}
void
puthdr_cs(Buffer *b, char c, short s)
{
- struct _cs buf;
+ struct _cs buf;
- buf.c = c;
- buf.s = s;
- Binsert(b, ftempstr((Rune*)&buf, sizeof buf/RUNESIZE), b->nrunes);
+ buf.c = c;
+ buf.s = s;
+ Binsert(b, ftempstr((Rune*)&buf, sizeof buf/RUNESIZE), b->nrunes);
}
void
puthdr_M(Buffer *b, Posn p, Range dot, Range mk, Mod m, short s1)
{
- Mark mark;
- static int first = 1;
-
- if(!first && p<0)
- panic("puthdr_M");
- mark.p = p;
- mark.dot = dot;
- mark.mark = mk;
- mark.m = m;
- mark.s1 = s1;
- Binsert(b, ftempstr((Rune *)&mark, sizeof mark/RUNESIZE), b->nrunes);
+ Mark mark;
+ static int first = 1;
+
+ if(!first && p<0)
+ panic("puthdr_M");
+ mark.p = p;
+ mark.dot = dot;
+ mark.mark = mk;
+ mark.m = m;
+ mark.s1 = s1;
+ Binsert(b, ftempstr((Rune *)&mark, sizeof mark/RUNESIZE), b->nrunes);
}
void
puthdr_cll(Buffer *b, char c, Posn p1, Posn p2)
{
- struct _cll buf;
-
- if(p1<0 || p2<0)
- panic("puthdr_cll");
- buf.c = c;
- buf.l = p1;
- buf.l1 = p2;
- Binsert(b, ftempstr((Rune*)&buf, sizeof buf/RUNESIZE), b->nrunes);
+ struct _cll buf;
+
+ if(p1<0 || p2<0)
+ panic("puthdr_cll");
+ buf.c = c;
+ buf.l = p1;
+ buf.l1 = p2;
+ Binsert(b, ftempstr((Rune*)&buf, sizeof buf/RUNESIZE), b->nrunes);
}
long
Fchars(File *f, Rune *addr, Posn p1, Posn p2)
{
- return Bread(f->buf, addr, p2-p1, p1);
+ return Bread(f->buf, addr, p2-p1, p1);
}
int
Fgetcset(File *f, Posn p)
{
- if(p<0 || p>f->nrunes)
- panic("Fgetcset out of range");
- if((f->ngetc = Fchars(f, f->getcbuf, p, p+NGETC))<0)
- panic("Fgetcset Bread fail");
- f->getcp = p;
- f->getci = 0;
- return f->ngetc;
+ if(p<0 || p>f->nrunes)
+ panic("Fgetcset out of range");
+ if((f->ngetc = Fchars(f, f->getcbuf, p, p+NGETC))<0)
+ panic("Fgetcset Bread fail");
+ f->getcp = p;
+ f->getci = 0;
+ return f->ngetc;
}
int
Fbgetcset(File *f, Posn p)
{
- if(p<0 || p>f->nrunes)
- panic("Fbgetcset out of range");
- if((f->ngetc = Fchars(f, f->getcbuf, p<NGETC? (Posn)0 : p-NGETC, p))<0)
- panic("Fbgetcset Bread fail");
- f->getcp = p;
- f->getci = f->ngetc;
- return f->ngetc;
+ if(p<0 || p>f->nrunes)
+ panic("Fbgetcset out of range");
+ if((f->ngetc = Fchars(f, f->getcbuf, p<NGETC? (Posn)0 : p-NGETC, p))<0)
+ panic("Fbgetcset Bread fail");
+ f->getcp = p;
+ f->getci = f->ngetc;
+ return f->ngetc;
}
int
Fgetcload(File *f, Posn p)
{
- if(Fgetcset(f, p)){
- --f->ngetc;
- f->getcp++;
- return f->getcbuf[f->getci++];
- }
- return -1;
+ if(Fgetcset(f, p)){
+ --f->ngetc;
+ f->getcp++;
+ return f->getcbuf[f->getci++];
+ }
+ return -1;
}
int
Fbgetcload(File *f, Posn p)
{
- if(Fbgetcset(f, p)){
- --f->getcp;
- return f->getcbuf[--f->getci];
- }
- return -1;
+ if(Fbgetcset(f, p)){
+ --f->getcp;
+ return f->getcbuf[--f->getci];
+ }
+ return -1;
}
static String*
ftempstr(Rune *s, int n)
{
- static String p;
+ static String p;
- p.s = s;
- p.n = n;
- p.size = n;
- return &p;
+ p.s = s;
+ p.n = n;
+ p.size = n;
+ return &p;
}
diff --git a/sam/io.c b/sam/io.c
@@ -1,257 +1,257 @@
/* Copyright (c) 1998 Lucent Technologies - All rights reserved. */
#include "sam.h"
-#define NSYSFILE 3
-#define NOFILE 128
+#define NSYSFILE 3
+#define NOFILE 128
void
checkqid(File *f)
{
- int i, w;
- File *g;
+ int i, w;
+ File *g;
- w = whichmenu(f);
- for(i=1; i<file.nused; i++){
- g = file.filepptr[i];
- if(w == i)
- continue;
- if(f->dev==g->dev && f->qid==g->qid)
- warn_SS(Wdupfile, &f->name, &g->name);
- }
+ w = whichmenu(f);
+ for(i=1; i<file.nused; i++){
+ g = file.filepptr[i];
+ if(w == i)
+ continue;
+ if(f->dev==g->dev && f->qid==g->qid)
+ warn_SS(Wdupfile, &f->name, &g->name);
+ }
}
void
writef(File *f)
{
- Rune c;
- Posn n;
- char *name;
- int i, samename, newfile;
- ulong dev, qid;
- long mtime, appendonly, length;
+ Rune c;
+ Posn n;
+ char *name;
+ int i, samename, newfile;
+ ulong dev, qid;
+ long mtime, appendonly, length;
- newfile = 0;
- samename = Strcmp(&genstr, &f->name) == 0;
- name = Strtoc(&f->name);
- i = statfile(name, &dev, &qid, &mtime, 0, 0);
- if(i == -1)
- newfile++;
- else if(samename &&
- (f->dev!=dev || f->qid!=qid || f->date<mtime)){
- f->dev = dev;
- f->qid = qid;
- f->date = mtime;
- warn_S(Wdate, &genstr);
- return;
- }
- if(genc)
- free(genc);
- genc = Strtoc(&genstr);
- if((io=create(genc, 1, 0666L)) < 0)
- error_s(Ecreate, genc);
- dprint("%s: ", genc);
- if(statfd(io, 0, 0, 0, &length, &appendonly) > 0 && appendonly && leng…
- error(Eappend);
- n = writeio(f);
- if(f->name.s[0]==0 || samename)
- state(f, addr.r.p1==0 && addr.r.p2==f->nrunes? Clean : Dirty);
- if(newfile)
- dprint("(new file) ");
- if(addr.r.p2>0 && Fchars(f, &c, addr.r.p2-1, addr.r.p2) && c!='\n')
- warn(Wnotnewline);
- closeio(n);
- if(f->name.s[0]==0 || samename){
- if(statfile(name, &dev, &qid, &mtime, 0, 0) > 0){
- f->dev = dev;
- f->qid = qid;
- f->date = mtime;
- checkqid(f);
- }
- }
+ newfile = 0;
+ samename = Strcmp(&genstr, &f->name) == 0;
+ name = Strtoc(&f->name);
+ i = statfile(name, &dev, &qid, &mtime, 0, 0);
+ if(i == -1)
+ newfile++;
+ else if(samename &&
+ (f->dev!=dev || f->qid!=qid || f->date<mtime)){
+ f->dev = dev;
+ f->qid = qid;
+ f->date = mtime;
+ warn_S(Wdate, &genstr);
+ return;
+ }
+ if(genc)
+ free(genc);
+ genc = Strtoc(&genstr);
+ if((io=create(genc, 1, 0666L)) < 0)
+ error_s(Ecreate, genc);
+ dprint("%s: ", genc);
+ if(statfd(io, 0, 0, 0, &length, &appendonly) > 0 && appendonly && length>0)
+ error(Eappend);
+ n = writeio(f);
+ if(f->name.s[0]==0 || samename)
+ state(f, addr.r.p1==0 && addr.r.p2==f->nrunes? Clean : Dirty);
+ if(newfile)
+ dprint("(new file) ");
+ if(addr.r.p2>0 && Fchars(f, &c, addr.r.p2-1, addr.r.p2) && c!='\n')
+ warn(Wnotnewline);
+ closeio(n);
+ if(f->name.s[0]==0 || samename){
+ if(statfile(name, &dev, &qid, &mtime, 0, 0) > 0){
+ f->dev = dev;
+ f->qid = qid;
+ f->date = mtime;
+ checkqid(f);
+ }
+ }
}
Posn
readio(File *f, int *nulls, int setdate)
{
- int n, b, w;
- Rune *r;
- Posn nt;
- Posn p = addr.r.p2;
- ulong dev, qid;
- long mtime;
- char buf[BLOCKSIZE+1], *s;
+ int n, b, w;
+ Rune *r;
+ Posn nt;
+ Posn p = addr.r.p2;
+ ulong dev, qid;
+ long mtime;
+ char buf[BLOCKSIZE+1], *s;
- *nulls = FALSE;
- b = 0;
- for(nt = 0; (n = read(io, buf+b, BLOCKSIZE-b))>0; nt+=(r-genbuf)){
- n += b;
- b = 0;
- r = genbuf;
- s = buf;
- while(n > 0){
- if((*r = *(uchar*)s) < Runeself){
- if(*r)
- r++;
- else
- *nulls = TRUE;
- --n;
- s++;
- continue;
- }
- if(fullrune(s, n)){
- w = chartorune(r, s);
- if(*r)
- r++;
- else
- *nulls = TRUE;
- n -= w;
- s += w;
- continue;
- }
- b = n;
- memmove(buf, s, b);
- break;
- }
- Finsert(f, tmprstr(genbuf, r-genbuf), p);
- }
- if(b)
- *nulls = TRUE;
- if(*nulls)
- warn(Wnulls);
- if(setdate){
- if(statfd(io, &dev, &qid, &mtime, 0, 0) > 0){
- f->dev = dev;
- f->qid = qid;
- f->date = mtime;
- checkqid(f);
- }
- }
- return nt;
+ *nulls = FALSE;
+ b = 0;
+ for(nt = 0; (n = read(io, buf+b, BLOCKSIZE-b))>0; nt+=(r-genbuf)){
+ n += b;
+ b = 0;
+ r = genbuf;
+ s = buf;
+ while(n > 0){
+ if((*r = *(uchar*)s) < Runeself){
+ if(*r)
+ r++;
+ else
+ *nulls = TRUE;
+ --n;
+ s++;
+ continue;
+ }
+ if(fullrune(s, n)){
+ w = chartorune(r, s);
+ if(*r)
+ r++;
+ else
+ *nulls = TRUE;
+ n -= w;
+ s += w;
+ continue;
+ }
+ b = n;
+ memmove(buf, s, b);
+ break;
+ }
+ Finsert(f, tmprstr(genbuf, r-genbuf), p);
+ }
+ if(b)
+ *nulls = TRUE;
+ if(*nulls)
+ warn(Wnulls);
+ if(setdate){
+ if(statfd(io, &dev, &qid, &mtime, 0, 0) > 0){
+ f->dev = dev;
+ f->qid = qid;
+ f->date = mtime;
+ checkqid(f);
+ }
+ }
+ return nt;
}
Posn
writeio(File *f)
{
- int m, n;
- Posn p = addr.r.p1;
- char *c;
+ int m, n;
+ Posn p = addr.r.p1;
+ char *c;
- while(p < addr.r.p2){
- if(addr.r.p2-p>BLOCKSIZE)
- n = BLOCKSIZE;
- else
- n = addr.r.p2-p;
- if(Fchars(f, genbuf, p, p+n)!=n)
- panic("writef read");
- c = Strtoc(tmprstr(genbuf, n));
- m = strlen(c);
- if (m < n)
- panic("corrupted file");
- if(Write(io, c, m) != m){
- free(c);
- if(p > 0)
- p += n;
- break;
- }
- free(c);
- p += n;
- }
- return p-addr.r.p1;
+ while(p < addr.r.p2){
+ if(addr.r.p2-p>BLOCKSIZE)
+ n = BLOCKSIZE;
+ else
+ n = addr.r.p2-p;
+ if(Fchars(f, genbuf, p, p+n)!=n)
+ panic("writef read");
+ c = Strtoc(tmprstr(genbuf, n));
+ m = strlen(c);
+ if (m < n)
+ panic("corrupted file");
+ if(Write(io, c, m) != m){
+ free(c);
+ if(p > 0)
+ p += n;
+ break;
+ }
+ free(c);
+ p += n;
+ }
+ return p-addr.r.p1;
}
void
closeio(Posn p)
{
- close(io);
- io = 0;
- if(p >= 0)
- dprint("#%lu\n", p);
+ close(io);
+ io = 0;
+ if(p >= 0)
+ dprint("#%lu\n", p);
}
-int remotefd0 = 0;
-int remotefd1 = 1;
+int remotefd0 = 0;
+int remotefd1 = 1;
void
bootterm(char *machine, char **argv, char **end)
{
- int ph2t[2], pt2h[2];
+ int ph2t[2], pt2h[2];
- if(machine){
- dup(remotefd0, 0);
- dup(remotefd1, 1);
- close(remotefd0);
- close(remotefd1);
- argv[0] = "samterm";
- *end = 0;
- execvp(samterm, argv);
- fprintf(stderr, "can't exec: ");
- perror(samterm);
- _exits("damn");
- }
- if(pipe(ph2t)==-1 || pipe(pt2h)==-1)
- panic("pipe");
- switch(fork()){
- case 0:
- dup(ph2t[0], 0);
- dup(pt2h[1], 1);
- close(ph2t[0]);
- close(ph2t[1]);
- close(pt2h[0]);
- close(pt2h[1]);
- argv[0] = "samterm";
- *end = 0;
- execvp(samterm, argv);
- fprintf(stderr, "can't exec: ");
- perror(samterm);
- _exits("damn");
- case -1:
- panic("can't fork samterm");
- }
- dup(pt2h[0], 0);
- dup(ph2t[1], 1);
- close(ph2t[0]);
- close(ph2t[1]);
- close(pt2h[0]);
- close(pt2h[1]);
+ if(machine){
+ dup(remotefd0, 0);
+ dup(remotefd1, 1);
+ close(remotefd0);
+ close(remotefd1);
+ argv[0] = "samterm";
+ *end = 0;
+ execvp(samterm, argv);
+ fprintf(stderr, "can't exec: ");
+ perror(samterm);
+ _exits("damn");
+ }
+ if(pipe(ph2t)==-1 || pipe(pt2h)==-1)
+ panic("pipe");
+ switch(fork()){
+ case 0:
+ dup(ph2t[0], 0);
+ dup(pt2h[1], 1);
+ close(ph2t[0]);
+ close(ph2t[1]);
+ close(pt2h[0]);
+ close(pt2h[1]);
+ argv[0] = "samterm";
+ *end = 0;
+ execvp(samterm, argv);
+ fprintf(stderr, "can't exec: ");
+ perror(samterm);
+ _exits("damn");
+ case -1:
+ panic("can't fork samterm");
+ }
+ dup(pt2h[0], 0);
+ dup(ph2t[1], 1);
+ close(ph2t[0]);
+ close(ph2t[1]);
+ close(pt2h[0]);
+ close(pt2h[1]);
}
void
connectto(char *machine)
{
- int p1[2], p2[2];
+ int p1[2], p2[2];
- if(pipe(p1)<0 || pipe(p2)<0){
- dprint("can't pipe\n");
- exits("pipe");
- }
- remotefd0 = p1[0];
- remotefd1 = p2[1];
- switch(fork()){
- case 0:
- dup(p2[0], 0);
- dup(p1[1], 1);
- close(p1[0]);
- close(p1[1]);
- close(p2[0]);
- close(p2[1]);
- execlp(getenv("RSH") ? getenv("RSH") : RXPATH, getenv("RSH") ?…
- dprint("can't exec %s\n", RXPATH);
- exits("exec");
+ if(pipe(p1)<0 || pipe(p2)<0){
+ dprint("can't pipe\n");
+ exits("pipe");
+ }
+ remotefd0 = p1[0];
+ remotefd1 = p2[1];
+ switch(fork()){
+ case 0:
+ dup(p2[0], 0);
+ dup(p1[1], 1);
+ close(p1[0]);
+ close(p1[1]);
+ close(p2[0]);
+ close(p2[1]);
+ execlp(getenv("RSH") ? getenv("RSH") : RXPATH, getenv("RSH") ? getenv(…
+ dprint("can't exec %s\n", RXPATH);
+ exits("exec");
- case -1:
- dprint("can't fork\n");
- exits("fork");
- }
- close(p1[1]);
- close(p2[0]);
+ case -1:
+ dprint("can't fork\n");
+ exits("fork");
+ }
+ close(p1[1]);
+ close(p2[0]);
}
void
startup(char *machine, int Rflag, char **arg, char **end)
{
- if(machine)
- connectto(machine);
- if(!Rflag)
- bootterm(machine, arg, end);
- downloaded = 1;
- outTs(Hversion, VERSION);
+ if(machine)
+ connectto(machine);
+ if(!Rflag)
+ bootterm(machine, arg, end);
+ downloaded = 1;
+ outTs(Hversion, VERSION);
}
diff --git a/sam/list.c b/sam/list.c
@@ -7,15 +7,15 @@
void
growlist(List *l)
{
- if(l->listptr==0 || l->nalloc==0){
- l->nalloc = INCR;
- l->listptr = emalloc(INCR*sizeof(long));
- l->nused = 0;
- }else if(l->nused == l->nalloc){
- l->listptr = erealloc(l->listptr, (l->nalloc+INCR)*sizeof(long…
- memset((void*)(l->longptr+l->nalloc), 0, INCR*sizeof(long));
- l->nalloc += INCR;
- }
+ if(l->listptr==0 || l->nalloc==0){
+ l->nalloc = INCR;
+ l->listptr = emalloc(INCR*sizeof(long));
+ l->nused = 0;
+ }else if(l->nused == l->nalloc){
+ l->listptr = erealloc(l->listptr, (l->nalloc+INCR)*sizeof(long));
+ memset((void*)(l->longptr+l->nalloc), 0, INCR*sizeof(long));
+ l->nalloc += INCR;
+ }
}
/*
@@ -24,8 +24,8 @@ growlist(List *l)
void
dellist(List *l, int i)
{
- memmove(&l->longptr[i], &l->longptr[i+1], (l->nused-(i+1))*sizeof(long…
- l->nused--;
+ memmove(&l->longptr[i], &l->longptr[i+1], (l->nused-(i+1))*sizeof(long));
+ l->nused--;
}
/*
@@ -34,15 +34,15 @@ dellist(List *l, int i)
void
inslist(List *l, int i, long val)
{
- growlist(l);
- memmove(&l->longptr[i+1], &l->longptr[i], (l->nused-i)*sizeof(long));
- l->longptr[i] = val;
- l->nused++;
+ growlist(l);
+ memmove(&l->longptr[i+1], &l->longptr[i], (l->nused-i)*sizeof(long));
+ l->longptr[i] = val;
+ l->nused++;
}
void
listfree(List *l)
{
- free(l->listptr);
- free(l);
+ free(l->listptr);
+ free(l);
}
diff --git a/sam/mesg.c b/sam/mesg.c
@@ -2,24 +2,24 @@
#include "sam.h"
#include "../config.h"
-Header h;
-uchar indata[DATASIZE];
-uchar outdata[2*DATASIZE+3]; /* room for overflow message */
-uchar *inp;
-uchar *outp;
-uchar *outmsg = outdata;
-Posn cmdpt;
-Posn cmdptadv;
-Buffer *snarfbuf;
-int waitack;
-int noflush;
-int tversion;
-
-long inlong(void);
-long invlong(void);
-int inshort(void);
-int inmesg(Tmesg);
-void setgenstr(File*, Posn, Posn);
+Header h;
+uchar indata[DATASIZE];
+uchar outdata[2*DATASIZE+3]; /* room for overflow message */
+uchar *inp;
+uchar *outp;
+uchar *outmsg = outdata;
+Posn cmdpt;
+Posn cmdptadv;
+Buffer *snarfbuf;
+int waitack;
+int noflush;
+int tversion;
+
+long inlong(void);
+long invlong(void);
+int inshort(void);
+int inmesg(Tmesg);
+void setgenstr(File*, Posn, Posn);
#ifdef CLASSIC_SAM_COMPATIBILITY
int oldcompat = 1;
@@ -29,747 +29,747 @@ int oldcompat = 0;
#ifdef DEBUG
char *hname[] = {
- [Hversion] "Hversion",
- [Hbindname] "Hbindname",
- [Hcurrent] "Hcurrent",
- [Hnewname] "Hnewname",
- [Hmovname] "Hmovname",
- [Hgrow] "Hgrow",
- [Hcheck0] "Hcheck0",
- [Hcheck] "Hcheck",
- [Hunlock] "Hunlock",
- [Hdata] "Hdata",
- [Horigin] "Horigin",
- [Hunlockfile] "Hunlockfile",
- [Hsetdot] "Hsetdot",
- [Hgrowdata] "Hgrowdata",
- [Hmoveto] "Hmoveto",
- [Hclean] "Hclean",
- [Hdirty] "Hdirty",
- [Hcut] "Hcut",
- [Hsetpat] "Hsetpat",
- [Hdelname] "Hdelname",
- [Hclose] "Hclose",
- [Hsetsnarf] "Hsetsnarf",
- [Hsnarflen] "Hsnarflen",
- [Hack] "Hack",
- [Hextcmd] "Hextcmd",
- [Hexit] "Hexit",
+ [Hversion] "Hversion",
+ [Hbindname] "Hbindname",
+ [Hcurrent] "Hcurrent",
+ [Hnewname] "Hnewname",
+ [Hmovname] "Hmovname",
+ [Hgrow] "Hgrow",
+ [Hcheck0] "Hcheck0",
+ [Hcheck] "Hcheck",
+ [Hunlock] "Hunlock",
+ [Hdata] "Hdata",
+ [Horigin] "Horigin",
+ [Hunlockfile] "Hunlockfile",
+ [Hsetdot] "Hsetdot",
+ [Hgrowdata] "Hgrowdata",
+ [Hmoveto] "Hmoveto",
+ [Hclean] "Hclean",
+ [Hdirty] "Hdirty",
+ [Hcut] "Hcut",
+ [Hsetpat] "Hsetpat",
+ [Hdelname] "Hdelname",
+ [Hclose] "Hclose",
+ [Hsetsnarf] "Hsetsnarf",
+ [Hsnarflen] "Hsnarflen",
+ [Hack] "Hack",
+ [Hextcmd] "Hextcmd",
+ [Hexit] "Hexit",
};
char *tname[] = {
- [Tversion] "Tversion",
- [Tstartcmdfile] "Tstartcmdfile",
- [Tcheck] "Tcheck",
- [Trequest] "Trequest",
- [Torigin] "Torigin",
- [Tstartfile] "Tstartfile",
- [Tworkfile] "Tworkfile",
- [Ttype] "Ttype",
- [Tcut] "Tcut",
- [Tpaste] "Tpaste",
- [Tsnarf] "Tsnarf",
- [Tstartnewfile] "Tstartnewfile",
- [Twrite] "Twrite",
- [Tclose] "Tclose",
- [Tlook] "Tlook",
- [Tsearch] "Tsearch",
- [Tsend] "Tsend",
- [Tdclick] "Tdclick",
- [Tstartsnarf] "Tstartsnarf",
- [Tsetsnarf] "Tsetsnarf",
- [Tack] "Tack",
- [Texit] "Texit",
+ [Tversion] "Tversion",
+ [Tstartcmdfile] "Tstartcmdfile",
+ [Tcheck] "Tcheck",
+ [Trequest] "Trequest",
+ [Torigin] "Torigin",
+ [Tstartfile] "Tstartfile",
+ [Tworkfile] "Tworkfile",
+ [Ttype] "Ttype",
+ [Tcut] "Tcut",
+ [Tpaste] "Tpaste",
+ [Tsnarf] "Tsnarf",
+ [Tstartnewfile] "Tstartnewfile",
+ [Twrite] "Twrite",
+ [Tclose] "Tclose",
+ [Tlook] "Tlook",
+ [Tsearch] "Tsearch",
+ [Tsend] "Tsend",
+ [Tdclick] "Tdclick",
+ [Tstartsnarf] "Tstartsnarf",
+ [Tsetsnarf] "Tsetsnarf",
+ [Tack] "Tack",
+ [Texit] "Texit",
};
void
journal(int out, char *s)
{
- static int fd = 0;
+ static int fd = 0;
- if(fd <= 0)
- fd = create("/tmp/sam.out", 1, 0666L);
- dprintf(fd, "%s%s\n", out? "out: " : "in: ", s);
+ if(fd <= 0)
+ fd = create("/tmp/sam.out", 1, 0666L);
+ dprintf(fd, "%s%s\n", out? "out: " : "in: ", s);
}
void
journaln(int out, long n)
{
- char buf[32];
- sprint(buf, sizeof (long) > 4 ? "%ld" : "%d", n);
- journal(out, buf);
+ char buf[32];
+ sprint(buf, sizeof (long) > 4 ? "%ld" : "%d", n);
+ journal(out, buf);
}
#else
-#define journal(a, b)
+#define journal(a, b)
#define journaln(a, b)
#endif
int
rcvchar(void){
- static uchar buf[64];
- static int i, nleft = 0;
-
- if(nleft <= 0){
- nleft = read(0, (char *)buf, sizeof buf);
- if(nleft <= 0)
- return -1;
- i = 0;
- }
- --nleft;
- return buf[i++];
+ static uchar buf[64];
+ static int i, nleft = 0;
+
+ if(nleft <= 0){
+ nleft = read(0, (char *)buf, sizeof buf);
+ if(nleft <= 0)
+ return -1;
+ i = 0;
+ }
+ --nleft;
+ return buf[i++];
}
int
rcv(void){
- int c;
- static int state = 0;
- static int count = 0;
- static int i = 0;
-
- while((c=rcvchar()) != -1)
- switch(state){
- case 0:
- h.type = c;
- state++;
- break;
-
- case 1:
- h.count0 = c;
- state++;
- break;
-
- case 2:
- h.count1 = c;
- count = h.count0|(h.count1<<8);
- i = 0;
- if(count > DATASIZE)
- panic("count>DATASIZE");
- if(count == 0)
- goto zerocount;
- state++;
- break;
-
- case 3:
- indata[i++] = c;
- if(i == count){
- zerocount:
- indata[i] = 0;
- state = count = 0;
- return inmesg(h.type);
- }
- break;
- }
- return 0;
+ int c;
+ static int state = 0;
+ static int count = 0;
+ static int i = 0;
+
+ while((c=rcvchar()) != -1)
+ switch(state){
+ case 0:
+ h.type = c;
+ state++;
+ break;
+
+ case 1:
+ h.count0 = c;
+ state++;
+ break;
+
+ case 2:
+ h.count1 = c;
+ count = h.count0|(h.count1<<8);
+ i = 0;
+ if(count > DATASIZE)
+ panic("count>DATASIZE");
+ if(count == 0)
+ goto zerocount;
+ state++;
+ break;
+
+ case 3:
+ indata[i++] = c;
+ if(i == count){
+ zerocount:
+ indata[i] = 0;
+ state = count = 0;
+ return inmesg(h.type);
+ }
+ break;
+ }
+ return 0;
}
File *
whichfile(int tag)
{
- int i;
+ int i;
- for(i = 0; i<file.nused; i++)
- if(file.filepptr[i]->tag==tag)
- return file.filepptr[i];
- hiccough((char *)0);
- return 0;
+ for(i = 0; i<file.nused; i++)
+ if(file.filepptr[i]->tag==tag)
+ return file.filepptr[i];
+ hiccough((char *)0);
+ return 0;
}
int
inmesg(Tmesg type)
{
- Rune buf[1025];
- int i, m;
- short s;
- long l, l1, l2;
- File *f;
- Posn p0, p1;
- Range r;
- String *str;
- char *c;
- Rune *rp;
-
- if(type > TMAX)
- panic("inmesg");
-
- journal(0, tname[type]);
-
- inp = indata;
- switch(type){
- case -1:
- panic("rcv error");
-
- default:
- fprintf(stderr, "unknown type %d\n", type);
- panic("rcv unknown");
-
- case Tversion:
- tversion = inshort();
- journaln(0, tversion);
- break;
-
- case Tstartcmdfile:
- l = invlong(); /* for 64-bit pointers */
- journaln(0, l);
- Strdupl(&genstr, samname);
- cmd = newfile();
- outTsv(Hbindname, cmd->tag, l);
- outTs(Hcurrent, cmd->tag);
- Fsetname(cmd, &genstr);
- cmd->rasp = emalloc(sizeof(List));
- cmd->state = Clean;
- if(cmdstr.n){
- Finsert(cmd, &cmdstr, 0L);
- Strdelete(&cmdstr, 0L, (Posn)cmdstr.n);
- }
- Fupdate(cmd, FALSE, TRUE);
- outT0(Hunlock);
- break;
-
- case Tcheck:
- /* go through whichfile to check the tag */
- outTs(Hcheck, whichfile(inshort())->tag);
- break;
-
- case Trequest:
- f = whichfile(inshort());
- p0 = inlong();
- p1 = p0+inshort();
- journaln(0, p0);
- journaln(0, p1-p0);
- if(f->state == Unread)
- panic("Trequest: unread");
- if(p1>f->nrunes)
- p1 = f->nrunes;
- if(p0>f->nrunes) /* can happen e.g. scrolling during command */
- p0 = f->nrunes;
- if(p0 == p1){
- i = 0;
- r.p1 = r.p2 = p0;
- }else{
- r = rdata(f->rasp, p0, p1-p0);
- i = r.p2-r.p1;
- if(Fchars(f, buf, r.p1, r.p2)!=i)
- panic("Trequest 2");
- }
- buf[i]=0;
- outTslS(Hdata, f->tag, r.p1, tmprstr(buf, i+1));
- break;
-
- case Torigin:
- s = inshort(); /* tag */
- l = inlong(); /* position */
- l1 = inlong(); /* lines to seek past position */
+ Rune buf[1025];
+ int i, m;
+ short s;
+ long l, l1, l2;
+ File *f;
+ Posn p0, p1;
+ Range r;
+ String *str;
+ char *c;
+ Rune *rp;
+
+ if(type > TMAX)
+ panic("inmesg");
+
+ journal(0, tname[type]);
+
+ inp = indata;
+ switch(type){
+ case -1:
+ panic("rcv error");
+
+ default:
+ fprintf(stderr, "unknown type %d\n", type);
+ panic("rcv unknown");
+
+ case Tversion:
+ tversion = inshort();
+ journaln(0, tversion);
+ break;
+
+ case Tstartcmdfile:
+ l = invlong(); /* for 64-bit pointers */
+ journaln(0, l);
+ Strdupl(&genstr, samname);
+ cmd = newfile();
+ outTsv(Hbindname, cmd->tag, l);
+ outTs(Hcurrent, cmd->tag);
+ Fsetname(cmd, &genstr);
+ cmd->rasp = emalloc(sizeof(List));
+ cmd->state = Clean;
+ if(cmdstr.n){
+ Finsert(cmd, &cmdstr, 0L);
+ Strdelete(&cmdstr, 0L, (Posn)cmdstr.n);
+ }
+ Fupdate(cmd, FALSE, TRUE);
+ outT0(Hunlock);
+ break;
+
+ case Tcheck:
+ /* go through whichfile to check the tag */
+ outTs(Hcheck, whichfile(inshort())->tag);
+ break;
+
+ case Trequest:
+ f = whichfile(inshort());
+ p0 = inlong();
+ p1 = p0+inshort();
+ journaln(0, p0);
+ journaln(0, p1-p0);
+ if(f->state == Unread)
+ panic("Trequest: unread");
+ if(p1>f->nrunes)
+ p1 = f->nrunes;
+ if(p0>f->nrunes) /* can happen e.g. scrolling during command */
+ p0 = f->nrunes;
+ if(p0 == p1){
+ i = 0;
+ r.p1 = r.p2 = p0;
+ }else{
+ r = rdata(f->rasp, p0, p1-p0);
+ i = r.p2-r.p1;
+ if(Fchars(f, buf, r.p1, r.p2)!=i)
+ panic("Trequest 2");
+ }
+ buf[i]=0;
+ outTslS(Hdata, f->tag, r.p1, tmprstr(buf, i+1));
+ break;
+
+ case Torigin:
+ s = inshort(); /* tag */
+ l = inlong(); /* position */
+ l1 = inlong(); /* lines to seek past position */
journaln(0, l1);
if (!oldcompat){
l2 = inlong(); /* cookie to return (identifies layer) */
journaln(0, l2);
} else
l2 = 0;
- lookorigin(whichfile(s), l, l1, l2);
- break;
-
- case Tstartfile:
- termlocked++;
- f = whichfile(inshort());
- if(!f->rasp) /* this might be a duplicate message */
- f->rasp = emalloc(sizeof(List));
- current(f);
- outTsv(Hbindname, f->tag, invlong()); /* for 64-bit poi…
- outTs(Hcurrent, f->tag);
- journaln(0, f->tag);
- if(f->state == Unread)
- load(f);
- else{
- if(f->nrunes>0){
- rgrow(f->rasp, 0L, f->nrunes);
- outTsll(Hgrow, f->tag, 0L, f->nrunes);
- }
- outTs(Hcheck0, f->tag);
- moveto(f, f->dot.r);
- }
- break;
-
- case Tworkfile:
- i = inshort();
- f = whichfile(i);
- current(f);
- f->dot.r.p1 = inlong();
- f->dot.r.p2 = inlong();
- f->tdot = f->dot.r;
- journaln(0, i);
- journaln(0, f->dot.r.p1);
- journaln(0, f->dot.r.p2);
- break;
-
- case Ttype:
- f = whichfile(inshort());
- p0 = inlong();
- journaln(0, p0);
- journal(0, (char*)inp);
- str = tmpcstr((char*)inp);
- i = str->n;
- Finsert(f, str, p0);
- if(Fupdate(f, FALSE, FALSE))
- modnum++;
- if(f==cmd && p0==f->nrunes-i && i>0 && str->s[i-1]=='\n'){
- freetmpstr(str);
- termlocked++;
- termcommand();
- }else
- freetmpstr(str);
- f->dot.r.p1 = f->dot.r.p2 = p0+i; /* terminal knows this alrea…
- f->tdot = f->dot.r;
- break;
-
- case Tcut:
- f = whichfile(inshort());
- p0 = inlong();
- p1 = inlong();
- journaln(0, p0);
- journaln(0, p1);
- Fdelete(f, p0, p1);
- if(Fupdate(f, FALSE, FALSE))
- modnum++;
- f->dot.r.p1 = f->dot.r.p2 = p0;
- f->tdot = f->dot.r; /* terminal knows the value of dot alrea…
- break;
-
- case Tpaste:
- f = whichfile(inshort());
- p0 = inlong();
- journaln(0, p0);
- for(l=0; l<snarfbuf->nrunes; l+=m){
- m = snarfbuf->nrunes-l;
- if(m>BLOCKSIZE)
- m = BLOCKSIZE;
- Bread(snarfbuf, genbuf, m, l);
- Finsert(f, tmprstr(genbuf, m), p0);
- }
- if(Fupdate(f, FALSE, TRUE))
- modnum++;
- f->dot.r.p1 = p0;
- f->dot.r.p2 = p0+snarfbuf->nrunes;
- f->tdot.p1 = -1; /* force telldot to tell (arguably a BUG) */
- telldot(f);
- outTs(Hunlockfile, f->tag);
- break;
-
- case Tsnarf:
- i = inshort();
- p0 = inlong();
- p1 = inlong();
- snarf(whichfile(i), p0, p1, snarfbuf, 0);
- break;
-
- case Tstartnewfile:
- l = invlong();
- Strdupl(&genstr, empty);
- f = newfile();
- f->rasp = emalloc(sizeof(List));
- outTsv(Hbindname, f->tag, l);
- Fsetname(f, &genstr);
- outTs(Hcurrent, f->tag);
- current(f);
- load(f);
- break;
-
- case Twrite:
- termlocked++;
- i = inshort();
- journaln(0, i);
- f = whichfile(i);
- addr.r.p1 = 0;
- addr.r.p2 = f->nrunes;
- if(f->name.s[0] == 0)
- error(Enoname);
- Strduplstr(&genstr, &f->name);
- writef(f);
- break;
-
- case Tclose:
- termlocked++;
- i = inshort();
- journaln(0, i);
- f = whichfile(i);
- current(f);
- trytoclose(f);
- /* if trytoclose fails, will error out */
- delete(f);
- break;
-
- case Tlook:
- f = whichfile(inshort());
- termlocked++;
- p0 = inlong();
- p1 = inlong();
- journaln(0, p0);
- journaln(0, p1);
- setgenstr(f, p0, p1);
- for(l = 0; l<genstr.n; l++){
- i = genstr.s[l];
- if(utfrune(".*+?(|)\\[]^$", i))
- Strinsert(&genstr, tmpcstr("\\"), l++);
- }
- Straddc(&genstr, '\0');
- nextmatch(f, &genstr, p1, 1);
- moveto(f, sel.p[0]);
- break;
-
- case Tsearch:
- termlocked++;
- if(curfile == 0)
- error(Enofile);
- if(lastpat.s[0] == 0)
- panic("Tsearch");
- nextmatch(curfile, &lastpat, curfile->dot.r.p2, 1);
- moveto(curfile, sel.p[0]);
- break;
-
- case Tsend:
- termlocked++;
- inshort(); /* ignored */
- p0 = inlong();
- p1 = inlong();
- setgenstr(cmd, p0, p1);
- Bdelete(snarfbuf, (Posn)0, snarfbuf->nrunes);
- Binsert(snarfbuf, &genstr, (Posn)0);
- outTl(Hsnarflen, genstr.n);
- if(genstr.s[genstr.n-1] != '\n')
- Straddc(&genstr, '\n');
- Finsert(cmd, &genstr, cmd->nrunes);
- Fupdate(cmd, FALSE, TRUE);
- cmd->dot.r.p1 = cmd->dot.r.p2 = cmd->nrunes;
- telldot(cmd);
- termcommand();
- break;
-
- case Tdclick:
- f = whichfile(inshort());
- p1 = inlong();
- doubleclick(f, p1);
- f->tdot.p1 = f->tdot.p2 = p1;
- telldot(f);
- outTs(Hunlockfile, f->tag);
- break;
-
- case Tstartsnarf:
- if (snarfbuf->nrunes <= 0) { /* nothing to export */
- outTs(Hsetsnarf, 0);
- break;
- }
- c = 0;
- i = 0;
- m = snarfbuf->nrunes;
- if(m > 32000) { /* tmprstr stores len in a shor…
- m = 32000;
- dprint("?warning: snarf buffer truncated\n");
- }
- rp = malloc(m*sizeof(Rune));
- if(rp){
- Bread(snarfbuf, rp, m, 0);
- c = Strtoc(tmprstr(rp, m));
- free(rp);
- i = strlen(c);
- }
- outTs(Hsetsnarf, i);
- if(c){
- Write(1, c, i);
- free(c);
- } else
- dprint("snarf buffer too long\n");
- break;
-
- case Tsetsnarf:
- m = inshort();
- if(m > SNARFSIZE)
- error(Etoolong);
- c = malloc(m+1);
- if(c){
- for(i=0; i<m; i++)
- c[i] = rcvchar();
- c[m] = 0;
- str = tmpcstr(c);
- free(c);
- Bdelete(snarfbuf, (Posn)0, snarfbuf->nrunes);
- Binsert(snarfbuf, str, (Posn)0);
- freetmpstr(str);
- outT0(Hunlock);
- }
- break;
-
- case Tack:
- waitack = 0;
- break;
-
- case Texit:
- exits(0);
- }
- return TRUE;
+ lookorigin(whichfile(s), l, l1, l2);
+ break;
+
+ case Tstartfile:
+ termlocked++;
+ f = whichfile(inshort());
+ if(!f->rasp) /* this might be a duplicate message */
+ f->rasp = emalloc(sizeof(List));
+ current(f);
+ outTsv(Hbindname, f->tag, invlong()); /* for 64-bit pointers */
+ outTs(Hcurrent, f->tag);
+ journaln(0, f->tag);
+ if(f->state == Unread)
+ load(f);
+ else{
+ if(f->nrunes>0){
+ rgrow(f->rasp, 0L, f->nrunes);
+ outTsll(Hgrow, f->tag, 0L, f->nrunes);
+ }
+ outTs(Hcheck0, f->tag);
+ moveto(f, f->dot.r);
+ }
+ break;
+
+ case Tworkfile:
+ i = inshort();
+ f = whichfile(i);
+ current(f);
+ f->dot.r.p1 = inlong();
+ f->dot.r.p2 = inlong();
+ f->tdot = f->dot.r;
+ journaln(0, i);
+ journaln(0, f->dot.r.p1);
+ journaln(0, f->dot.r.p2);
+ break;
+
+ case Ttype:
+ f = whichfile(inshort());
+ p0 = inlong();
+ journaln(0, p0);
+ journal(0, (char*)inp);
+ str = tmpcstr((char*)inp);
+ i = str->n;
+ Finsert(f, str, p0);
+ if(Fupdate(f, FALSE, FALSE))
+ modnum++;
+ if(f==cmd && p0==f->nrunes-i && i>0 && str->s[i-1]=='\n'){
+ freetmpstr(str);
+ termlocked++;
+ termcommand();
+ }else
+ freetmpstr(str);
+ f->dot.r.p1 = f->dot.r.p2 = p0+i; /* terminal knows this already */
+ f->tdot = f->dot.r;
+ break;
+
+ case Tcut:
+ f = whichfile(inshort());
+ p0 = inlong();
+ p1 = inlong();
+ journaln(0, p0);
+ journaln(0, p1);
+ Fdelete(f, p0, p1);
+ if(Fupdate(f, FALSE, FALSE))
+ modnum++;
+ f->dot.r.p1 = f->dot.r.p2 = p0;
+ f->tdot = f->dot.r; /* terminal knows the value of dot already */
+ break;
+
+ case Tpaste:
+ f = whichfile(inshort());
+ p0 = inlong();
+ journaln(0, p0);
+ for(l=0; l<snarfbuf->nrunes; l+=m){
+ m = snarfbuf->nrunes-l;
+ if(m>BLOCKSIZE)
+ m = BLOCKSIZE;
+ Bread(snarfbuf, genbuf, m, l);
+ Finsert(f, tmprstr(genbuf, m), p0);
+ }
+ if(Fupdate(f, FALSE, TRUE))
+ modnum++;
+ f->dot.r.p1 = p0;
+ f->dot.r.p2 = p0+snarfbuf->nrunes;
+ f->tdot.p1 = -1; /* force telldot to tell (arguably a BUG) */
+ telldot(f);
+ outTs(Hunlockfile, f->tag);
+ break;
+
+ case Tsnarf:
+ i = inshort();
+ p0 = inlong();
+ p1 = inlong();
+ snarf(whichfile(i), p0, p1, snarfbuf, 0);
+ break;
+
+ case Tstartnewfile:
+ l = invlong();
+ Strdupl(&genstr, empty);
+ f = newfile();
+ f->rasp = emalloc(sizeof(List));
+ outTsv(Hbindname, f->tag, l);
+ Fsetname(f, &genstr);
+ outTs(Hcurrent, f->tag);
+ current(f);
+ load(f);
+ break;
+
+ case Twrite:
+ termlocked++;
+ i = inshort();
+ journaln(0, i);
+ f = whichfile(i);
+ addr.r.p1 = 0;
+ addr.r.p2 = f->nrunes;
+ if(f->name.s[0] == 0)
+ error(Enoname);
+ Strduplstr(&genstr, &f->name);
+ writef(f);
+ break;
+
+ case Tclose:
+ termlocked++;
+ i = inshort();
+ journaln(0, i);
+ f = whichfile(i);
+ current(f);
+ trytoclose(f);
+ /* if trytoclose fails, will error out */
+ delete(f);
+ break;
+
+ case Tlook:
+ f = whichfile(inshort());
+ termlocked++;
+ p0 = inlong();
+ p1 = inlong();
+ journaln(0, p0);
+ journaln(0, p1);
+ setgenstr(f, p0, p1);
+ for(l = 0; l<genstr.n; l++){
+ i = genstr.s[l];
+ if(utfrune(".*+?(|)\\[]^$", i))
+ Strinsert(&genstr, tmpcstr("\\"), l++);
+ }
+ Straddc(&genstr, '\0');
+ nextmatch(f, &genstr, p1, 1);
+ moveto(f, sel.p[0]);
+ break;
+
+ case Tsearch:
+ termlocked++;
+ if(curfile == 0)
+ error(Enofile);
+ if(lastpat.s[0] == 0)
+ panic("Tsearch");
+ nextmatch(curfile, &lastpat, curfile->dot.r.p2, 1);
+ moveto(curfile, sel.p[0]);
+ break;
+
+ case Tsend:
+ termlocked++;
+ inshort(); /* ignored */
+ p0 = inlong();
+ p1 = inlong();
+ setgenstr(cmd, p0, p1);
+ Bdelete(snarfbuf, (Posn)0, snarfbuf->nrunes);
+ Binsert(snarfbuf, &genstr, (Posn)0);
+ outTl(Hsnarflen, genstr.n);
+ if(genstr.s[genstr.n-1] != '\n')
+ Straddc(&genstr, '\n');
+ Finsert(cmd, &genstr, cmd->nrunes);
+ Fupdate(cmd, FALSE, TRUE);
+ cmd->dot.r.p1 = cmd->dot.r.p2 = cmd->nrunes;
+ telldot(cmd);
+ termcommand();
+ break;
+
+ case Tdclick:
+ f = whichfile(inshort());
+ p1 = inlong();
+ doubleclick(f, p1);
+ f->tdot.p1 = f->tdot.p2 = p1;
+ telldot(f);
+ outTs(Hunlockfile, f->tag);
+ break;
+
+ case Tstartsnarf:
+ if (snarfbuf->nrunes <= 0) { /* nothing to export */
+ outTs(Hsetsnarf, 0);
+ break;
+ }
+ c = 0;
+ i = 0;
+ m = snarfbuf->nrunes;
+ if(m > 32000) { /* tmprstr stores len in a short */
+ m = 32000;
+ dprint("?warning: snarf buffer truncated\n");
+ }
+ rp = malloc(m*sizeof(Rune));
+ if(rp){
+ Bread(snarfbuf, rp, m, 0);
+ c = Strtoc(tmprstr(rp, m));
+ free(rp);
+ i = strlen(c);
+ }
+ outTs(Hsetsnarf, i);
+ if(c){
+ Write(1, c, i);
+ free(c);
+ } else
+ dprint("snarf buffer too long\n");
+ break;
+
+ case Tsetsnarf:
+ m = inshort();
+ if(m > SNARFSIZE)
+ error(Etoolong);
+ c = malloc(m+1);
+ if(c){
+ for(i=0; i<m; i++)
+ c[i] = rcvchar();
+ c[m] = 0;
+ str = tmpcstr(c);
+ free(c);
+ Bdelete(snarfbuf, (Posn)0, snarfbuf->nrunes);
+ Binsert(snarfbuf, str, (Posn)0);
+ freetmpstr(str);
+ outT0(Hunlock);
+ }
+ break;
+
+ case Tack:
+ waitack = 0;
+ break;
+
+ case Texit:
+ exits(0);
+ }
+ return TRUE;
}
void
snarf(File *f, Posn p1, Posn p2, Buffer *buf, int emptyok)
{
- Posn l;
- int i;
-
- if(!emptyok && p1==p2)
- return;
- Bdelete(buf, (Posn)0, buf->nrunes);
- /* Stage through genbuf to avoid compaction problems (vestigial) */
- for(l=p1; l<p2; l+=i){
- i = p2-l>BLOCKSIZE? BLOCKSIZE : p2-l;
- Fchars(f, genbuf, l, l+i);
- Binsert(buf, tmprstr(genbuf, i), buf->nrunes);
- }
+ Posn l;
+ int i;
+
+ if(!emptyok && p1==p2)
+ return;
+ Bdelete(buf, (Posn)0, buf->nrunes);
+ /* Stage through genbuf to avoid compaction problems (vestigial) */
+ for(l=p1; l<p2; l+=i){
+ i = p2-l>BLOCKSIZE? BLOCKSIZE : p2-l;
+ Fchars(f, genbuf, l, l+i);
+ Binsert(buf, tmprstr(genbuf, i), buf->nrunes);
+ }
}
int
inshort(void)
{
- ushort n;
+ ushort n;
- n = inp[0] | (inp[1]<<8);
- inp += 2;
- return n;
+ n = inp[0] | (inp[1]<<8);
+ inp += 2;
+ return n;
}
long
inlong(void)
{
- ulong n;
+ ulong n;
- n = inp[0] | (inp[1]<<8) | (inp[2]<<16) | (inp[3]<<24);
- inp += 4;
- return n;
+ n = inp[0] | (inp[1]<<8) | (inp[2]<<16) | (inp[3]<<24);
+ inp += 4;
+ return n;
}
long
invlong(void)
{
- ulong n;
-
- n = (inp[7]<<24) | (inp[6]<<16) | (inp[5]<<8) | inp[4];
- n = (n<<16) | (inp[3]<<8) | inp[2];
- n = (n<<16) | (inp[1]<<8) | inp[0];
- inp += 8;
- return n;
+ ulong n;
+
+ n = (inp[7]<<24) | (inp[6]<<16) | (inp[5]<<8) | inp[4];
+ n = (n<<16) | (inp[3]<<8) | inp[2];
+ n = (n<<16) | (inp[1]<<8) | inp[0];
+ inp += 8;
+ return n;
}
void
setgenstr(File *f, Posn p0, Posn p1)
{
- if(p0 != p1){
- if(p1-p0 >= TBLOCKSIZE)
- error(Etoolong);
- Strinsure(&genstr, p1-p0);
- Fchars(f, genbuf, p0, p1);
- memmove(genstr.s, genbuf, RUNESIZE*(p1-p0));
- genstr.n = p1-p0;
- }else{
- if(snarfbuf->nrunes == 0)
- error(Eempty);
- if(snarfbuf->nrunes > TBLOCKSIZE)
- error(Etoolong);
- Bread(snarfbuf, genbuf, snarfbuf->nrunes, (Posn)0);
- Strinsure(&genstr, snarfbuf->nrunes);
- memmove(genstr.s, genbuf, RUNESIZE*snarfbuf->nrunes);
- genstr.n = snarfbuf->nrunes;
- }
+ if(p0 != p1){
+ if(p1-p0 >= TBLOCKSIZE)
+ error(Etoolong);
+ Strinsure(&genstr, p1-p0);
+ Fchars(f, genbuf, p0, p1);
+ memmove(genstr.s, genbuf, RUNESIZE*(p1-p0));
+ genstr.n = p1-p0;
+ }else{
+ if(snarfbuf->nrunes == 0)
+ error(Eempty);
+ if(snarfbuf->nrunes > TBLOCKSIZE)
+ error(Etoolong);
+ Bread(snarfbuf, genbuf, snarfbuf->nrunes, (Posn)0);
+ Strinsure(&genstr, snarfbuf->nrunes);
+ memmove(genstr.s, genbuf, RUNESIZE*snarfbuf->nrunes);
+ genstr.n = snarfbuf->nrunes;
+ }
}
void
outT0(Hmesg type)
{
- outstart(type);
- outsend();
+ outstart(type);
+ outsend();
}
void
outTl(Hmesg type, long l)
{
- outstart(type);
- outlong(l);
- outsend();
+ outstart(type);
+ outlong(l);
+ outsend();
}
void
outTs(Hmesg type, int s)
{
- outstart(type);
- journaln(1, s);
- outshort(s);
- outsend();
+ outstart(type);
+ journaln(1, s);
+ outshort(s);
+ outsend();
}
void
outS(String *s)
{
- char *c;
- int i;
-
- c = Strtoc(s);
- i = strlen(c);
- outcopy(i, c);
- if(i > 99)
- c[99] = 0;
- journaln(1, i);
- journal(1, c);
- free(c);
+ char *c;
+ int i;
+
+ c = Strtoc(s);
+ i = strlen(c);
+ outcopy(i, c);
+ if(i > 99)
+ c[99] = 0;
+ journaln(1, i);
+ journal(1, c);
+ free(c);
}
void
outTsS(Hmesg type, int s1, String *s)
{
- outstart(type);
- outshort(s1);
- outS(s);
- outsend();
+ outstart(type);
+ outshort(s1);
+ outS(s);
+ outsend();
}
void
outTslS(Hmesg type, int s1, Posn l1, String *s)
{
- outstart(type);
- outshort(s1);
- journaln(1, s1);
- outlong(l1);
- journaln(1, l1);
- outS(s);
- outsend();
+ outstart(type);
+ outshort(s1);
+ journaln(1, s1);
+ outlong(l1);
+ journaln(1, l1);
+ outS(s);
+ outsend();
}
void
outTS(Hmesg type, String *s)
{
- outstart(type);
- outS(s);
- outsend();
+ outstart(type);
+ outS(s);
+ outsend();
}
void
outTsllS(Hmesg type, int s1, Posn l1, Posn l2, String *s)
{
- outstart(type);
- outshort(s1);
- outlong(l1);
- outlong(l2);
- journaln(1, l1);
- journaln(1, l2);
- outS(s);
- outsend();
+ outstart(type);
+ outshort(s1);
+ outlong(l1);
+ outlong(l2);
+ journaln(1, l1);
+ journaln(1, l2);
+ outS(s);
+ outsend();
}
void
outTsll(Hmesg type, int s, Posn l1, Posn l2)
{
- outstart(type);
- outshort(s);
- outlong(l1);
- outlong(l2);
- journaln(1, l1);
- journaln(1, l2);
- outsend();
+ outstart(type);
+ outshort(s);
+ outlong(l1);
+ outlong(l2);
+ journaln(1, l1);
+ journaln(1, l2);
+ outsend();
}
void
outTsl(Hmesg type, int s, Posn l)
{
- outstart(type);
- outshort(s);
- outlong(l);
- journaln(1, l);
- outsend();
+ outstart(type);
+ outshort(s);
+ outlong(l);
+ journaln(1, l);
+ outsend();
}
void
outTsv(Hmesg type, int s, Posn l)
{
- outstart(type);
- outshort(s);
- outvlong((void*)l);
- journaln(1, l);
- outsend();
+ outstart(type);
+ outshort(s);
+ outvlong((void*)l);
+ journaln(1, l);
+ outsend();
}
void
outstart(Hmesg type)
{
- journal(1, hname[type]);
- outmsg[0] = type;
- outp = outmsg+3;
+ journal(1, hname[type]);
+ outmsg[0] = type;
+ outp = outmsg+3;
}
void
outcopy(int count, void *data)
{
- memmove(outp, data, count);
- outp += count;
+ memmove(outp, data, count);
+ outp += count;
}
void
outshort(int s)
{
- *outp++ = s;
- *outp++ = s>>8;
+ *outp++ = s;
+ *outp++ = s>>8;
}
void
outlong(long l)
{
- *outp++ = l;
- *outp++ = l>>8;
- *outp++ = l>>16;
- *outp++ = l>>24;
+ *outp++ = l;
+ *outp++ = l>>8;
+ *outp++ = l>>16;
+ *outp++ = l>>24;
}
void
outvlong(void *v)
{
- int i;
- uintptr_t l;
+ int i;
+ uintptr_t l;
- l = (uintptr_t)v;
- for(i = 0; i < 8; i++, l >>= 8)
- *outp++ = l;
+ l = (uintptr_t)v;
+ for(i = 0; i < 8; i++, l >>= 8)
+ *outp++ = l;
}
void
outsend(void)
{
- int outcount;
-
- outcount = outp-outmsg;
- outcount -= 3;
- outmsg[1] = outcount;
- outmsg[2] = outcount>>8;
- outmsg = outp;
- if(!noflush){
- outcount = outmsg-outdata;
- if (write(1, (char*) outdata, outcount) != outcount)
- rescue();
- outmsg = outdata;
- return;
- }
- if(outmsg < outdata+DATASIZE)
- return;
- outflush();
+ int outcount;
+
+ outcount = outp-outmsg;
+ outcount -= 3;
+ outmsg[1] = outcount;
+ outmsg[2] = outcount>>8;
+ outmsg = outp;
+ if(!noflush){
+ outcount = outmsg-outdata;
+ if (write(1, (char*) outdata, outcount) != outcount)
+ rescue();
+ outmsg = outdata;
+ return;
+ }
+ if(outmsg < outdata+DATASIZE)
+ return;
+ outflush();
}
void
outflush(void)
{
- if(outmsg == outdata)
- return;
- noflush = 0;
- outT0(Hack);
- waitack = 1;
- do
- if(rcv() == 0){
- rescue();
- exits("eof");
- }
- while(waitack);
- outmsg = outdata;
- noflush = 1;
+ if(outmsg == outdata)
+ return;
+ noflush = 0;
+ outT0(Hack);
+ waitack = 1;
+ do
+ if(rcv() == 0){
+ rescue();
+ exits("eof");
+ }
+ while(waitack);
+ outmsg = outdata;
+ noflush = 1;
}
diff --git a/sam/mesg.h b/sam/mesg.h
@@ -2,107 +2,107 @@
#ifdef CLASSIC_SAM_COMPATIBILITY
#define VERSION 0
#else
-#define VERSION 16091
+#define VERSION 16091
#endif
extern int oldcompat;
-#define TBLOCKSIZE 512 /* largest piece of text sent t…
-#define DATASIZE (UTFmax*TBLOCKSIZE+30) /* ... including protocol head…
-#define SNARFSIZE 16384 /* maximum length of exchanged s…
+#define TBLOCKSIZE 512 /* largest piece of text sent to terminal */
+#define DATASIZE (UTFmax*TBLOCKSIZE+30) /* ... including protocol header stuf…
+#define SNARFSIZE 16384 /* maximum length of exchanged snarf buffer */
/*
* Messages originating at the terminal
*/
typedef enum Tmesg
{
- Tversion, /* version */
- Tstartcmdfile, /* terminal just opened command frame */
- Tcheck, /* ask host to poke with Hcheck */
- Trequest, /* request data to fill a hole */
- Torigin, /* gimme an Horigin near here */
- Tstartfile, /* terminal just opened a file's frame */
- Tworkfile, /* set file to which commands apply */
- Ttype, /* add some characters, but terminal already kno…
- Tcut,
- Tpaste,
- Tsnarf,
- Tstartnewfile, /* terminal just opened a new frame */
- Twrite, /* write file */
- Tclose, /* terminal requests file close; check mod. sta…
- Tlook, /* search for literal current text */
- Tsearch, /* search for last regular expression */
- Tsend, /* pretend he typed stuff */
- Tdclick, /* double click */
- Tstartsnarf, /* initiate snarf buffer exchange */
- Tsetsnarf, /* remember string in snarf buffer */
- Tack, /* acknowledge Hack */
- Texit, /* exit */
- TMAX
+ Tversion, /* version */
+ Tstartcmdfile, /* terminal just opened command frame */
+ Tcheck, /* ask host to poke with Hcheck */
+ Trequest, /* request data to fill a hole */
+ Torigin, /* gimme an Horigin near here */
+ Tstartfile, /* terminal just opened a file's frame */
+ Tworkfile, /* set file to which commands apply */
+ Ttype, /* add some characters, but terminal already knows */
+ Tcut,
+ Tpaste,
+ Tsnarf,
+ Tstartnewfile, /* terminal just opened a new frame */
+ Twrite, /* write file */
+ Tclose, /* terminal requests file close; check mod. status */
+ Tlook, /* search for literal current text */
+ Tsearch, /* search for last regular expression */
+ Tsend, /* pretend he typed stuff */
+ Tdclick, /* double click */
+ Tstartsnarf, /* initiate snarf buffer exchange */
+ Tsetsnarf, /* remember string in snarf buffer */
+ Tack, /* acknowledge Hack */
+ Texit, /* exit */
+ TMAX
}Tmesg;
/*
* Messages originating at the host
*/
typedef enum Hmesg
{
- Hversion, /* version */
- Hbindname, /* attach name[0] to text in terminal */
- Hcurrent, /* make named file the typing file */
- Hnewname, /* create "" name in menu */
- Hmovname, /* move file name in menu */
- Hgrow, /* insert space in rasp */
- Hcheck0, /* see below */
- Hcheck, /* ask terminal to check whether it needs more …
- Hunlock, /* command is finished; user can do things */
- Hdata, /* store this data in previously allocated space…
- Horigin, /* set origin of file/frame in terminal */
- Hunlockfile, /* unlock file in terminal */
- Hsetdot, /* set dot in terminal */
- Hgrowdata, /* Hgrow + Hdata folded together */
- Hmoveto, /* scrolling, context search, etc. */
- Hclean, /* named file is now 'clean' */
- Hdirty, /* named file is now 'dirty' */
- Hcut, /* remove space from rasp */
- Hsetpat, /* set remembered regular expression */
- Hdelname, /* delete file name from menu */
- Hclose, /* close file and remove from menu */
- Hsetsnarf, /* remember string in snarf buffer */
- Hsnarflen, /* report length of implicit snarf */
- Hack, /* request acknowledgement */
- Hexit,
+ Hversion, /* version */
+ Hbindname, /* attach name[0] to text in terminal */
+ Hcurrent, /* make named file the typing file */
+ Hnewname, /* create "" name in menu */
+ Hmovname, /* move file name in menu */
+ Hgrow, /* insert space in rasp */
+ Hcheck0, /* see below */
+ Hcheck, /* ask terminal to check whether it needs more data */
+ Hunlock, /* command is finished; user can do things */
+ Hdata, /* store this data in previously allocated space */
+ Horigin, /* set origin of file/frame in terminal */
+ Hunlockfile, /* unlock file in terminal */
+ Hsetdot, /* set dot in terminal */
+ Hgrowdata, /* Hgrow + Hdata folded together */
+ Hmoveto, /* scrolling, context search, etc. */
+ Hclean, /* named file is now 'clean' */
+ Hdirty, /* named file is now 'dirty' */
+ Hcut, /* remove space from rasp */
+ Hsetpat, /* set remembered regular expression */
+ Hdelname, /* delete file name from menu */
+ Hclose, /* close file and remove from menu */
+ Hsetsnarf, /* remember string in snarf buffer */
+ Hsnarflen, /* report length of implicit snarf */
+ Hack, /* request acknowledgement */
+ Hexit,
Hextcmd, /* execute a external command */
- HMAX
+ HMAX
}Hmesg;
typedef struct Header{
- uchar type; /* one of the above */
- uchar count0; /* low bits of data size */
- uchar count1; /* high bits of data size */
- uchar data[1]; /* variable size */
+ uchar type; /* one of the above */
+ uchar count0; /* low bits of data size */
+ uchar count1; /* high bits of data size */
+ uchar data[1]; /* variable size */
}Header;
/*
* File transfer protocol schematic, a la Holzmann
- *
- * proc h
- * { pvar n = 0;
- * queue h[4];
- *
- * do
- * :: (n < N) -> n++; t!Hgrow
- * :: (n == N) -> n++; t!Hcheck0
- * :: h?Trequest -> t!Hdata
- * :: h?Tcheck -> t!Hcheck
- * od
- * }
- * proc t
- * { queue t[4];
- * do
- * :: t?Hgrow -> h!Trequest
- * :: t?Hdata -> skip
- * :: t?Hcheck0 -> h!Tcheck
- * :: t?Hcheck ->
- * if
- * :: break
- * :: h!Trequest; h!Tcheck
- * fi
- * od
- * }
+ *
+ * proc h
+ * { pvar n = 0;
+ * queue h[4];
+ *
+ * do
+ * :: (n < N) -> n++; t!Hgrow
+ * :: (n == N) -> n++; t!Hcheck0
+ * :: h?Trequest -> t!Hdata
+ * :: h?Tcheck -> t!Hcheck
+ * od
+ * }
+ * proc t
+ * { queue t[4];
+ * do
+ * :: t?Hgrow -> h!Trequest
+ * :: t?Hdata -> skip
+ * :: t?Hcheck0 -> h!Tcheck
+ * :: t?Hcheck ->
+ * if
+ * :: break
+ * :: h!Trequest; h!Tcheck
+ * fi
+ * od
+ * }
*/
diff --git a/sam/moveto.c b/sam/moveto.c
@@ -4,168 +4,168 @@
void
moveto(File *f, Range r)
{
- Posn p1 = r.p1, p2 = r.p2;
-
- f->dot.r.p1 = p1;
- f->dot.r.p2 = p2;
- if(f->rasp){
- telldot(f);
- outTsl(Hmoveto, f->tag, f->dot.r.p1);
- }
+ Posn p1 = r.p1, p2 = r.p2;
+
+ f->dot.r.p1 = p1;
+ f->dot.r.p2 = p2;
+ if(f->rasp){
+ telldot(f);
+ outTsl(Hmoveto, f->tag, f->dot.r.p1);
+ }
}
void
telldot(File *f)
{
- if(f->rasp == 0)
- panic("telldot");
- if(f->dot.r.p1==f->tdot.p1 && f->dot.r.p2==f->tdot.p2)
- return;
- outTsll(Hsetdot, f->tag, f->dot.r.p1, f->dot.r.p2);
- f->tdot = f->dot.r;
+ if(f->rasp == 0)
+ panic("telldot");
+ if(f->dot.r.p1==f->tdot.p1 && f->dot.r.p2==f->tdot.p2)
+ return;
+ outTsll(Hsetdot, f->tag, f->dot.r.p1, f->dot.r.p2);
+ f->tdot = f->dot.r;
}
void
tellpat(void)
{
- outTS(Hsetpat, &lastpat);
- patset = FALSE;
+ outTS(Hsetpat, &lastpat);
+ patset = FALSE;
}
-#define CHARSHIFT 128
+#define CHARSHIFT 128
void
lookorigin(File *f, Posn p0, Posn ls, long rl)
{
- int nl, nc, c;
- Posn oldp0;
-
- if(p0 > f->nrunes)
- p0 = f->nrunes;
- oldp0 = p0;
- Fgetcset(f, p0);
- for(nl=nc=c=0; c!=-1 && nl<ls && nc<ls*CHARSHIFT; nc++)
- if((c=Fbgetc(f)) == '\n'){
- nl++;
- oldp0 = p0-nc;
- }
- if(c == -1)
- p0 = 0;
- else if(nl==0){
- if(p0>=CHARSHIFT/2)
- p0-=CHARSHIFT/2;
- else
- p0 = 0;
- }else
- p0 = oldp0;
+ int nl, nc, c;
+ Posn oldp0;
+
+ if(p0 > f->nrunes)
+ p0 = f->nrunes;
+ oldp0 = p0;
+ Fgetcset(f, p0);
+ for(nl=nc=c=0; c!=-1 && nl<ls && nc<ls*CHARSHIFT; nc++)
+ if((c=Fbgetc(f)) == '\n'){
+ nl++;
+ oldp0 = p0-nc;
+ }
+ if(c == -1)
+ p0 = 0;
+ else if(nl==0){
+ if(p0>=CHARSHIFT/2)
+ p0-=CHARSHIFT/2;
+ else
+ p0 = 0;
+ }else
+ p0 = oldp0;
if (oldcompat)
- outTsl(Horigin, f->tag, p0);
+ outTsl(Horigin, f->tag, p0);
else
- outTsll(Horigin, f->tag, p0, rl);
+ outTsll(Horigin, f->tag, p0, rl);
}
int
alnum(int c)
{
- /*
- * Hard to get absolutely right. Use what we know about ASCII
- * and assume anything above the Latin control characters is
- * potentially an alphanumeric.
- */
- if(c<=' ')
- return 0;
- if(0x7F<=c && c<=0xA0)
- return 0;
- if(utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c))
- return 0;
- return 1;
+ /*
+ * Hard to get absolutely right. Use what we know about ASCII
+ * and assume anything above the Latin control characters is
+ * potentially an alphanumeric.
+ */
+ if(c<=' ')
+ return 0;
+ if(0x7F<=c && c<=0xA0)
+ return 0;
+ if(utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c))
+ return 0;
+ return 1;
}
int
clickmatch(File *f, int cl, int cr, int dir)
{
- int c;
- int nest = 1;
-
- while((c=(dir>0? Fgetc(f) : Fbgetc(f))) > 0)
- if(c == cr){
- if(--nest==0)
- return 1;
- }else if(c == cl)
- nest++;
- return cl=='\n' && nest==1;
+ int c;
+ int nest = 1;
+
+ while((c=(dir>0? Fgetc(f) : Fbgetc(f))) > 0)
+ if(c == cr){
+ if(--nest==0)
+ return 1;
+ }else if(c == cl)
+ nest++;
+ return cl=='\n' && nest==1;
}
Rune*
strrune(Rune *s, Rune c)
{
- Rune c1;
-
- if(c == 0) {
- while(*s++)
- ;
- return s-1;
- }
-
- while(c1 = *s++)
- if(c1 == c)
- return s-1;
- return 0;
+ Rune c1;
+
+ if(c == 0) {
+ while(*s++)
+ ;
+ return s-1;
+ }
+
+ while(c1 = *s++)
+ if(c1 == c)
+ return s-1;
+ return 0;
}
void
doubleclick(File *f, Posn p1)
{
- int c, i;
- Rune *r, *l;
-
- if(p1 > f->nrunes)
- return;
- f->dot.r.p1 = f->dot.r.p2 = p1;
- for(i=0; left[i]; i++){
- l = left[i];
- r = right[i];
- /* try left match */
- if(p1 == 0){
- Fgetcset(f, p1);
- c = '\n';
- }else{
- Fgetcset(f, p1-1);
- c = Fgetc(f);
- }
- if(c!=-1 && strrune(l, c)){
- if(clickmatch(f, c, r[strrune(l, c)-l], 1)){
- f->dot.r.p1 = p1;
- f->dot.r.p2 = f->getcp-(c!='\n');
- }
- return;
- }
- /* try right match */
- if(p1 == f->nrunes){
- Fbgetcset(f, p1);
- c = '\n';
- }else{
- Fbgetcset(f, p1+1);
- c = Fbgetc(f);
- }
- if(c!=-1 && strrune(r, c)){
- if(clickmatch(f, c, l[strrune(r, c)-r], -1)){
- f->dot.r.p1 = f->getcp;
- if(c!='\n' || f->getcp!=0 ||
- (Fgetcset(f, (Posn)0),Fgetc(f))=='\n')
- f->dot.r.p1++;
- f->dot.r.p2 = p1+(p1<f->nrunes && c=='\n');
- }
- return;
- }
- }
- /* try filling out word to right */
- Fgetcset(f, p1);
- while((c=Fgetc(f))!=-1 && alnum(c))
- f->dot.r.p2++;
- /* try filling out word to left */
- Fbgetcset(f, p1);
- while((c=Fbgetc(f))!=-1 && alnum(c))
- f->dot.r.p1--;
+ int c, i;
+ Rune *r, *l;
+
+ if(p1 > f->nrunes)
+ return;
+ f->dot.r.p1 = f->dot.r.p2 = p1;
+ for(i=0; left[i]; i++){
+ l = left[i];
+ r = right[i];
+ /* try left match */
+ if(p1 == 0){
+ Fgetcset(f, p1);
+ c = '\n';
+ }else{
+ Fgetcset(f, p1-1);
+ c = Fgetc(f);
+ }
+ if(c!=-1 && strrune(l, c)){
+ if(clickmatch(f, c, r[strrune(l, c)-l], 1)){
+ f->dot.r.p1 = p1;
+ f->dot.r.p2 = f->getcp-(c!='\n');
+ }
+ return;
+ }
+ /* try right match */
+ if(p1 == f->nrunes){
+ Fbgetcset(f, p1);
+ c = '\n';
+ }else{
+ Fbgetcset(f, p1+1);
+ c = Fbgetc(f);
+ }
+ if(c!=-1 && strrune(r, c)){
+ if(clickmatch(f, c, l[strrune(r, c)-r], -1)){
+ f->dot.r.p1 = f->getcp;
+ if(c!='\n' || f->getcp!=0 ||
+ (Fgetcset(f, (Posn)0),Fgetc(f))=='\n')
+ f->dot.r.p1++;
+ f->dot.r.p2 = p1+(p1<f->nrunes && c=='\n');
+ }
+ return;
+ }
+ }
+ /* try filling out word to right */
+ Fgetcset(f, p1);
+ while((c=Fgetc(f))!=-1 && alnum(c))
+ f->dot.r.p2++;
+ /* try filling out word to left */
+ Fbgetcset(f, p1);
+ while((c=Fbgetc(f))!=-1 && alnum(c))
+ f->dot.r.p1--;
}
diff --git a/sam/multi.c b/sam/multi.c
@@ -3,96 +3,96 @@
#include <libgen.h>
-List file;
-ushort tag;
+List file;
+ushort tag;
File *
newfile(void)
{
- File *f;
-
- inslist(&file, 0, (long)(f = Fopen()));
- f->tag = tag++;
- if(downloaded)
- outTs(Hnewname, f->tag);
- /* already sorted; file name is "" */
- return f;
+ File *f;
+
+ inslist(&file, 0, (long)(f = Fopen()));
+ f->tag = tag++;
+ if(downloaded)
+ outTs(Hnewname, f->tag);
+ /* already sorted; file name is "" */
+ return f;
}
int
whichmenu(File *f)
{
- int i;
+ int i;
- for(i=0; i<file.nused; i++)
- if(file.filepptr[i]==f)
- return i;
- return -1;
+ for(i=0; i<file.nused; i++)
+ if(file.filepptr[i]==f)
+ return i;
+ return -1;
}
void
delfile(File *f)
{
- int w = whichmenu(f);
-
- if(w < 0) /* e.g. x/./D */
- return;
- if(downloaded)
- outTs(Hdelname, f->tag);
- dellist(&file, w);
- Fclose(f);
+ int w = whichmenu(f);
+
+ if(w < 0) /* e.g. x/./D */
+ return;
+ if(downloaded)
+ outTs(Hdelname, f->tag);
+ dellist(&file, w);
+ Fclose(f);
}
void
sortname(File *f)
{
- int i, cmp, w;
- int dupwarned;
-
- w = whichmenu(f);
- dupwarned = FALSE;
- dellist(&file, w);
- if(f == cmd)
- i = 0;
- else for(i=0; i<file.nused; i++){
- cmp = Strcmp(&f->name, &file.filepptr[i]->name);
- if(cmp==0 && !dupwarned){
- dupwarned = TRUE;
- warn_S(Wdupname, &f->name);
- }else if(cmp<0 && (i>0 || cmd==0))
- break;
- }
- inslist(&file, i, (long)f);
- if(downloaded)
- outTsS(Hmovname, f->tag, &f->name);
+ int i, cmp, w;
+ int dupwarned;
+
+ w = whichmenu(f);
+ dupwarned = FALSE;
+ dellist(&file, w);
+ if(f == cmd)
+ i = 0;
+ else for(i=0; i<file.nused; i++){
+ cmp = Strcmp(&f->name, &file.filepptr[i]->name);
+ if(cmp==0 && !dupwarned){
+ dupwarned = TRUE;
+ warn_S(Wdupname, &f->name);
+ }else if(cmp<0 && (i>0 || cmd==0))
+ break;
+ }
+ inslist(&file, i, (long)f);
+ if(downloaded)
+ outTsS(Hmovname, f->tag, &f->name);
}
void
state(File *f, int cleandirty)
{
- if(f == cmd)
- return;
- if(downloaded && whichmenu(f)>=0){ /* else flist or menu */
- if(f->state==Dirty && cleandirty!=Dirty)
- outTs(Hclean, f->tag);
- else if(f->state!=Dirty && cleandirty==Dirty)
- outTs(Hdirty, f->tag);
- }
- f->state = cleandirty;
+ if(f == cmd)
+ return;
+ if(downloaded && whichmenu(f)>=0){ /* else flist or menu */
+ if(f->state==Dirty && cleandirty!=Dirty)
+ outTs(Hclean, f->tag);
+ else if(f->state!=Dirty && cleandirty==Dirty)
+ outTs(Hdirty, f->tag);
+ }
+ f->state = cleandirty;
}
File *
lookfile(String *s, int fuzzy)
{
- int i;
+ int i;
File *b = NULL;
char *sc = Strtoc(s);
size_t sl = strlen(sc);
- for(i=0; i<file.nused; i++){
+ for(i=0; i<file.nused; i++){
int l2;
- if(Strcmp(&file.filepptr[i]->name, s) == 0)
- return file.filepptr[i];
+ if(Strcmp(&file.filepptr[i]->name, s) == 0)
+ return file.filepptr[i];
if (fuzzy){
char *ac = Strtoc(&file.filepptr[i]->name);
@@ -105,5 +105,5 @@ lookfile(String *s, int fuzzy)
}
}
- return b;
+ return b;
}
diff --git a/sam/parse.h b/sam/parse.h
@@ -3,67 +3,67 @@ typedef struct Addr Addr;
typedef struct Cmd Cmd;
struct Addr
{
- char type; /* # (char addr), l (line addr), / ? . $ + - …
- union{
- String *re;
- Addr *aleft; /* left side of , and ; */
- } g;
- Posn num;
- Addr *next; /* or right side of , and ; …
+ char type; /* # (char addr), l (line addr), / ? . $ + - , ; */
+ union{
+ String *re;
+ Addr *aleft; /* left side of , and ; */
+ } g;
+ Posn num;
+ Addr *next; /* or right side of , and ; */
};
-#define are g.re
-#define left g.aleft
+#define are g.re
+#define left g.aleft
struct Cmd
{
- Addr *addr; /* address (range of text) */
- String *re; /* regular expression for e.…
- union{
- Cmd *cmd; /* target of x, g, {, etc. */
- String *text; /* text of a, c, i; rhs of…
- Addr *addr; /* address for m, t */
- } g;
- Cmd *next; /* pointer to next element in…
- short num;
- ushort flag; /* whatever */
- ushort cmdc; /* command character; 'x' e…
+ Addr *addr; /* address (range of text) */
+ String *re; /* regular expression for e.g. 'x' */
+ union{
+ Cmd *cmd; /* target of x, g, {, etc. */
+ String *text; /* text of a, c, i; rhs of s */
+ Addr *addr; /* address for m, t */
+ } g;
+ Cmd *next; /* pointer to next element in {} */
+ short num;
+ ushort flag; /* whatever */
+ ushort cmdc; /* command character; 'x' etc. */
};
-#define ccmd g.cmd
-#define ctext g.text
-#define caddr g.addr
+#define ccmd g.cmd
+#define ctext g.text
+#define caddr g.addr
extern struct cmdtab{
- ushort cmdc; /* command character */
- uchar text; /* takes a textual argument? */
- uchar regexp; /* takes a regular expression? */
- uchar addr; /* takes an address (m or t)? */
- uchar defcmd; /* default command; 0==>none */
- uchar defaddr; /* default address */
- uchar count; /* takes a count e.g. s2/// */
- char *token; /* takes text terminated by one of …
- int (*fn)(File*, Cmd*); /* function to call with parse t…
+ ushort cmdc; /* command character */
+ uchar text; /* takes a textual argument? */
+ uchar regexp; /* takes a regular expression? */
+ uchar addr; /* takes an address (m or t)? */
+ uchar defcmd; /* default command; 0==>none */
+ uchar defaddr; /* default address */
+ uchar count; /* takes a count e.g. s2/// */
+ char *token; /* takes text terminated by one of these */
+ int (*fn)(File*, Cmd*); /* function to call with parse tree */
}cmdtab[];
-enum Defaddr{ /* default addresses */
- aNo,
- aDot,
- aAll
+enum Defaddr{ /* default addresses */
+ aNo,
+ aDot,
+ aAll
};
-int nl_cmd(File*, Cmd*), a_cmd(File*, Cmd*), b_cmd(File*, Cmd*);
-int c_cmd(File*, Cmd*), cd_cmd(File*, Cmd*), d_cmd(File*, Cmd*);
-int D_cmd(File*, Cmd*), e_cmd(File*, Cmd*);
-int f_cmd(File*, Cmd*), g_cmd(File*, Cmd*), i_cmd(File*, Cmd*);
-int k_cmd(File*, Cmd*), m_cmd(File*, Cmd*), n_cmd(File*, Cmd*);
-int p_cmd(File*, Cmd*), q_cmd(File*, Cmd*);
-int s_cmd(File*, Cmd*), u_cmd(File*, Cmd*), w_cmd(File*, Cmd*);
-int x_cmd(File*, Cmd*), X_cmd(File*, Cmd*), plan9_cmd(File*, Cmd*);
-int eq_cmd(File*, Cmd*);
+int nl_cmd(File*, Cmd*), a_cmd(File*, Cmd*), b_cmd(File*, Cmd*);
+int c_cmd(File*, Cmd*), cd_cmd(File*, Cmd*), d_cmd(File*, Cmd*);
+int D_cmd(File*, Cmd*), e_cmd(File*, Cmd*);
+int f_cmd(File*, Cmd*), g_cmd(File*, Cmd*), i_cmd(File*, Cmd*);
+int k_cmd(File*, Cmd*), m_cmd(File*, Cmd*), n_cmd(File*, Cmd*);
+int p_cmd(File*, Cmd*), q_cmd(File*, Cmd*);
+int s_cmd(File*, Cmd*), u_cmd(File*, Cmd*), w_cmd(File*, Cmd*);
+int x_cmd(File*, Cmd*), X_cmd(File*, Cmd*), plan9_cmd(File*, Cmd*);
+int eq_cmd(File*, Cmd*);
-String *getregexp(int);
-Addr *newaddr(void);
-Address address(Addr*, Address, int);
-int cmdexec(File*, Cmd*);
+String *getregexp(int);
+Addr *newaddr(void);
+Address address(Addr*, Address, int);
+int cmdexec(File*, Cmd*);
diff --git a/sam/rasp.c b/sam/rasp.c
@@ -4,273 +4,273 @@
* GROWDATASIZE must be big enough that all errors go out as Hgrowdata's,
* so they will be scrolled into visibility in the ~~sam~~ window (yuck!).
*/
-#define GROWDATASIZE 50 /* if size is > this, send data w…
+#define GROWDATASIZE 50 /* if size is > this, send data with grow */
-void rcut(List*, Posn, Posn);
-int rterm(List*, Posn);
-void rgrow(List*, Posn, Posn);
+void rcut(List*, Posn, Posn);
+int rterm(List*, Posn);
+void rgrow(List*, Posn, Posn);
void
toterminal(File *f, int toterm)
{
- Buffer *t = f->transcript;
- Posn n, p0, p1, p2, delta = 0, deltacmd = 0;
- Range r;
- union{
- union Hdr g;
- Rune buf[8+GROWDATASIZE];
- }hdr;
- Posn growpos, grown;
+ Buffer *t = f->transcript;
+ Posn n, p0, p1, p2, delta = 0, deltacmd = 0;
+ Range r;
+ union{
+ union Hdr g;
+ Rune buf[8+GROWDATASIZE];
+ }hdr;
+ Posn growpos, grown;
- if(f->rasp == 0)
- return;
- if(f->marked)
- p0 = f->markp+sizeof(Mark)/RUNESIZE;
- else
- p0 = 0;
- grown = 0;
- noflush = 1;
- SET(growpos);
- while(Bread(t, (Rune*)&hdr, sizeof(hdr)/RUNESIZE, p0) > 0){
- switch(hdr.g.cs.c){
- default:
- fprintf(stderr, "char %c %.2x\n", hdr.g.cs.c, hdr.g.cs…
- panic("unknown in toterminal");
+ if(f->rasp == 0)
+ return;
+ if(f->marked)
+ p0 = f->markp+sizeof(Mark)/RUNESIZE;
+ else
+ p0 = 0;
+ grown = 0;
+ noflush = 1;
+ SET(growpos);
+ while(Bread(t, (Rune*)&hdr, sizeof(hdr)/RUNESIZE, p0) > 0){
+ switch(hdr.g.cs.c){
+ default:
+ fprintf(stderr, "char %c %.2x\n", hdr.g.cs.c, hdr.g.cs.c);
+ panic("unknown in toterminal");
- case 'd':
- if(grown){
- outTsll(Hgrow, f->tag, growpos, grown);
- grown = 0;
- }
- p1 = hdr.g.cll.l;
- p2 = hdr.g.cll.l1;
- if(p2 <= p1)
- panic("toterminal delete 0");
- if(f==cmd && p1<cmdpt){
- if(p2 <= cmdpt)
- deltacmd -= (p2-p1);
- else
- deltacmd -= cmdpt-p1;
- }
- p1 += delta;
- p2 += delta;
- p0 += sizeof(struct _cll)/RUNESIZE;
- if(toterm)
- outTsll(Hcut, f->tag, p1, p2-p1);
- rcut(f->rasp, p1, p2);
- delta -= p2-p1;
- break;
+ case 'd':
+ if(grown){
+ outTsll(Hgrow, f->tag, growpos, grown);
+ grown = 0;
+ }
+ p1 = hdr.g.cll.l;
+ p2 = hdr.g.cll.l1;
+ if(p2 <= p1)
+ panic("toterminal delete 0");
+ if(f==cmd && p1<cmdpt){
+ if(p2 <= cmdpt)
+ deltacmd -= (p2-p1);
+ else
+ deltacmd -= cmdpt-p1;
+ }
+ p1 += delta;
+ p2 += delta;
+ p0 += sizeof(struct _cll)/RUNESIZE;
+ if(toterm)
+ outTsll(Hcut, f->tag, p1, p2-p1);
+ rcut(f->rasp, p1, p2);
+ delta -= p2-p1;
+ break;
- case 'f':
- if(grown){
- outTsll(Hgrow, f->tag, growpos, grown);
- grown = 0;
- }
- n = hdr.g.cs.s;
- p0 += sizeof(struct _cs)/RUNESIZE + n;
- break;
+ case 'f':
+ if(grown){
+ outTsll(Hgrow, f->tag, growpos, grown);
+ grown = 0;
+ }
+ n = hdr.g.cs.s;
+ p0 += sizeof(struct _cs)/RUNESIZE + n;
+ break;
- case 'i':
- n = hdr.g.csl.s;
- p1 = hdr.g.csl.l;
- p0 += sizeof(struct _csl)/RUNESIZE + n;
- if(n <= 0)
- panic("toterminal insert 0");
- if(f==cmd && p1<cmdpt)
- deltacmd += n;
- p1 += delta;
- if(toterm){
- if(n>GROWDATASIZE || !rterm(f->rasp, p1)){
- rgrow(f->rasp, p1, n);
- if(grown && growpos+grown!=p1){
- outTsll(Hgrow, f->tag, growpos…
- grown = 0;
- }
- if(grown)
- grown += n;
- else{
- growpos = p1;
- grown = n;
- }
- }else{
- Rune *rp;
- if(grown){
- outTsll(Hgrow, f->tag, growpos…
- grown = 0;
- }
- rp = hdr.buf+sizeof(hdr.g.csl)/RUNESIZ…
- rgrow(f->rasp, p1, n);
- r = rdata(f->rasp, p1, n);
- if(r.p1!=p1 || r.p2!=p1+n)
- panic("rdata in toterminal");
- outTsllS(Hgrowdata, f->tag, p1, n, tmp…
- }
- }else{
- rgrow(f->rasp, p1, n);
- r = rdata(f->rasp, p1, n);
- if(r.p1!=p1 || r.p2!=p1+n)
- panic("rdata in toterminal");
- }
- delta += n;
- break;
- }
- }
- if(grown)
- outTsll(Hgrow, f->tag, growpos, grown);
- if(toterm)
- outTs(Hcheck0, f->tag);
- outflush();
- noflush = 0;
- if(f == cmd){
- cmdpt += deltacmd+cmdptadv;
- cmdptadv = 0;
- }
+ case 'i':
+ n = hdr.g.csl.s;
+ p1 = hdr.g.csl.l;
+ p0 += sizeof(struct _csl)/RUNESIZE + n;
+ if(n <= 0)
+ panic("toterminal insert 0");
+ if(f==cmd && p1<cmdpt)
+ deltacmd += n;
+ p1 += delta;
+ if(toterm){
+ if(n>GROWDATASIZE || !rterm(f->rasp, p1)){
+ rgrow(f->rasp, p1, n);
+ if(grown && growpos+grown!=p1){
+ outTsll(Hgrow, f->tag, growpos, grown);
+ grown = 0;
+ }
+ if(grown)
+ grown += n;
+ else{
+ growpos = p1;
+ grown = n;
+ }
+ }else{
+ Rune *rp;
+ if(grown){
+ outTsll(Hgrow, f->tag, growpos, grown);
+ grown = 0;
+ }
+ rp = hdr.buf+sizeof(hdr.g.csl)/RUNESIZE;
+ rgrow(f->rasp, p1, n);
+ r = rdata(f->rasp, p1, n);
+ if(r.p1!=p1 || r.p2!=p1+n)
+ panic("rdata in toterminal");
+ outTsllS(Hgrowdata, f->tag, p1, n, tmprstr(rp, n));
+ }
+ }else{
+ rgrow(f->rasp, p1, n);
+ r = rdata(f->rasp, p1, n);
+ if(r.p1!=p1 || r.p2!=p1+n)
+ panic("rdata in toterminal");
+ }
+ delta += n;
+ break;
+ }
+ }
+ if(grown)
+ outTsll(Hgrow, f->tag, growpos, grown);
+ if(toterm)
+ outTs(Hcheck0, f->tag);
+ outflush();
+ noflush = 0;
+ if(f == cmd){
+ cmdpt += deltacmd+cmdptadv;
+ cmdptadv = 0;
+ }
}
-#define M 0x80000000L
-#define P(i) r->longptr[i]
-#define T(i) (P(i)&M) /* in terminal */
-#define L(i) (P(i)&~M) /* length of this piece */
+#define M 0x80000000L
+#define P(i) r->longptr[i]
+#define T(i) (P(i)&M) /* in terminal */
+#define L(i) (P(i)&~M) /* length of this piece */
void
rcut(List *r, Posn p1, Posn p2)
{
- Posn p, x;
- int i;
+ Posn p, x;
+ int i;
- if(p1 == p2)
- panic("rcut 0");
- for(p=0,i=0; i<r->nused && p+L(i)<=p1; p+=L(i++))
- ;
- if(i == r->nused)
- panic("rcut 1");
- if(p<p1){ /* chop this piece */
- if(p+L(i) < p2){
- x = p1-p;
- p += L(i);
- }else{
- x = L(i)-(p2-p1);
- p = p2;
- }
- if(T(i))
- P(i) = x|M;
- else
- P(i) = x;
- i++;
- }
- while(i<r->nused && p+L(i)<=p2){
- p += L(i);
- dellist(r, i);
- }
- if(p<p2){
- if(i == r->nused)
- panic("rcut 2");
- x = L(i)-(p2-p);
- if(T(i))
- P(i) = x|M;
- else
- P(i) = x;
- }
- /* can we merge i and i-1 ? */
- if(i>0 && i<r->nused && T(i-1)==T(i)){
- x = L(i-1)+L(i);
- dellist(r, i--);
- if(T(i))
- P(i)=x|M;
- else
- P(i)=x;
- }
+ if(p1 == p2)
+ panic("rcut 0");
+ for(p=0,i=0; i<r->nused && p+L(i)<=p1; p+=L(i++))
+ ;
+ if(i == r->nused)
+ panic("rcut 1");
+ if(p<p1){ /* chop this piece */
+ if(p+L(i) < p2){
+ x = p1-p;
+ p += L(i);
+ }else{
+ x = L(i)-(p2-p1);
+ p = p2;
+ }
+ if(T(i))
+ P(i) = x|M;
+ else
+ P(i) = x;
+ i++;
+ }
+ while(i<r->nused && p+L(i)<=p2){
+ p += L(i);
+ dellist(r, i);
+ }
+ if(p<p2){
+ if(i == r->nused)
+ panic("rcut 2");
+ x = L(i)-(p2-p);
+ if(T(i))
+ P(i) = x|M;
+ else
+ P(i) = x;
+ }
+ /* can we merge i and i-1 ? */
+ if(i>0 && i<r->nused && T(i-1)==T(i)){
+ x = L(i-1)+L(i);
+ dellist(r, i--);
+ if(T(i))
+ P(i)=x|M;
+ else
+ P(i)=x;
+ }
}
void
rgrow(List *r, Posn p1, Posn n)
{
- Posn p;
- int i;
+ Posn p;
+ int i;
- if(n == 0)
- panic("rgrow 0");
- for(p=0,i=0; i<r->nused && p+L(i)<=p1; p+=L(i++))
- ;
- if(i == r->nused){ /* stick on end of file */
- if(p!=p1)
- panic("rgrow 1");
- if(i>0 && !T(i-1))
- P(i-1)+=n;
- else
- inslist(r, i, n);
- }else if(!T(i)) /* goes in this empty piece */
- P(i)+=n;
- else if(p==p1 && i>0 && !T(i-1)) /* special case; simplifies li…
- P(i-1)+=n;
- else if(p==p1)
- inslist(r, i, n);
- else{ /* must break piece in terminal */
- inslist(r, i+1, (L(i)-(p1-p))|M);
- inslist(r, i+1, n);
- P(i) = (p1-p)|M;
- }
+ if(n == 0)
+ panic("rgrow 0");
+ for(p=0,i=0; i<r->nused && p+L(i)<=p1; p+=L(i++))
+ ;
+ if(i == r->nused){ /* stick on end of file */
+ if(p!=p1)
+ panic("rgrow 1");
+ if(i>0 && !T(i-1))
+ P(i-1)+=n;
+ else
+ inslist(r, i, n);
+ }else if(!T(i)) /* goes in this empty piece */
+ P(i)+=n;
+ else if(p==p1 && i>0 && !T(i-1)) /* special case; simplifies life */
+ P(i-1)+=n;
+ else if(p==p1)
+ inslist(r, i, n);
+ else{ /* must break piece in terminal */
+ inslist(r, i+1, (L(i)-(p1-p))|M);
+ inslist(r, i+1, n);
+ P(i) = (p1-p)|M;
+ }
}
int
rterm(List *r, Posn p1)
{
- Posn p;
- int i;
+ Posn p;
+ int i;
- for(p = 0,i = 0; i<r->nused && p+L(i)<=p1; p+=L(i++))
- ;
- if(i==r->nused && (i==0 || !T(i-1)))
- return 0;
- return T(i);
+ for(p = 0,i = 0; i<r->nused && p+L(i)<=p1; p+=L(i++))
+ ;
+ if(i==r->nused && (i==0 || !T(i-1)))
+ return 0;
+ return T(i);
}
Range
rdata(List *r, Posn p1, Posn n)
{
- Posn p;
- int i;
- Range rg;
+ Posn p;
+ int i;
+ Range rg;
- if(n==0)
- panic("rdata 0");
- for(p = 0,i = 0; i<r->nused && p+L(i)<=p1; p+=L(i++))
- ;
- if(i==r->nused)
- panic("rdata 1");
- if(T(i)){
- n-=L(i)-(p1-p);
- if(n<=0){
- rg.p1 = rg.p2 = p1;
- return rg;
- }
- p+=L(i++);
- p1 = p;
- }
- if(T(i) || i==r->nused)
- panic("rdata 2");
- if(p+L(i)<p1+n)
- n = L(i)-(p1-p);
- rg.p1 = p1;
- rg.p2 = p1+n;
- if(p!=p1){
- inslist(r, i+1, L(i)-(p1-p));
- P(i)=p1-p;
- i++;
- }
- if(L(i)!=n){
- inslist(r, i+1, L(i)-n);
- P(i)=n;
- }
- P(i)|=M;
- /* now i is set; can we merge? */
- if(i<r->nused-1 && T(i+1)){
- P(i)=(n+=L(i+1))|M;
- dellist(r, i+1);
- }
- if(i>0 && T(i-1)){
- P(i)=(n+L(i-1))|M;
- dellist(r, i-1);
- }
- return rg;
+ if(n==0)
+ panic("rdata 0");
+ for(p = 0,i = 0; i<r->nused && p+L(i)<=p1; p+=L(i++))
+ ;
+ if(i==r->nused)
+ panic("rdata 1");
+ if(T(i)){
+ n-=L(i)-(p1-p);
+ if(n<=0){
+ rg.p1 = rg.p2 = p1;
+ return rg;
+ }
+ p+=L(i++);
+ p1 = p;
+ }
+ if(T(i) || i==r->nused)
+ panic("rdata 2");
+ if(p+L(i)<p1+n)
+ n = L(i)-(p1-p);
+ rg.p1 = p1;
+ rg.p2 = p1+n;
+ if(p!=p1){
+ inslist(r, i+1, L(i)-(p1-p));
+ P(i)=p1-p;
+ i++;
+ }
+ if(L(i)!=n){
+ inslist(r, i+1, L(i)-n);
+ P(i)=n;
+ }
+ P(i)|=M;
+ /* now i is set; can we merge? */
+ if(i<r->nused-1 && T(i+1)){
+ P(i)=(n+=L(i+1))|M;
+ dellist(r, i+1);
+ }
+ if(i>0 && T(i-1)){
+ P(i)=(n+L(i-1))|M;
+ dellist(r, i-1);
+ }
+ return rg;
}
diff --git a/sam/regexp.c b/sam/regexp.c
@@ -1,8 +1,8 @@
/* Copyright (c) 1998 Lucent Technologies - All rights reserved. */
#include "sam.h"
-Rangeset sel;
-String lastregexp;
+Rangeset sel;
+String lastregexp;
/*
* Machine Information
*/
@@ -10,72 +10,72 @@ typedef struct Inst Inst;
struct Inst
{
- long type; /* < 0x10000 ==> literal, otherwise action */
- union {
- int rsid;
- int rsubid;
- int class;
- struct Inst *rother;
- struct Inst *rright;
- } r;
- union{
- struct Inst *lleft;
- struct Inst *lnext;
- } l;
+ long type; /* < 0x10000 ==> literal, otherwise action */
+ union {
+ int rsid;
+ int rsubid;
+ int class;
+ struct Inst *rother;
+ struct Inst *rright;
+ } r;
+ union{
+ struct Inst *lleft;
+ struct Inst *lnext;
+ } l;
};
-#define sid r.rsid
-#define subid r.rsubid
-#define rclass r.class
-#define other r.rother
-#define right r.rright
-#define left l.lleft
-#define next l.lnext
-
-#define NPROG 1024
-Inst program[NPROG];
-Inst *progp;
-Inst *startinst; /* First inst. of program; might not be program…
-Inst *bstartinst; /* same for backwards machine */
+#define sid r.rsid
+#define subid r.rsubid
+#define rclass r.class
+#define other r.rother
+#define right r.rright
+#define left l.lleft
+#define next l.lnext
+
+#define NPROG 1024
+Inst program[NPROG];
+Inst *progp;
+Inst *startinst; /* First inst. of program; might not be program[0] */
+Inst *bstartinst; /* same for backwards machine */
typedef struct Ilist Ilist;
struct Ilist
{
- Inst *inst; /* Instruction of the thread */
- Rangeset se;
- Posn startp; /* first char of match */
+ Inst *inst; /* Instruction of the thread */
+ Rangeset se;
+ Posn startp; /* first char of match */
};
-#define NLIST 128
+#define NLIST 128
-Ilist *tl, *nl; /* This list, next list */
-Ilist list[2][NLIST];
-static Rangeset sempty;
+Ilist *tl, *nl; /* This list, next list */
+Ilist list[2][NLIST];
+static Rangeset sempty;
/*
* Actions and Tokens
*
- * 0x100xx are operators, value == precedence
- * 0x200xx are tokens, i.e. operands for operators
+ * 0x100xx are operators, value == precedence
+ * 0x200xx are tokens, i.e. operands for operators
*/
-#define OPERATOR 0x10000 /* Bitmask of all operators */
-#define START 0x10000 /* Start, used for marker o…
-#define RBRA 0x10001 /* Right bracket, ) */
-#define LBRA 0x10002 /* Left bracket, ( */
-#define OR 0x10003 /* Alternation, | */
-#define CAT 0x10004 /* Concatentation, implicit o…
-#define STAR 0x10005 /* Closure, * */
-#define PLUS 0x10006 /* a+ == aa* */
-#define QUEST 0x10007 /* a? == a|nothing, i.e. 0 …
-#define ANY 0x20000 /* Any character but newline,…
-#define NOP 0x20001 /* No operation, internal use…
-#define BOL 0x20002 /* Beginning of line, ^ */
-#define EOL 0x20003 /* End of line, $ */
-#define CCLASS 0x20004 /* Character class, [] */
-#define NCCLASS 0x20005 /* Negated character clas…
-#define END 0x20077 /* Terminate: match found */
-
-#define ISATOR 0x10000
-#define ISAND 0x20000
+#define OPERATOR 0x10000 /* Bitmask of all operators */
+#define START 0x10000 /* Start, used for marker on stack */
+#define RBRA 0x10001 /* Right bracket, ) */
+#define LBRA 0x10002 /* Left bracket, ( */
+#define OR 0x10003 /* Alternation, | */
+#define CAT 0x10004 /* Concatentation, implicit operator */
+#define STAR 0x10005 /* Closure, * */
+#define PLUS 0x10006 /* a+ == aa* */
+#define QUEST 0x10007 /* a? == a|nothing, i.e. 0 or 1 a's */
+#define ANY 0x20000 /* Any character but newline, . */
+#define NOP 0x20001 /* No operation, internal use only */
+#define BOL 0x20002 /* Beginning of line, ^ */
+#define EOL 0x20003 /* End of line, $ */
+#define CCLASS 0x20004 /* Character class, [] */
+#define NCCLASS 0x20005 /* Negated character class, [^] */
+#define END 0x20077 /* Terminate: match found */
+
+#define ISATOR 0x10000
+#define ISAND 0x20000
/*
* Parser Information
@@ -83,729 +83,729 @@ static Rangeset sempty;
typedef struct Node Node;
struct Node
{
- Inst *first;
- Inst *last;
+ Inst *first;
+ Inst *last;
};
-#define NSTACK 20
-Node andstack[NSTACK];
-Node *andp;
-int atorstack[NSTACK];
-int *atorp;
-int lastwasand; /* Last token was operand */
-int cursubid;
-int subidstack[NSTACK];
-int *subidp;
-int backwards;
-int nbra;
-Rune *exprp; /* pointer to next character in source expr…
-#define DCLASS 10 /* allocation increment */
-int nclass; /* number active */
-int Nclass; /* high water mark */
-Rune **class;
-int negateclass;
-
-void addinst(Ilist *l, Inst *inst, Rangeset *sep);
-void newmatch(Rangeset*);
-void bnewmatch(Rangeset*);
-void pushand(Inst*, Inst*);
-void pushator(int);
-Node *popand(int);
-int popator(void);
-void startlex(Rune*);
-int lex(void);
-void operator(int);
-void operand(int);
-void evaluntil(int);
-void optimize(Inst*);
-void bldcclass(void);
+#define NSTACK 20
+Node andstack[NSTACK];
+Node *andp;
+int atorstack[NSTACK];
+int *atorp;
+int lastwasand; /* Last token was operand */
+int cursubid;
+int subidstack[NSTACK];
+int *subidp;
+int backwards;
+int nbra;
+Rune *exprp; /* pointer to next character in source expression */
+#define DCLASS 10 /* allocation increment */
+int nclass; /* number active */
+int Nclass; /* high water mark */
+Rune **class;
+int negateclass;
+
+void addinst(Ilist *l, Inst *inst, Rangeset *sep);
+void newmatch(Rangeset*);
+void bnewmatch(Rangeset*);
+void pushand(Inst*, Inst*);
+void pushator(int);
+Node *popand(int);
+int popator(void);
+void startlex(Rune*);
+int lex(void);
+void operator(int);
+void operand(int);
+void evaluntil(int);
+void optimize(Inst*);
+void bldcclass(void);
void
regerror(Err e)
{
- Strzero(&lastregexp);
- error(e);
+ Strzero(&lastregexp);
+ error(e);
}
void
regerror_c(Err e, int c)
{
- Strzero(&lastregexp);
- error_c(e, c);
+ Strzero(&lastregexp);
+ error_c(e, c);
}
Inst *
newinst(int t)
{
- if(progp >= &program[NPROG])
- regerror(Etoolong);
- progp->type = t;
- progp->left = 0;
- progp->right = 0;
- return progp++;
+ if(progp >= &program[NPROG])
+ regerror(Etoolong);
+ progp->type = t;
+ progp->left = 0;
+ progp->right = 0;
+ return progp++;
}
Inst *
realcompile(Rune *s)
{
- int token;
-
- startlex(s);
- atorp = atorstack;
- andp = andstack;
- subidp = subidstack;
- cursubid = 0;
- lastwasand = FALSE;
- /* Start with a low priority operator to prime parser */
- pushator(START-1);
- while((token=lex()) != END){
- if((token&ISATOR) == OPERATOR)
- operator(token);
- else
- operand(token);
- }
- /* Close with a low priority operator */
- evaluntil(START);
- /* Force END */
- operand(END);
- evaluntil(START);
- if(nbra)
- regerror(Eleftpar);
- --andp; /* points to first and only operand */
- return andp->first;
+ int token;
+
+ startlex(s);
+ atorp = atorstack;
+ andp = andstack;
+ subidp = subidstack;
+ cursubid = 0;
+ lastwasand = FALSE;
+ /* Start with a low priority operator to prime parser */
+ pushator(START-1);
+ while((token=lex()) != END){
+ if((token&ISATOR) == OPERATOR)
+ operator(token);
+ else
+ operand(token);
+ }
+ /* Close with a low priority operator */
+ evaluntil(START);
+ /* Force END */
+ operand(END);
+ evaluntil(START);
+ if(nbra)
+ regerror(Eleftpar);
+ --andp; /* points to first and only operand */
+ return andp->first;
}
void
compile(String *s)
{
- int i;
- Inst *oprogp;
-
- if(Strcmp(s, &lastregexp)==0)
- return;
- for(i=0; i<nclass; i++)
- free(class[i]);
- nclass = 0;
- progp = program;
- backwards = FALSE;
- startinst = realcompile(s->s);
- optimize(program);
- oprogp = progp;
- backwards = TRUE;
- bstartinst = realcompile(s->s);
- optimize(oprogp);
- Strduplstr(&lastregexp, s);
+ int i;
+ Inst *oprogp;
+
+ if(Strcmp(s, &lastregexp)==0)
+ return;
+ for(i=0; i<nclass; i++)
+ free(class[i]);
+ nclass = 0;
+ progp = program;
+ backwards = FALSE;
+ startinst = realcompile(s->s);
+ optimize(program);
+ oprogp = progp;
+ backwards = TRUE;
+ bstartinst = realcompile(s->s);
+ optimize(oprogp);
+ Strduplstr(&lastregexp, s);
}
void
operand(int t)
{
- Inst *i;
- if(lastwasand)
- operator(CAT); /* catenate is implicit */
- i = newinst(t);
- if(t == CCLASS){
- if(negateclass)
- i->type = NCCLASS; /* UGH */
- i->rclass = nclass-1; /* UGH */
- }
- pushand(i, i);
- lastwasand = TRUE;
+ Inst *i;
+ if(lastwasand)
+ operator(CAT); /* catenate is implicit */
+ i = newinst(t);
+ if(t == CCLASS){
+ if(negateclass)
+ i->type = NCCLASS; /* UGH */
+ i->rclass = nclass-1; /* UGH */
+ }
+ pushand(i, i);
+ lastwasand = TRUE;
}
void
operator(int t)
{
- if(t==RBRA && --nbra<0)
- regerror(Erightpar);
- if(t==LBRA){
+ if(t==RBRA && --nbra<0)
+ regerror(Erightpar);
+ if(t==LBRA){
/*
- * if(++cursubid >= NSUBEXP)
- * regerror(Esubexp);
+ * if(++cursubid >= NSUBEXP)
+ * regerror(Esubexp);
*/
- cursubid++; /* silently ignored */
- nbra++;
- if(lastwasand)
- operator(CAT);
- }else
- evaluntil(t);
- if(t!=RBRA)
- pushator(t);
- lastwasand = FALSE;
- if(t==STAR || t==QUEST || t==PLUS || t==RBRA)
- lastwasand = TRUE; /* these look like operands */
+ cursubid++; /* silently ignored */
+ nbra++;
+ if(lastwasand)
+ operator(CAT);
+ }else
+ evaluntil(t);
+ if(t!=RBRA)
+ pushator(t);
+ lastwasand = FALSE;
+ if(t==STAR || t==QUEST || t==PLUS || t==RBRA)
+ lastwasand = TRUE; /* these look like operands */
}
void
cant(char *s)
{
- char buf[100];
+ char buf[100];
- sprint(buf, "regexp: can't happen: %s", s);
- panic(buf);
+ sprint(buf, "regexp: can't happen: %s", s);
+ panic(buf);
}
void
pushand(Inst *f, Inst *l)
{
- if(andp >= &andstack[NSTACK])
- cant("operand stack overflow");
- andp->first = f;
- andp->last = l;
- andp++;
+ if(andp >= &andstack[NSTACK])
+ cant("operand stack overflow");
+ andp->first = f;
+ andp->last = l;
+ andp++;
}
void
pushator(int t)
{
- if(atorp >= &atorstack[NSTACK])
- cant("operator stack overflow");
- *atorp++=t;
- if(cursubid >= NSUBEXP)
- *subidp++= -1;
- else
- *subidp++=cursubid;
+ if(atorp >= &atorstack[NSTACK])
+ cant("operator stack overflow");
+ *atorp++=t;
+ if(cursubid >= NSUBEXP)
+ *subidp++= -1;
+ else
+ *subidp++=cursubid;
}
Node *
popand(int op)
{
- if(andp <= &andstack[0])
- if(op)
- regerror_c(Emissop, op);
- else
- regerror(Ebadregexp);
- return --andp;
+ if(andp <= &andstack[0])
+ if(op)
+ regerror_c(Emissop, op);
+ else
+ regerror(Ebadregexp);
+ return --andp;
}
int
popator(void)
{
- if(atorp <= &atorstack[0])
- cant("operator stack underflow");
- --subidp;
- return *--atorp;
+ if(atorp <= &atorstack[0])
+ cant("operator stack underflow");
+ --subidp;
+ return *--atorp;
}
void
evaluntil(int pri)
{
- Node *op1, *op2, *t;
- Inst *inst1, *inst2;
-
- while(pri==RBRA || atorp[-1]>=pri){
- switch(popator()){
- case LBRA:
- op1 = popand('(');
- inst2 = newinst(RBRA);
- inst2->subid = *subidp;
- op1->last->next = inst2;
- inst1 = newinst(LBRA);
- inst1->subid = *subidp;
- inst1->next = op1->first;
- pushand(inst1, inst2);
- return; /* must have been RBRA */
- default:
- panic("unknown regexp operator");
- break;
- case OR:
- op2 = popand('|');
- op1 = popand('|');
- inst2 = newinst(NOP);
- op2->last->next = inst2;
- op1->last->next = inst2;
- inst1 = newinst(OR);
- inst1->right = op1->first;
- inst1->left = op2->first;
- pushand(inst1, inst2);
- break;
- case CAT:
- op2 = popand(0);
- op1 = popand(0);
- if(backwards && op2->first->type!=END)
- t = op1, op1 = op2, op2 = t;
- op1->last->next = op2->first;
- pushand(op1->first, op2->last);
- break;
- case STAR:
- op2 = popand('*');
- inst1 = newinst(OR);
- op2->last->next = inst1;
- inst1->right = op2->first;
- pushand(inst1, inst1);
- break;
- case PLUS:
- op2 = popand('+');
- inst1 = newinst(OR);
- op2->last->next = inst1;
- inst1->right = op2->first;
- pushand(op2->first, inst1);
- break;
- case QUEST:
- op2 = popand('?');
- inst1 = newinst(OR);
- inst2 = newinst(NOP);
- inst1->left = inst2;
- inst1->right = op2->first;
- op2->last->next = inst2;
- pushand(inst1, inst2);
- break;
- }
- }
+ Node *op1, *op2, *t;
+ Inst *inst1, *inst2;
+
+ while(pri==RBRA || atorp[-1]>=pri){
+ switch(popator()){
+ case LBRA:
+ op1 = popand('(');
+ inst2 = newinst(RBRA);
+ inst2->subid = *subidp;
+ op1->last->next = inst2;
+ inst1 = newinst(LBRA);
+ inst1->subid = *subidp;
+ inst1->next = op1->first;
+ pushand(inst1, inst2);
+ return; /* must have been RBRA */
+ default:
+ panic("unknown regexp operator");
+ break;
+ case OR:
+ op2 = popand('|');
+ op1 = popand('|');
+ inst2 = newinst(NOP);
+ op2->last->next = inst2;
+ op1->last->next = inst2;
+ inst1 = newinst(OR);
+ inst1->right = op1->first;
+ inst1->left = op2->first;
+ pushand(inst1, inst2);
+ break;
+ case CAT:
+ op2 = popand(0);
+ op1 = popand(0);
+ if(backwards && op2->first->type!=END)
+ t = op1, op1 = op2, op2 = t;
+ op1->last->next = op2->first;
+ pushand(op1->first, op2->last);
+ break;
+ case STAR:
+ op2 = popand('*');
+ inst1 = newinst(OR);
+ op2->last->next = inst1;
+ inst1->right = op2->first;
+ pushand(inst1, inst1);
+ break;
+ case PLUS:
+ op2 = popand('+');
+ inst1 = newinst(OR);
+ op2->last->next = inst1;
+ inst1->right = op2->first;
+ pushand(op2->first, inst1);
+ break;
+ case QUEST:
+ op2 = popand('?');
+ inst1 = newinst(OR);
+ inst2 = newinst(NOP);
+ inst1->left = inst2;
+ inst1->right = op2->first;
+ op2->last->next = inst2;
+ pushand(inst1, inst2);
+ break;
+ }
+ }
}
void
optimize(Inst *start)
{
- Inst *inst, *target;
-
- for(inst=start; inst->type!=END; inst++){
- target = inst->next;
- while(target->type == NOP)
- target = target->next;
- inst->next = target;
- }
+ Inst *inst, *target;
+
+ for(inst=start; inst->type!=END; inst++){
+ target = inst->next;
+ while(target->type == NOP)
+ target = target->next;
+ inst->next = target;
+ }
}
-#ifdef DEBUG
+#ifdef DEBUG
void
dumpstack(void){
- Node *stk;
- int *ip;
-
- dprint("operators\n");
- for(ip = atorstack; ip<atorp; ip++)
- dprint("0%o\n", *ip);
- dprint("operands\n");
- for(stk = andstack; stk<andp; stk++)
- dprint("0%o\t0%o\n", stk->first->type, stk->last->type);
+ Node *stk;
+ int *ip;
+
+ dprint("operators\n");
+ for(ip = atorstack; ip<atorp; ip++)
+ dprint("0%o\n", *ip);
+ dprint("operands\n");
+ for(stk = andstack; stk<andp; stk++)
+ dprint("0%o\t0%o\n", stk->first->type, stk->last->type);
}
void
dump(void){
- Inst *l;
+ Inst *l;
- l = program;
- do{
- dprint("%d:\t0%o\t%d\t%d\n", l-program, l->type,
- l->left-program, l->right-program);
- }while(l++->type);
+ l = program;
+ do{
+ dprint("%d:\t0%o\t%d\t%d\n", l-program, l->type,
+ l->left-program, l->right-program);
+ }while(l++->type);
}
#endif
void
startlex(Rune *s)
{
- exprp = s;
- nbra = 0;
+ exprp = s;
+ nbra = 0;
}
int
lex(void){
- int c= *exprp++;
-
- switch(c){
- case '\\':
- if(*exprp)
- if((c= *exprp++)=='n')
- c='\n';
- break;
- case 0:
- c = END;
- --exprp; /* In case we come here again */
- break;
- case '*':
- c = STAR;
- break;
- case '?':
- c = QUEST;
- break;
- case '+':
- c = PLUS;
- break;
- case '|':
- c = OR;
- break;
- case '.':
- c = ANY;
- break;
- case '(':
- c = LBRA;
- break;
- case ')':
- c = RBRA;
- break;
- case '^':
- c = BOL;
- break;
- case '$':
- c = EOL;
- break;
- case '[':
- c = CCLASS;
- bldcclass();
- break;
- }
- return c;
+ int c= *exprp++;
+
+ switch(c){
+ case '\\':
+ if(*exprp)
+ if((c= *exprp++)=='n')
+ c='\n';
+ break;
+ case 0:
+ c = END;
+ --exprp; /* In case we come here again */
+ break;
+ case '*':
+ c = STAR;
+ break;
+ case '?':
+ c = QUEST;
+ break;
+ case '+':
+ c = PLUS;
+ break;
+ case '|':
+ c = OR;
+ break;
+ case '.':
+ c = ANY;
+ break;
+ case '(':
+ c = LBRA;
+ break;
+ case ')':
+ c = RBRA;
+ break;
+ case '^':
+ c = BOL;
+ break;
+ case '$':
+ c = EOL;
+ break;
+ case '[':
+ c = CCLASS;
+ bldcclass();
+ break;
+ }
+ return c;
}
long
nextrec(void){
- if(exprp[0]==0 || (exprp[0]=='\\' && exprp[1]==0))
- regerror(Ebadclass);
- if(exprp[0] == '\\'){
- exprp++;
- if(*exprp=='n'){
- exprp++;
- return '\n';
- }
- return *exprp++|0x10000;
- }
- return *exprp++;
+ if(exprp[0]==0 || (exprp[0]=='\\' && exprp[1]==0))
+ regerror(Ebadclass);
+ if(exprp[0] == '\\'){
+ exprp++;
+ if(*exprp=='n'){
+ exprp++;
+ return '\n';
+ }
+ return *exprp++|0x10000;
+ }
+ return *exprp++;
}
void
bldcclass(void)
{
- long c1, c2, n, na;
- Rune *classp;
-
- classp = emalloc(DCLASS*RUNESIZE);
- n = 0;
- na = DCLASS;
- /* we have already seen the '[' */
- if(*exprp == '^'){
- classp[n++] = '\n'; /* don't match newline in negate ca…
- negateclass = TRUE;
- exprp++;
- }else
- negateclass = FALSE;
- while((c1 = nextrec()) != ']'){
- if(c1 == '-'){
+ long c1, c2, n, na;
+ Rune *classp;
+
+ classp = emalloc(DCLASS*RUNESIZE);
+ n = 0;
+ na = DCLASS;
+ /* we have already seen the '[' */
+ if(*exprp == '^'){
+ classp[n++] = '\n'; /* don't match newline in negate case */
+ negateclass = TRUE;
+ exprp++;
+ }else
+ negateclass = FALSE;
+ while((c1 = nextrec()) != ']'){
+ if(c1 == '-'){
Error:
- free(classp);
- regerror(Ebadclass);
- }
- if(n+4 >= na){ /* 3 runes plus NUL */
- na += DCLASS;
- classp = erealloc(classp, na*RUNESIZE);
- }
- if(*exprp == '-'){
- exprp++; /* eat '-' */
- if((c2 = nextrec()) == ']')
- goto Error;
- classp[n+0] = 0xFFFF;
- classp[n+1] = c1;
- classp[n+2] = c2;
- n += 3;
- }else
- classp[n++] = c1;
- }
- classp[n] = 0;
- if(nclass == Nclass){
- Nclass += DCLASS;
- class = erealloc(class, Nclass*sizeof(Rune*));
- }
- class[nclass++] = classp;
+ free(classp);
+ regerror(Ebadclass);
+ }
+ if(n+4 >= na){ /* 3 runes plus NUL */
+ na += DCLASS;
+ classp = erealloc(classp, na*RUNESIZE);
+ }
+ if(*exprp == '-'){
+ exprp++; /* eat '-' */
+ if((c2 = nextrec()) == ']')
+ goto Error;
+ classp[n+0] = 0xFFFF;
+ classp[n+1] = c1;
+ classp[n+2] = c2;
+ n += 3;
+ }else
+ classp[n++] = c1;
+ }
+ classp[n] = 0;
+ if(nclass == Nclass){
+ Nclass += DCLASS;
+ class = erealloc(class, Nclass*sizeof(Rune*));
+ }
+ class[nclass++] = classp;
}
int
classmatch(int classno, int c, int negate)
{
- Rune *p;
-
- p = class[classno];
- while(*p){
- if(*p == 0xFFFF){
- if(p[1]<=c && c<=p[2])
- return !negate;
- p += 3;
- }else if(*p++ == c)
- return !negate;
- }
- return negate;
+ Rune *p;
+
+ p = class[classno];
+ while(*p){
+ if(*p == 0xFFFF){
+ if(p[1]<=c && c<=p[2])
+ return !negate;
+ p += 3;
+ }else if(*p++ == c)
+ return !negate;
+ }
+ return negate;
}
/*
* Note optimization in addinst:
- * *l must be pending when addinst called; if *l has been looked
- * at already, the optimization is a bug.
+ * *l must be pending when addinst called; if *l has been looked
+ * at already, the optimization is a bug.
*/
void
addinst(Ilist *l, Inst *inst, Rangeset *sep)
{
- Ilist *p;
-
- for(p = l; p->inst; p++){
- if(p->inst==inst){
- if((sep)->p[0].p1 < p->se.p[0].p1)
- p->se= *sep; /* this would be bug */
- return; /* It's already there */
- }
- }
- p->inst = inst;
- p->se= *sep;
- (p+1)->inst = 0;
+ Ilist *p;
+
+ for(p = l; p->inst; p++){
+ if(p->inst==inst){
+ if((sep)->p[0].p1 < p->se.p[0].p1)
+ p->se= *sep; /* this would be bug */
+ return; /* It's already there */
+ }
+ }
+ p->inst = inst;
+ p->se= *sep;
+ (p+1)->inst = 0;
}
int
execute(File *f, Posn startp, Posn eof)
{
- int flag = 0;
- Inst *inst;
- Ilist *tlp;
- Posn p = startp;
- int nnl = 0, ntl;
- int c;
- int wrapped = 0;
- int startchar = startinst->type<OPERATOR? startinst->type : 0;
-
- list[0][0].inst = list[1][0].inst = 0;
- sel.p[0].p1 = -1;
- Fgetcset(f, startp);
- /* Execute machine once for each character */
- for(;;p++){
- doloop:
- c = Fgetc(f);
- if(p>=eof || c<0){
- switch(wrapped++){
- case 0: /* let loop run one more click …
- case 2:
- break;
- case 1: /* expired; wrap to beginning */
- if(sel.p[0].p1>=0 || eof!=INFINITY)
- goto Return;
- list[0][0].inst = list[1][0].inst = 0;
- Fgetcset(f, (Posn)0);
- p = 0;
- goto doloop;
- default:
- goto Return;
- }
- }else if(((wrapped && p>=startp) || sel.p[0].p1>0) && nnl==0)
- break;
- /* fast check for first char */
- if(startchar && nnl==0 && c!=startchar)
- continue;
- tl = list[flag];
- nl = list[flag^=1];
- nl->inst = 0;
- ntl = nnl;
- nnl = 0;
- if(sel.p[0].p1<0 && (!wrapped || p<startp || startp==eof)){
- /* Add first instruction to this list */
- if(++ntl >= NLIST)
- Overflow:
- error(Eoverflow);
- sempty.p[0].p1 = p;
- addinst(tl, startinst, &sempty);
- }
- /* Execute machine until this list is empty */
- for(tlp = tl; inst = tlp->inst; tlp++){ /* assignment =…
- Switchstmt:
- switch(inst->type){
- default: /* regular character */
- if(inst->type==c){
- Addinst:
- if(++nnl >= NLIST)
- goto Overflow;
- addinst(nl, inst->next, &tlp->se);
- }
- break;
- case LBRA:
- if(inst->subid>=0)
- tlp->se.p[inst->subid].p1 = p;
- inst = inst->next;
- goto Switchstmt;
- case RBRA:
- if(inst->subid>=0)
- tlp->se.p[inst->subid].p2 = p;
- inst = inst->next;
- goto Switchstmt;
- case ANY:
- if(c!='\n')
- goto Addinst;
- break;
- case BOL:
- if(p == 0){
- Step:
- inst = inst->next;
- goto Switchstmt;
- }
- if(f->getci > 1){
- if(f->getcbuf[f->getci-2]=='\n')
- goto Step;
- }else{
- Rune c;
- if(Fchars(f, &c, p-1, p)==1 && c=='\n')
- goto Step;
- }
- break;
- case EOL:
- if(c == '\n')
- goto Step;
- break;
- case CCLASS:
- if(c>=0 && classmatch(inst->rclass, c, 0))
- goto Addinst;
- break;
- case NCCLASS:
- if(c>=0 && classmatch(inst->rclass, c, 1))
- goto Addinst;
- break;
- case OR:
- /* evaluate right choice later */
- if(++ntl >= NLIST)
- goto Overflow;
- addinst(tlp, inst->right, &tlp->se);
- /* efficiency: advance and re-evaluate */
- inst = inst->left;
- goto Switchstmt;
- case END: /* Match! */
- tlp->se.p[0].p2 = p;
- newmatch(&tlp->se);
- break;
- }
- }
- }
+ int flag = 0;
+ Inst *inst;
+ Ilist *tlp;
+ Posn p = startp;
+ int nnl = 0, ntl;
+ int c;
+ int wrapped = 0;
+ int startchar = startinst->type<OPERATOR? startinst->type : 0;
+
+ list[0][0].inst = list[1][0].inst = 0;
+ sel.p[0].p1 = -1;
+ Fgetcset(f, startp);
+ /* Execute machine once for each character */
+ for(;;p++){
+ doloop:
+ c = Fgetc(f);
+ if(p>=eof || c<0){
+ switch(wrapped++){
+ case 0: /* let loop run one more click */
+ case 2:
+ break;
+ case 1: /* expired; wrap to beginning */
+ if(sel.p[0].p1>=0 || eof!=INFINITY)
+ goto Return;
+ list[0][0].inst = list[1][0].inst = 0;
+ Fgetcset(f, (Posn)0);
+ p = 0;
+ goto doloop;
+ default:
+ goto Return;
+ }
+ }else if(((wrapped && p>=startp) || sel.p[0].p1>0) && nnl==0)
+ break;
+ /* fast check for first char */
+ if(startchar && nnl==0 && c!=startchar)
+ continue;
+ tl = list[flag];
+ nl = list[flag^=1];
+ nl->inst = 0;
+ ntl = nnl;
+ nnl = 0;
+ if(sel.p[0].p1<0 && (!wrapped || p<startp || startp==eof)){
+ /* Add first instruction to this list */
+ if(++ntl >= NLIST)
+ Overflow:
+ error(Eoverflow);
+ sempty.p[0].p1 = p;
+ addinst(tl, startinst, &sempty);
+ }
+ /* Execute machine until this list is empty */
+ for(tlp = tl; inst = tlp->inst; tlp++){ /* assignment = */
+ Switchstmt:
+ switch(inst->type){
+ default: /* regular character */
+ if(inst->type==c){
+ Addinst:
+ if(++nnl >= NLIST)
+ goto Overflow;
+ addinst(nl, inst->next, &tlp->se);
+ }
+ break;
+ case LBRA:
+ if(inst->subid>=0)
+ tlp->se.p[inst->subid].p1 = p;
+ inst = inst->next;
+ goto Switchstmt;
+ case RBRA:
+ if(inst->subid>=0)
+ tlp->se.p[inst->subid].p2 = p;
+ inst = inst->next;
+ goto Switchstmt;
+ case ANY:
+ if(c!='\n')
+ goto Addinst;
+ break;
+ case BOL:
+ if(p == 0){
+ Step:
+ inst = inst->next;
+ goto Switchstmt;
+ }
+ if(f->getci > 1){
+ if(f->getcbuf[f->getci-2]=='\n')
+ goto Step;
+ }else{
+ Rune c;
+ if(Fchars(f, &c, p-1, p)==1 && c=='\n')
+ goto Step;
+ }
+ break;
+ case EOL:
+ if(c == '\n')
+ goto Step;
+ break;
+ case CCLASS:
+ if(c>=0 && classmatch(inst->rclass, c, 0))
+ goto Addinst;
+ break;
+ case NCCLASS:
+ if(c>=0 && classmatch(inst->rclass, c, 1))
+ goto Addinst;
+ break;
+ case OR:
+ /* evaluate right choice later */
+ if(++ntl >= NLIST)
+ goto Overflow;
+ addinst(tlp, inst->right, &tlp->se);
+ /* efficiency: advance and re-evaluate */
+ inst = inst->left;
+ goto Switchstmt;
+ case END: /* Match! */
+ tlp->se.p[0].p2 = p;
+ newmatch(&tlp->se);
+ break;
+ }
+ }
+ }
Return:
- return sel.p[0].p1>=0;
+ return sel.p[0].p1>=0;
}
void
newmatch(Rangeset *sp)
{
- int i;
+ int i;
- if(sel.p[0].p1<0 || sp->p[0].p1<sel.p[0].p1 ||
- (sp->p[0].p1==sel.p[0].p1 && sp->p[0].p2>sel.p[0].p2))
- for(i = 0; i<NSUBEXP; i++)
- sel.p[i] = sp->p[i];
+ if(sel.p[0].p1<0 || sp->p[0].p1<sel.p[0].p1 ||
+ (sp->p[0].p1==sel.p[0].p1 && sp->p[0].p2>sel.p[0].p2))
+ for(i = 0; i<NSUBEXP; i++)
+ sel.p[i] = sp->p[i];
}
int
bexecute(File *f, Posn startp)
{
- int flag = 0;
- Inst *inst;
- Ilist *tlp;
- Posn p = startp;
- int nnl = 0, ntl;
- int c;
- int wrapped = 0;
- int startchar = bstartinst->type<OPERATOR? bstartinst->type : 0;
-
- list[0][0].inst = list[1][0].inst = 0;
- sel.p[0].p1= -1;
- Fgetcset(f, startp);
- /* Execute machine once for each character, including terminal NUL */
- for(;;--p){
- doloop:
- if((c = Fbgetc(f))==-1){
- switch(wrapped++){
- case 0: /* let loop run one more click …
- case 2:
- break;
- case 1: /* expired; wrap to end */
- if(sel.p[0].p1>=0)
- case 3:
- goto Return;
- list[0][0].inst = list[1][0].inst = 0;
- Fgetcset(f, f->nrunes);
- p = f->nrunes;
- goto doloop;
- default:
- goto Return;
- }
- }else if(((wrapped && p<=startp) || sel.p[0].p1>0) && nnl==0)
- break;
- /* fast check for first char */
- if(startchar && nnl==0 && c!=startchar)
- continue;
- tl = list[flag];
- nl = list[flag^=1];
- nl->inst = 0;
- ntl = nnl;
- nnl = 0;
- if(sel.p[0].p1<0 && (!wrapped || p>startp)){
- /* Add first instruction to this list */
- if(++ntl >= NLIST)
- Overflow:
- error(Eoverflow);
- /* the minus is so the optimizations in addinst work */
- sempty.p[0].p1 = -p;
- addinst(tl, bstartinst, &sempty);
- }
- /* Execute machine until this list is empty */
- for(tlp = tl; inst = tlp->inst; tlp++){ /* assignment =…
- Switchstmt:
- switch(inst->type){
- default: /* regular character */
- if(inst->type == c){
- Addinst:
- if(++nnl >= NLIST)
- goto Overflow;
- addinst(nl, inst->next, &tlp->se);
- }
- break;
- case LBRA:
- if(inst->subid>=0)
- tlp->se.p[inst->subid].p1 = p;
- inst = inst->next;
- goto Switchstmt;
- case RBRA:
- if(inst->subid >= 0)
- tlp->se.p[inst->subid].p2 = p;
- inst = inst->next;
- goto Switchstmt;
- case ANY:
- if(c != '\n')
- goto Addinst;
- break;
- case BOL:
- if(c=='\n' || p==0){
- Step:
- inst = inst->next;
- goto Switchstmt;
- }
- break;
- case EOL:
- if(f->getci<f->ngetc-1){
- if(f->getcbuf[f->getci+1]=='\n')
- goto Step;
- }else if(p<f->nrunes-1){
- Rune c;
- if(Fchars(f, &c, p, p+1)==1 && c=='\n')
- goto Step;
- }
- break;
- case CCLASS:
- if(c>=0 && classmatch(inst->rclass, c, 0))
- goto Addinst;
- break;
- case NCCLASS:
- if(c>=0 && classmatch(inst->rclass, c, 1))
- goto Addinst;
- break;
- case OR:
- /* evaluate right choice later */
- if(++ntl >= NLIST)
- goto Overflow;
- addinst(tlp, inst->right, &tlp->se);
- /* efficiency: advance and re-evaluate */
- inst = inst->left;
- goto Switchstmt;
- case END: /* Match! */
- tlp->se.p[0].p1 = -tlp->se.p[0].p1; /* minus s…
- tlp->se.p[0].p2 = p;
- bnewmatch(&tlp->se);
- break;
- }
- }
- }
+ int flag = 0;
+ Inst *inst;
+ Ilist *tlp;
+ Posn p = startp;
+ int nnl = 0, ntl;
+ int c;
+ int wrapped = 0;
+ int startchar = bstartinst->type<OPERATOR? bstartinst->type : 0;
+
+ list[0][0].inst = list[1][0].inst = 0;
+ sel.p[0].p1= -1;
+ Fgetcset(f, startp);
+ /* Execute machine once for each character, including terminal NUL */
+ for(;;--p){
+ doloop:
+ if((c = Fbgetc(f))==-1){
+ switch(wrapped++){
+ case 0: /* let loop run one more click */
+ case 2:
+ break;
+ case 1: /* expired; wrap to end */
+ if(sel.p[0].p1>=0)
+ case 3:
+ goto Return;
+ list[0][0].inst = list[1][0].inst = 0;
+ Fgetcset(f, f->nrunes);
+ p = f->nrunes;
+ goto doloop;
+ default:
+ goto Return;
+ }
+ }else if(((wrapped && p<=startp) || sel.p[0].p1>0) && nnl==0)
+ break;
+ /* fast check for first char */
+ if(startchar && nnl==0 && c!=startchar)
+ continue;
+ tl = list[flag];
+ nl = list[flag^=1];
+ nl->inst = 0;
+ ntl = nnl;
+ nnl = 0;
+ if(sel.p[0].p1<0 && (!wrapped || p>startp)){
+ /* Add first instruction to this list */
+ if(++ntl >= NLIST)
+ Overflow:
+ error(Eoverflow);
+ /* the minus is so the optimizations in addinst work */
+ sempty.p[0].p1 = -p;
+ addinst(tl, bstartinst, &sempty);
+ }
+ /* Execute machine until this list is empty */
+ for(tlp = tl; inst = tlp->inst; tlp++){ /* assignment = */
+ Switchstmt:
+ switch(inst->type){
+ default: /* regular character */
+ if(inst->type == c){
+ Addinst:
+ if(++nnl >= NLIST)
+ goto Overflow;
+ addinst(nl, inst->next, &tlp->se);
+ }
+ break;
+ case LBRA:
+ if(inst->subid>=0)
+ tlp->se.p[inst->subid].p1 = p;
+ inst = inst->next;
+ goto Switchstmt;
+ case RBRA:
+ if(inst->subid >= 0)
+ tlp->se.p[inst->subid].p2 = p;
+ inst = inst->next;
+ goto Switchstmt;
+ case ANY:
+ if(c != '\n')
+ goto Addinst;
+ break;
+ case BOL:
+ if(c=='\n' || p==0){
+ Step:
+ inst = inst->next;
+ goto Switchstmt;
+ }
+ break;
+ case EOL:
+ if(f->getci<f->ngetc-1){
+ if(f->getcbuf[f->getci+1]=='\n')
+ goto Step;
+ }else if(p<f->nrunes-1){
+ Rune c;
+ if(Fchars(f, &c, p, p+1)==1 && c=='\n')
+ goto Step;
+ }
+ break;
+ case CCLASS:
+ if(c>=0 && classmatch(inst->rclass, c, 0))
+ goto Addinst;
+ break;
+ case NCCLASS:
+ if(c>=0 && classmatch(inst->rclass, c, 1))
+ goto Addinst;
+ break;
+ case OR:
+ /* evaluate right choice later */
+ if(++ntl >= NLIST)
+ goto Overflow;
+ addinst(tlp, inst->right, &tlp->se);
+ /* efficiency: advance and re-evaluate */
+ inst = inst->left;
+ goto Switchstmt;
+ case END: /* Match! */
+ tlp->se.p[0].p1 = -tlp->se.p[0].p1; /* minus sign */
+ tlp->se.p[0].p2 = p;
+ bnewmatch(&tlp->se);
+ break;
+ }
+ }
+ }
Return:
- return sel.p[0].p1>=0;
+ return sel.p[0].p1>=0;
}
void
diff --git a/sam/sam.c b/sam/sam.c
@@ -3,44 +3,44 @@
#include <unistd.h>
-Rune genbuf[BLOCKSIZE];
-int io;
-int panicking;
-int rescuing;
-Mod modnum;
-String genstr;
-String rhs;
-String wd;
-String cmdstr;
-Rune empty[] = { 0 };
-char *genc;
-File *curfile;
-File *flist;
-File *cmd;
-jmp_buf mainloop;
+Rune genbuf[BLOCKSIZE];
+int io;
+int panicking;
+int rescuing;
+Mod modnum;
+String genstr;
+String rhs;
+String wd;
+String cmdstr;
+Rune empty[] = { 0 };
+char *genc;
+File *curfile;
+File *flist;
+File *cmd;
+jmp_buf mainloop;
List tempfile;
-int quitok = TRUE;
-int downloaded;
+int quitok = TRUE;
+int downloaded;
int expandtabs;
-int dflag;
-int Rflag;
-char *machine;
-char *home;
-int bpipeok;
-int termlocked;
-char *samterm = "samterm";
-char *rsamname = "rsam";
+int dflag;
+int Rflag;
+char *machine;
+char *home;
+int bpipeok;
+int termlocked;
+char *samterm = "samterm";
+char *rsamname = "rsam";
-Rune baddir[] = { '<', 'b', 'a', 'd', 'd', 'i', 'r', '>', '\n'};
+Rune baddir[] = { '<', 'b', 'a', 'd', 'd', 'i', 'r', '>', '\n'};
-void usage(void);
+void usage(void);
int
main(int argc, char *argv[])
{
- int i, o;
- String *t;
- char *arg[argc + 1], **ap;
+ int i, o;
+ String *t;
+ char *arg[argc + 1], **ap;
int targc = 1;
ap = &arg[argc];
@@ -87,68 +87,68 @@ main(int argc, char *argv[])
argc -= optind;
arg[targc] = NULL;
- Strinit(&cmdstr);
- Strinit0(&lastpat);
- Strinit0(&lastregexp);
- Strinit0(&genstr);
- Strinit0(&rhs);
- Strinit0(&wd);
- tempfile.listptr = emalloc(0);
- Strinit0(&plan9cmd);
- home = getenv("HOME");
- if(home == 0)
- home = "/";
- if(!dflag)
- startup(machine, Rflag, arg, ap);
- Fstart();
- notify(notifyf);
- if(argc > 0){
- for(i=0; i<argc; i++)
- if(!setjmp(mainloop)){
- t = tmpcstr(argv[i]);
- Straddc(t, '\0');
- Strduplstr(&genstr, t);
- freetmpstr(t);
- Fsetname(newfile(), &genstr);
- }
- }else if(!downloaded)
- newfile()->state = Clean;
- modnum++;
- if(file.nused)
- current(file.filepptr[0]);
- setjmp(mainloop);
- cmdloop();
- trytoquit(); /* if we already q'ed, quitok will be TRUE */
- exits(0);
+ Strinit(&cmdstr);
+ Strinit0(&lastpat);
+ Strinit0(&lastregexp);
+ Strinit0(&genstr);
+ Strinit0(&rhs);
+ Strinit0(&wd);
+ tempfile.listptr = emalloc(0);
+ Strinit0(&plan9cmd);
+ home = getenv("HOME");
+ if(home == 0)
+ home = "/";
+ if(!dflag)
+ startup(machine, Rflag, arg, ap);
+ Fstart();
+ notify(notifyf);
+ if(argc > 0){
+ for(i=0; i<argc; i++)
+ if(!setjmp(mainloop)){
+ t = tmpcstr(argv[i]);
+ Straddc(t, '\0');
+ Strduplstr(&genstr, t);
+ freetmpstr(t);
+ Fsetname(newfile(), &genstr);
+ }
+ }else if(!downloaded)
+ newfile()->state = Clean;
+ modnum++;
+ if(file.nused)
+ current(file.filepptr[0]);
+ setjmp(mainloop);
+ cmdloop();
+ trytoquit(); /* if we already q'ed, quitok will be TRUE */
+ exits(0);
}
void
usage(void)
{
- dprint("usage: sam [-r machine] [-d] [-f] [-e] [-t samterm] [-s samnam…
- exits("usage");
+ dprint("usage: sam [-r machine] [-d] [-f] [-e] [-t samterm] [-s samname] F…
+ exits("usage");
}
void
rescue(void)
{
- int i, nblank = 0;
- File *f;
- char *c;
- char buf[256];
-
- if(rescuing++)
- return;
- io = -1;
- for(i=0; i<file.nused; i++){
- f = file.filepptr[i];
- if(f==cmd || f->nrunes==0 || f->state!=Dirty)
- continue;
- if(io == -1){
- sprint(buf, "%s/sam.save", home);
- io = create(buf, 1, 0700);
- if(io<0)
- return;
+ int i, nblank = 0;
+ File *f;
+ char *c;
+ char buf[256];
+
+ if(rescuing++)
+ return;
+ io = -1;
+ for(i=0; i<file.nused; i++){
+ f = file.filepptr[i];
+ if(f==cmd || f->nrunes==0 || f->state!=Dirty)
+ continue;
+ if(io == -1){
+ sprint(buf, "%s/sam.save", home);
+ io = create(buf, 1, 0700);
+ if(io<0)
+ return;
dprintf(io, "samsave() {\n"
" echo \"${1}?\"\n"
" read yn < /dev/tty\n"
@@ -156,432 +156,432 @@ rescue(void)
" [Yy]*) cat > \"${1}\"\n"
" esac\n"
"}\n");
- }
- if(f->name.s[0]){
- c = Strtoc(&f->name);
- strncpy(buf, c, sizeof buf-1);
- buf[sizeof buf-1] = 0;
- free(c);
- }else
- sprint(buf, "nameless.%d", nblank++);
+ }
+ if(f->name.s[0]){
+ c = Strtoc(&f->name);
+ strncpy(buf, c, sizeof buf-1);
+ buf[sizeof buf-1] = 0;
+ free(c);
+ }else
+ sprint(buf, "nameless.%d", nblank++);
dprintf(io, "samsave %s <<'---%s'\n", buf, buf);
- addr.r.p1 = 0, addr.r.p2 = f->nrunes;
- writeio(f);
- dprintf(io, "\n---%s\n", (char *)buf);
- }
+ addr.r.p1 = 0, addr.r.p2 = f->nrunes;
+ writeio(f);
+ dprintf(io, "\n---%s\n", (char *)buf);
+ }
}
void
panic(char *s)
{
- int wasd;
-
- if(!panicking++ && !setjmp(mainloop)){
- wasd = downloaded;
- downloaded = 0;
- dprint("sam: panic: %s\n", s);
- if(wasd)
- fprintf(stderr, "sam: panic: %s\n", s);
- rescue();
- abort();
- }
+ int wasd;
+
+ if(!panicking++ && !setjmp(mainloop)){
+ wasd = downloaded;
+ downloaded = 0;
+ dprint("sam: panic: %s\n", s);
+ if(wasd)
+ fprintf(stderr, "sam: panic: %s\n", s);
+ rescue();
+ abort();
+ }
}
void
hiccough(char *s)
{
- if(rescuing)
- exits("rescue");
- if(s)
- dprint("%s\n", s);
- resetcmd();
- resetxec();
- resetsys();
- if(io > 0)
- close(io);
- if(undobuf->nrunes)
- Bdelete(undobuf, (Posn)0, undobuf->nrunes);
- update();
- if (curfile) {
- if (curfile->state==Unread)
- curfile->state = Clean;
- else if (downloaded)
- outTs(Hcurrent, curfile->tag);
- }
- longjmp(mainloop, 1);
+ if(rescuing)
+ exits("rescue");
+ if(s)
+ dprint("%s\n", s);
+ resetcmd();
+ resetxec();
+ resetsys();
+ if(io > 0)
+ close(io);
+ if(undobuf->nrunes)
+ Bdelete(undobuf, (Posn)0, undobuf->nrunes);
+ update();
+ if (curfile) {
+ if (curfile->state==Unread)
+ curfile->state = Clean;
+ else if (downloaded)
+ outTs(Hcurrent, curfile->tag);
+ }
+ longjmp(mainloop, 1);
}
void
intr(void)
{
- error(Eintr);
+ error(Eintr);
}
void
trytoclose(File *f)
{
- char *t;
- char buf[256];
-
- if(f == cmd) /* possible? */
- return;
- if(f->deleted)
- return;
- if(f->state==Dirty && !f->closeok){
- f->closeok = TRUE;
- if(f->name.s[0]){
- t = Strtoc(&f->name);
- strncpy(buf, t, sizeof buf-1);
- free(t);
- }else
- strcpy(buf, "nameless file");
- error_s(Emodified, buf);
- }
- f->deleted = TRUE;
+ char *t;
+ char buf[256];
+
+ if(f == cmd) /* possible? */
+ return;
+ if(f->deleted)
+ return;
+ if(f->state==Dirty && !f->closeok){
+ f->closeok = TRUE;
+ if(f->name.s[0]){
+ t = Strtoc(&f->name);
+ strncpy(buf, t, sizeof buf-1);
+ free(t);
+ }else
+ strcpy(buf, "nameless file");
+ error_s(Emodified, buf);
+ }
+ f->deleted = TRUE;
}
void
trytoquit(void)
{
- int c;
- File *f;
+ int c;
+ File *f;
- if(!quitok)
+ if(!quitok)
{
- for(c = 0; c<file.nused; c++){
- f = file.filepptr[c];
- if(f!=cmd && f->state==Dirty){
- quitok = TRUE;
- eof = FALSE;
- error(Echanges);
- }
- }
+ for(c = 0; c<file.nused; c++){
+ f = file.filepptr[c];
+ if(f!=cmd && f->state==Dirty){
+ quitok = TRUE;
+ eof = FALSE;
+ error(Echanges);
+ }
+ }
}
}
void
load(File *f)
{
- Address saveaddr;
-
- Strduplstr(&genstr, &f->name);
- filename(f);
- if(f->name.s[0]){
- saveaddr = addr;
- edit(f, 'I');
- addr = saveaddr;
- }else
- f->state = Clean;
- Fupdate(f, TRUE, TRUE);
+ Address saveaddr;
+
+ Strduplstr(&genstr, &f->name);
+ filename(f);
+ if(f->name.s[0]){
+ saveaddr = addr;
+ edit(f, 'I');
+ addr = saveaddr;
+ }else
+ f->state = Clean;
+ Fupdate(f, TRUE, TRUE);
}
void
cmdupdate(void)
{
- if(cmd && cmd->mod!=0){
- Fupdate(cmd, FALSE, downloaded);
- cmd->dot.r.p1 = cmd->dot.r.p2 = cmd->nrunes;
- telldot(cmd);
- }
+ if(cmd && cmd->mod!=0){
+ Fupdate(cmd, FALSE, downloaded);
+ cmd->dot.r.p1 = cmd->dot.r.p2 = cmd->nrunes;
+ telldot(cmd);
+ }
}
void
delete(File *f)
{
- if(downloaded && f->rasp)
- outTs(Hclose, f->tag);
- delfile(f);
- if(f == curfile)
- current(0);
+ if(downloaded && f->rasp)
+ outTs(Hclose, f->tag);
+ delfile(f);
+ if(f == curfile)
+ current(0);
}
void
update(void)
{
- int i, anymod;
- File *f;
-
- settempfile();
- for(anymod = i=0; i<tempfile.nused; i++){
- f = tempfile.filepptr[i];
- if(f==cmd) /* cmd gets done in main() */
- continue;
- if(f->deleted) {
- delete(f);
- continue;
- }
- if(f->mod==modnum && Fupdate(f, FALSE, downloaded))
- anymod++;
- if(f->rasp)
- telldot(f);
- }
- if(anymod)
- modnum++;
+ int i, anymod;
+ File *f;
+
+ settempfile();
+ for(anymod = i=0; i<tempfile.nused; i++){
+ f = tempfile.filepptr[i];
+ if(f==cmd) /* cmd gets done in main() */
+ continue;
+ if(f->deleted) {
+ delete(f);
+ continue;
+ }
+ if(f->mod==modnum && Fupdate(f, FALSE, downloaded))
+ anymod++;
+ if(f->rasp)
+ telldot(f);
+ }
+ if(anymod)
+ modnum++;
}
File *
current(File *f)
{
- return curfile = f;
+ return curfile = f;
}
void
edit(File *f, int cmd)
{
- int empty = TRUE;
- Posn p;
- int nulls;
-
- if(cmd == 'r')
- Fdelete(f, addr.r.p1, addr.r.p2);
- if(cmd=='e' || cmd=='I'){
- Fdelete(f, (Posn)0, f->nrunes);
- addr.r.p2 = f->nrunes;
- }else if(f->nrunes!=0 || (f->name.s[0] && Strcmp(&genstr, &f->name)!=0…
- empty = FALSE;
- if((io = open(genc, OREAD))<0) {
- if (curfile && curfile->state == Unread)
- curfile->state = Clean;
- error_s(Eopen, genc);
- }
- p = readio(f, &nulls, empty);
- closeio((cmd=='e' || cmd=='I')? -1 : p);
- if(cmd == 'r')
- f->ndot.r.p1 = addr.r.p2, f->ndot.r.p2 = addr.r.p2+p;
- else
- f->ndot.r.p1 = f->ndot.r.p2 = 0;
- f->closeok = empty;
- if (quitok)
- quitok = empty;
- else
- quitok = FALSE;
- state(f, empty && !nulls? Clean : Dirty);
- if(cmd == 'e')
- filename(f);
+ int empty = TRUE;
+ Posn p;
+ int nulls;
+
+ if(cmd == 'r')
+ Fdelete(f, addr.r.p1, addr.r.p2);
+ if(cmd=='e' || cmd=='I'){
+ Fdelete(f, (Posn)0, f->nrunes);
+ addr.r.p2 = f->nrunes;
+ }else if(f->nrunes!=0 || (f->name.s[0] && Strcmp(&genstr, &f->name)!=0))
+ empty = FALSE;
+ if((io = open(genc, OREAD))<0) {
+ if (curfile && curfile->state == Unread)
+ curfile->state = Clean;
+ error_s(Eopen, genc);
+ }
+ p = readio(f, &nulls, empty);
+ closeio((cmd=='e' || cmd=='I')? -1 : p);
+ if(cmd == 'r')
+ f->ndot.r.p1 = addr.r.p2, f->ndot.r.p2 = addr.r.p2+p;
+ else
+ f->ndot.r.p1 = f->ndot.r.p2 = 0;
+ f->closeok = empty;
+ if (quitok)
+ quitok = empty;
+ else
+ quitok = FALSE;
+ state(f, empty && !nulls? Clean : Dirty);
+ if(cmd == 'e')
+ filename(f);
}
int
getname(File *f, String *s, int save)
{
- int c, i;
-
- Strzero(&genstr);
- if(genc){
- free(genc);
- genc = 0;
- }
- if(s==0 || (c = s->s[0])==0){ /* no name provided */
- if(f)
- Strduplstr(&genstr, &f->name);
- else
- Straddc(&genstr, '\0');
- goto Return;
- }
- if(c!=' ' && c!='\t')
- error(Eblank);
- for(i=0; (c=s->s[i])==' ' || c=='\t'; i++)
- ;
- while(s->s[i] > ' ')
- Straddc(&genstr, s->s[i++]);
- if(s->s[i])
- error(Enewline);
- Straddc(&genstr, '\0');
- if(f && (save || f->name.s[0]==0)){
- Fsetname(f, &genstr);
- if(Strcmp(&f->name, &genstr)){
- quitok = f->closeok = FALSE;
- f->qid = 0;
- f->date = 0;
- state(f, Dirty); /* if it's 'e', fix later */
- }
- }
+ int c, i;
+
+ Strzero(&genstr);
+ if(genc){
+ free(genc);
+ genc = 0;
+ }
+ if(s==0 || (c = s->s[0])==0){ /* no name provided */
+ if(f)
+ Strduplstr(&genstr, &f->name);
+ else
+ Straddc(&genstr, '\0');
+ goto Return;
+ }
+ if(c!=' ' && c!='\t')
+ error(Eblank);
+ for(i=0; (c=s->s[i])==' ' || c=='\t'; i++)
+ ;
+ while(s->s[i] > ' ')
+ Straddc(&genstr, s->s[i++]);
+ if(s->s[i])
+ error(Enewline);
+ Straddc(&genstr, '\0');
+ if(f && (save || f->name.s[0]==0)){
+ Fsetname(f, &genstr);
+ if(Strcmp(&f->name, &genstr)){
+ quitok = f->closeok = FALSE;
+ f->qid = 0;
+ f->date = 0;
+ state(f, Dirty); /* if it's 'e', fix later */
+ }
+ }
Return:
- genc = Strtoc(&genstr);
- return genstr.n-1; /* strlen(name) */
+ genc = Strtoc(&genstr);
+ return genstr.n-1; /* strlen(name) */
}
void
filename(File *f)
{
- if(genc)
- free(genc);
- genc = Strtoc(&f->name);
- dprint("%c%c%c %s\n", " '"[f->state==Dirty],
- "-+"[f->rasp!=0], " ."[f==curfile], genc);
+ if(genc)
+ free(genc);
+ genc = Strtoc(&f->name);
+ dprint("%c%c%c %s\n", " '"[f->state==Dirty],
+ "-+"[f->rasp!=0], " ."[f==curfile], genc);
}
void
undostep(File *f)
{
- Buffer *t;
- int changes;
- Mark mark;
-
- t = f->transcript;
- changes = Fupdate(f, TRUE, TRUE);
- Bread(t, (Rune*)&mark, (sizeof mark)/RUNESIZE, f->markp);
- Bdelete(t, f->markp, t->nrunes);
- f->markp = mark.p;
- f->dot.r = mark.dot;
- f->ndot.r = mark.dot;
- f->mark = mark.mark;
- f->mod = mark.m;
- f->closeok = mark.s1!=Dirty;
- if(mark.s1==Dirty)
- quitok = FALSE;
- if(f->state==Clean && mark.s1==Clean && changes)
- state(f, Dirty);
- else
- state(f, mark.s1);
+ Buffer *t;
+ int changes;
+ Mark mark;
+
+ t = f->transcript;
+ changes = Fupdate(f, TRUE, TRUE);
+ Bread(t, (Rune*)&mark, (sizeof mark)/RUNESIZE, f->markp);
+ Bdelete(t, f->markp, t->nrunes);
+ f->markp = mark.p;
+ f->dot.r = mark.dot;
+ f->ndot.r = mark.dot;
+ f->mark = mark.mark;
+ f->mod = mark.m;
+ f->closeok = mark.s1!=Dirty;
+ if(mark.s1==Dirty)
+ quitok = FALSE;
+ if(f->state==Clean && mark.s1==Clean && changes)
+ state(f, Dirty);
+ else
+ state(f, mark.s1);
}
int
undo(void)
{
- File *f;
- int i;
- Mod max;
- if((max = curfile->mod)==0)
- return 0;
- settempfile();
- for(i = 0; i<tempfile.nused; i++){
- f = tempfile.filepptr[i];
- if(f!=cmd && f->mod==max)
- undostep(f);
- }
- return 1;
+ File *f;
+ int i;
+ Mod max;
+ if((max = curfile->mod)==0)
+ return 0;
+ settempfile();
+ for(i = 0; i<tempfile.nused; i++){
+ f = tempfile.filepptr[i];
+ if(f!=cmd && f->mod==max)
+ undostep(f);
+ }
+ return 1;
}
int
readcmd(String *s)
{
- int retcode;
-
- if(flist == 0)
- (flist = Fopen())->state = Clean;
- addr.r.p1 = 0, addr.r.p2 = flist->nrunes;
- retcode = plan9(flist, '<', s, FALSE);
- Fupdate(flist, FALSE, FALSE);
- flist->mod = 0;
- if (flist->nrunes > BLOCKSIZE)
- error(Etoolong);
- Strzero(&genstr);
- Strinsure(&genstr, flist->nrunes);
- Fchars(flist, genbuf, (Posn)0, flist->nrunes);
- memmove(genstr.s, genbuf, flist->nrunes*RUNESIZE);
- genstr.n = flist->nrunes;
- Straddc(&genstr, '\0');
- return retcode;
+ int retcode;
+
+ if(flist == 0)
+ (flist = Fopen())->state = Clean;
+ addr.r.p1 = 0, addr.r.p2 = flist->nrunes;
+ retcode = plan9(flist, '<', s, FALSE);
+ Fupdate(flist, FALSE, FALSE);
+ flist->mod = 0;
+ if (flist->nrunes > BLOCKSIZE)
+ error(Etoolong);
+ Strzero(&genstr);
+ Strinsure(&genstr, flist->nrunes);
+ Fchars(flist, genbuf, (Posn)0, flist->nrunes);
+ memmove(genstr.s, genbuf, flist->nrunes*RUNESIZE);
+ genstr.n = flist->nrunes;
+ Straddc(&genstr, '\0');
+ return retcode;
}
void
cd(String *str)
{
- int i;
- File *f;
- String *t;
-
- t = tmpcstr("/bin/pwd");
- Straddc(t, '\0');
- if (flist) {
- Fclose(flist);
- flist = 0;
- }
- if (readcmd(t) != 0) {
- Strduplstr(&genstr, tmprstr(baddir, sizeof(baddir)/sizeof(Rune…
- Straddc(&genstr, '\0');
- }
- freetmpstr(t);
- Strduplstr(&wd, &genstr);
- if(wd.s[0] == 0){
- wd.n = 0;
- warn(Wpwd);
- }else if(wd.s[wd.n-2] == '\n'){
- --wd.n;
- wd.s[wd.n-1]='/';
- }
- if(chdir(getname((File *)0, str, FALSE)? genc : home))
- syserror("chdir");
- settempfile();
- for(i=0; i<tempfile.nused; i++){
- f = tempfile.filepptr[i];
- if(f!=cmd && f->name.s[0]!='/' && f->name.s[0]!=0){
- Strinsert(&f->name, &wd, (Posn)0);
- sortname(f);
- }
- }
+ int i;
+ File *f;
+ String *t;
+
+ t = tmpcstr("/bin/pwd");
+ Straddc(t, '\0');
+ if (flist) {
+ Fclose(flist);
+ flist = 0;
+ }
+ if (readcmd(t) != 0) {
+ Strduplstr(&genstr, tmprstr(baddir, sizeof(baddir)/sizeof(Rune)));
+ Straddc(&genstr, '\0');
+ }
+ freetmpstr(t);
+ Strduplstr(&wd, &genstr);
+ if(wd.s[0] == 0){
+ wd.n = 0;
+ warn(Wpwd);
+ }else if(wd.s[wd.n-2] == '\n'){
+ --wd.n;
+ wd.s[wd.n-1]='/';
+ }
+ if(chdir(getname((File *)0, str, FALSE)? genc : home))
+ syserror("chdir");
+ settempfile();
+ for(i=0; i<tempfile.nused; i++){
+ f = tempfile.filepptr[i];
+ if(f!=cmd && f->name.s[0]!='/' && f->name.s[0]!=0){
+ Strinsert(&f->name, &wd, (Posn)0);
+ sortname(f);
+ }
+ }
}
int
loadflist(String *s)
{
- int c, i;
-
- c = s->s[0];
- for(i = 0; s->s[i]==' ' || s->s[i]=='\t'; i++)
- ;
- if((c==' ' || c=='\t') && s->s[i]!='\n'){
- if(s->s[i]=='<'){
- Strdelete(s, 0L, (long)i+1);
- readcmd(s);
- }else{
- Strzero(&genstr);
- while((c = s->s[i++]) && c!='\n')
- Straddc(&genstr, c);
- Straddc(&genstr, '\0');
- }
- }else{
- if(c != '\n')
- error(Eblank);
- Strdupl(&genstr, empty);
- }
- if(genc)
- free(genc);
- genc = Strtoc(&genstr);
- return genstr.s[0];
+ int c, i;
+
+ c = s->s[0];
+ for(i = 0; s->s[i]==' ' || s->s[i]=='\t'; i++)
+ ;
+ if((c==' ' || c=='\t') && s->s[i]!='\n'){
+ if(s->s[i]=='<'){
+ Strdelete(s, 0L, (long)i+1);
+ readcmd(s);
+ }else{
+ Strzero(&genstr);
+ while((c = s->s[i++]) && c!='\n')
+ Straddc(&genstr, c);
+ Straddc(&genstr, '\0');
+ }
+ }else{
+ if(c != '\n')
+ error(Eblank);
+ Strdupl(&genstr, empty);
+ }
+ if(genc)
+ free(genc);
+ genc = Strtoc(&genstr);
+ return genstr.s[0];
}
File *
readflist(int readall, int delete)
{
- Posn i;
- int c;
- File *f;
- String *t;
-
- for(i=0,f=0; f==0 || readall || delete; i++){ /* ++ skips blank…
- Strdelete(&genstr, (Posn)0, i);
- for(i=0; (c = genstr.s[i])==' ' || c=='\t' || c=='\n'; i++)
- ;
- if(i >= genstr.n)
- break;
- Strdelete(&genstr, (Posn)0, i);
- for(i=0; (c=genstr.s[i]) && c!=' ' && c!='\t' && c!='\n'; i++)
- ;
-
- if(i == 0)
- break;
- genstr.s[i] = 0;
- t = tmprstr(genstr.s, i+1);
- f = lookfile(t, 0);
- if(delete){
- if(f == 0)
- warn_S(Wfile, t);
- else
- trytoclose(f);
- }else if(f==0 && readall)
- Fsetname(f = newfile(), t);
- }
- return f;
+ Posn i;
+ int c;
+ File *f;
+ String *t;
+
+ for(i=0,f=0; f==0 || readall || delete; i++){ /* ++ skips blank */
+ Strdelete(&genstr, (Posn)0, i);
+ for(i=0; (c = genstr.s[i])==' ' || c=='\t' || c=='\n'; i++)
+ ;
+ if(i >= genstr.n)
+ break;
+ Strdelete(&genstr, (Posn)0, i);
+ for(i=0; (c=genstr.s[i]) && c!=' ' && c!='\t' && c!='\n'; i++)
+ ;
+
+ if(i == 0)
+ break;
+ genstr.s[i] = 0;
+ t = tmprstr(genstr.s, i+1);
+ f = lookfile(t, 0);
+ if(delete){
+ if(f == 0)
+ warn_S(Wfile, t);
+ else
+ trytoclose(f);
+ }else if(f==0 && readall)
+ Fsetname(f = newfile(), t);
+ }
+ return f;
}
File *
tofile(String *s)
{
- File *f = NULL;
+ File *f = NULL;
- if(s->s[0] != ' ')
- error(Eblank);
+ if(s->s[0] != ' ')
+ error(Eblank);
if (loadflist(s) == 0)
f = lookfile(&genstr, 0);
@@ -601,102 +601,102 @@ tofile(String *s)
File *
getfile(String *s)
{
- File *f;
+ File *f;
- if(loadflist(s) == 0)
- Fsetname(f = newfile(), &genstr);
- else if((f=readflist(TRUE, FALSE)) == 0)
- error(Eblank);
- return current(f);
+ if(loadflist(s) == 0)
+ Fsetname(f = newfile(), &genstr);
+ else if((f=readflist(TRUE, FALSE)) == 0)
+ error(Eblank);
+ return current(f);
}
void
closefiles(File *f, String *s)
{
- if(s->s[0] == 0){
- if(f == 0)
- error(Enofile);
- trytoclose(f);
- return;
- }
- if(s->s[0] != ' ')
- error(Eblank);
- if(loadflist(s) == 0)
- error(Enewline);
- readflist(FALSE, TRUE);
+ if(s->s[0] == 0){
+ if(f == 0)
+ error(Enofile);
+ trytoclose(f);
+ return;
+ }
+ if(s->s[0] != ' ')
+ error(Eblank);
+ if(loadflist(s) == 0)
+ error(Enewline);
+ readflist(FALSE, TRUE);
}
void
copy(File *f, Address addr2)
{
- Posn p;
- int ni;
- for(p=addr.r.p1; p<addr.r.p2; p+=ni){
- ni = addr.r.p2-p;
- if(ni > BLOCKSIZE)
- ni = BLOCKSIZE;
- Fchars(f, genbuf, p, p+ni);
- Finsert(addr2.f, tmprstr(genbuf, ni), addr2.r.p2);
- }
- addr2.f->ndot.r.p2 = addr2.r.p2+(f->dot.r.p2-f->dot.r.p1);
- addr2.f->ndot.r.p1 = addr2.r.p2;
+ Posn p;
+ int ni;
+ for(p=addr.r.p1; p<addr.r.p2; p+=ni){
+ ni = addr.r.p2-p;
+ if(ni > BLOCKSIZE)
+ ni = BLOCKSIZE;
+ Fchars(f, genbuf, p, p+ni);
+ Finsert(addr2.f, tmprstr(genbuf, ni), addr2.r.p2);
+ }
+ addr2.f->ndot.r.p2 = addr2.r.p2+(f->dot.r.p2-f->dot.r.p1);
+ addr2.f->ndot.r.p1 = addr2.r.p2;
}
void
move(File *f, Address addr2)
{
- if(addr.r.p2 <= addr2.r.p2){
- Fdelete(f, addr.r.p1, addr.r.p2);
- copy(f, addr2);
- }else if(addr.r.p1 >= addr2.r.p2){
- copy(f, addr2);
- Fdelete(f, addr.r.p1, addr.r.p2);
- }else
- error(Eoverlap);
+ if(addr.r.p2 <= addr2.r.p2){
+ Fdelete(f, addr.r.p1, addr.r.p2);
+ copy(f, addr2);
+ }else if(addr.r.p1 >= addr2.r.p2){
+ copy(f, addr2);
+ Fdelete(f, addr.r.p1, addr.r.p2);
+ }else
+ error(Eoverlap);
}
Posn
nlcount(File *f, Posn p0, Posn p1)
{
- Posn nl = 0;
+ Posn nl = 0;
- Fgetcset(f, p0);
- while(p0++<p1)
- if(Fgetc(f)=='\n')
- nl++;
- return nl;
+ Fgetcset(f, p0);
+ while(p0++<p1)
+ if(Fgetc(f)=='\n')
+ nl++;
+ return nl;
}
void
printposn(File *f, int charsonly)
{
- Posn l1, l2;
-
- if(!charsonly){
- l1 = 1+nlcount(f, (Posn)0, addr.r.p1);
- l2 = l1+nlcount(f, addr.r.p1, addr.r.p2);
- /* check if addr ends with '\n' */
- if(addr.r.p2>0 && addr.r.p2>addr.r.p1 && (Fgetcset(f, addr.r.p…
- --l2;
- dprint("%lu", l1);
- if(l2 != l1)
- dprint(",%lu", l2);
- dprint("; ");
- }
- dprint("#%lu", addr.r.p1);
- if(addr.r.p2 != addr.r.p1)
- dprint(",#%lu", addr.r.p2);
- dprint("\n");
+ Posn l1, l2;
+
+ if(!charsonly){
+ l1 = 1+nlcount(f, (Posn)0, addr.r.p1);
+ l2 = l1+nlcount(f, addr.r.p1, addr.r.p2);
+ /* check if addr ends with '\n' */
+ if(addr.r.p2>0 && addr.r.p2>addr.r.p1 && (Fgetcset(f, addr.r.p2-1),Fge…
+ --l2;
+ dprint("%lu", l1);
+ if(l2 != l1)
+ dprint(",%lu", l2);
+ dprint("; ");
+ }
+ dprint("#%lu", addr.r.p1);
+ if(addr.r.p2 != addr.r.p1)
+ dprint(",#%lu", addr.r.p2);
+ dprint("\n");
}
void
settempfile(void)
{
- if(tempfile.nalloc < file.nused){
- free(tempfile.listptr);
- tempfile.listptr = emalloc(sizeof(*tempfile.filepptr)*file.nus…
- tempfile.nalloc = file.nused;
- }
- tempfile.nused = file.nused;
- memmove(&tempfile.filepptr[0], &file.filepptr[0], file.nused*sizeof(Fi…
+ if(tempfile.nalloc < file.nused){
+ free(tempfile.listptr);
+ tempfile.listptr = emalloc(sizeof(*tempfile.filepptr)*file.nused);
+ tempfile.nalloc = file.nused;
+ }
+ tempfile.nused = file.nused;
+ memmove(&tempfile.filepptr[0], &file.filepptr[0], file.nused*sizeof(File*)…
}
diff --git a/sam/sam.h b/sam/sam.h
@@ -8,80 +8,80 @@
* BLOCKSIZE is relatively small to keep memory consumption down.
*/
-#define BLOCKSIZE 2048
-#define RUNESIZE sizeof(Rune)
-#define NDISC 5
-#define NBUFFILES 3+2*NDISC /* plan 9+undo+snarf+NDISC*(t…
-#define NSUBEXP 10
+#define BLOCKSIZE 2048
+#define RUNESIZE sizeof(Rune)
+#define NDISC 5
+#define NBUFFILES 3+2*NDISC /* plan 9+undo+snarf+NDISC*(transcript+buf) */
+#define NSUBEXP 10
-#define TRUE 1
-#define FALSE 0
+#define TRUE 1
+#define FALSE 0
-#define INFINITY 0x7FFFFFFFL
-#define INCR 25
-#define STRSIZE (2*BLOCKSIZE)
+#define INFINITY 0x7FFFFFFFL
+#define INCR 25
+#define STRSIZE (2*BLOCKSIZE)
-typedef long Posn; /* file position or address */
-typedef ushort Mod; /* modification numbe…
+typedef long Posn; /* file position or address */
+typedef ushort Mod; /* modification number */
-typedef struct Address Address;
-typedef struct Block Block;
-typedef struct Buffer Buffer;
-typedef struct Disc Disc;
-typedef struct Discdesc Discdesc;
-typedef struct File File;
-typedef struct List List;
-typedef struct Mark Mark;
-typedef struct Range Range;
-typedef struct Rangeset Rangeset;
-typedef struct String String;
+typedef struct Address Address;
+typedef struct Block Block;
+typedef struct Buffer Buffer;
+typedef struct Disc Disc;
+typedef struct Discdesc Discdesc;
+typedef struct File File;
+typedef struct List List;
+typedef struct Mark Mark;
+typedef struct Range Range;
+typedef struct Rangeset Rangeset;
+typedef struct String String;
enum State
{
- Clean = ' ',
- Dirty = '\'',
- Unread = '-',
- Readerr = '~'
+ Clean = ' ',
+ Dirty = '\'',
+ Unread = '-',
+ Readerr = '~'
};
struct Range
{
- Posn p1, p2;
+ Posn p1, p2;
};
struct Rangeset
{
- Range p[NSUBEXP];
+ Range p[NSUBEXP];
};
struct Address
{
- Range r;
- File *f;
+ Range r;
+ File *f;
};
-struct List /* code depends on a long being able to hold a pointer */
+struct List /* code depends on a long being able to hold a pointer */
{
- int nalloc;
- int nused;
- union{
- void *listp;
- Block *blkp;
- long *longp;
- uchar* *ucharp;
- String* *stringp;
- File* *filep;
- long listv;
- }g;
+ int nalloc;
+ int nused;
+ union{
+ void *listp;
+ Block *blkp;
+ long *longp;
+ uchar* *ucharp;
+ String* *stringp;
+ File* *filep;
+ long listv;
+ }g;
};
-#define listptr g.listp
-#define blkptr g.blkp
-#define longptr g.longp
-#define ucharpptr g.ucharp
-#define stringpptr g.stringp
-#define filepptr g.filep
-#define listval g.listv
+#define listptr g.listp
+#define blkptr g.blkp
+#define longptr g.longp
+#define ucharpptr g.ucharp
+#define stringpptr g.stringp
+#define filepptr g.filep
+#define listval g.listv
/*
* Block must fit in a long because the list routines manage arrays of
@@ -92,8 +92,8 @@ struct List /* code depends on a long being able to ho…
* bigger is the easiest way.
*
* The necessary conditions are even stronger:
-* sizeof(struct Block)==sizeof(long)
-* && the first 32 bits must hold bnum and nrunes.
+* sizeof(struct Block)==sizeof(long)
+* && the first 32 bits must hold bnum and nrunes.
* When sizeof(ushort)+sizeof(short) < sizeof(long),
* add padding at the beginning on a little endian and at
* the end on a big endian, as shown below for the DEC Alpha.
@@ -101,87 +101,87 @@ struct List /* code depends on a long being able t…
struct Block
{
#if USE64BITS == 1
- char pad[sizeof(long)-sizeof(ushort)-sizeof(short)];
+ char pad[sizeof(long)-sizeof(ushort)-sizeof(short)];
#endif
- ushort bnum; /* absolute number on disk */
- short nrunes; /* runes stored in this block */
+ ushort bnum; /* absolute number on disk */
+ short nrunes; /* runes stored in this block */
#if USE64BITS == 2
- char pad[sizeof(long)-sizeof(ushort)-sizeof(short)];
+ char pad[sizeof(long)-sizeof(ushort)-sizeof(short)];
#endif
};
struct Discdesc
{
- int fd; /* plan 9 file descriptor of temp file */
- ulong nbk; /* high water mark */
- List free; /* array of free block indices */
+ int fd; /* plan 9 file descriptor of temp file */
+ ulong nbk; /* high water mark */
+ List free; /* array of free block indices */
};
struct Disc
{
- Discdesc *desc; /* descriptor of temp file */
- Posn nrunes; /* runes on disc file */
- List block; /* list of used block indices */
+ Discdesc *desc; /* descriptor of temp file */
+ Posn nrunes; /* runes on disc file */
+ List block; /* list of used block indices */
};
struct String
{
- short n;
- short size;
- Rune *s;
+ short n;
+ short size;
+ Rune *s;
};
struct Buffer
{
- Disc *disc; /* disc storage */
- Posn nrunes; /* total length of buffer */
- String cache; /* in-core storage for efficiency …
- Posn c1, c2; /* cache start and end positions in…
- /* note: if dirty, cache is really c1, c1+cach…
- int dirty; /* cache dirty */
+ Disc *disc; /* disc storage */
+ Posn nrunes; /* total length of buffer */
+ String cache; /* in-core storage for efficiency */
+ Posn c1, c2; /* cache start and end positions in disc */
+ /* note: if dirty, cache is really c1, c1+cache.n */
+ int dirty; /* cache dirty */
};
-#define NGETC 128
+#define NGETC 128
struct File
{
- Buffer *buf; /* cached disc storage */
- Buffer *transcript; /* what's been done */
- Posn markp; /* file pointer to start of latest c…
- Mod mod; /* modification stamp */
- Posn nrunes; /* total length of file */
- Posn hiposn; /* highest address touched this Mod…
- Address dot; /* current position */
- Address ndot; /* new current position after upda…
- Range tdot; /* what terminal thinks is current r…
- Range mark; /* tagged spot in text (don't confus…
- List *rasp; /* map of what terminal's got */
- String name; /* file name */
- short tag; /* for communicating with terminal */
- char state; /* Clean, Dirty, Unread, or Readerr*/
- char closeok; /* ok to close file? */
- char deleted; /* delete at completion of command */
- char marked; /* file has been Fmarked at least o…
- * set, this will never go off as undo doesn't
- * revert to the dawn of time */
- long dev; /* file system from which it was read …
- long qid; /* file from which it was read */
- long date; /* time stamp of plan9 file */
- Posn cp1, cp2; /* Write-behind cache positions and */
- String cache; /* string */
- Rune getcbuf[NGETC];
- int ngetc;
- int getci;
- Posn getcp;
+ Buffer *buf; /* cached disc storage */
+ Buffer *transcript; /* what's been done */
+ Posn markp; /* file pointer to start of latest change */
+ Mod mod; /* modification stamp */
+ Posn nrunes; /* total length of file */
+ Posn hiposn; /* highest address touched this Mod */
+ Address dot; /* current position */
+ Address ndot; /* new current position after update */
+ Range tdot; /* what terminal thinks is current range */
+ Range mark; /* tagged spot in text (don't confuse with Mark) */
+ List *rasp; /* map of what terminal's got */
+ String name; /* file name */
+ short tag; /* for communicating with terminal */
+ char state; /* Clean, Dirty, Unread, or Readerr*/
+ char closeok; /* ok to close file? */
+ char deleted; /* delete at completion of command */
+ char marked; /* file has been Fmarked at least once; once
+ * set, this will never go off as undo doesn't
+ * revert to the dawn of time */
+ long dev; /* file system from which it was read */
+ long qid; /* file from which it was read */
+ long date; /* time stamp of plan9 file */
+ Posn cp1, cp2; /* Write-behind cache positions and */
+ String cache; /* string */
+ Rune getcbuf[NGETC];
+ int ngetc;
+ int getci;
+ Posn getcp;
};
struct Mark
{
- Posn p;
- Range dot;
- Range mark;
- Mod m;
- short s1;
+ Posn p;
+ Range dot;
+ Range mark;
+ Mod m;
+ short s1;
};
/*
@@ -190,210 +190,210 @@ struct Mark
*/
union Hdr
{
- struct _csl
- {
- short c;
- short s;
- long l;
- }csl;
- struct _cs
- {
- short c;
- short s;
- }cs;
- struct _cll
- {
- short c;
- long l;
- long l1;
- }cll;
- Mark mark;
+ struct _csl
+ {
+ short c;
+ short s;
+ long l;
+ }csl;
+ struct _cs
+ {
+ short c;
+ short s;
+ }cs;
+ struct _cll
+ {
+ short c;
+ long l;
+ long l1;
+ }cll;
+ Mark mark;
};
-#define Fgetc(f) ((--(f)->ngetc<0)? Fgetcload(f, (f)->getcp) : (f)->ge…
-#define Fbgetc(f) (((f)->getci<=0)? Fbgetcload(f, (f)->getcp) : (f)->ge…
+#define Fgetc(f) ((--(f)->ngetc<0)? Fgetcload(f, (f)->getcp) : (f)->getcbuf[(…
+#define Fbgetc(f) (((f)->getci<=0)? Fbgetcload(f, (f)->getcp) : (f)->getcbuf[-…
-int alnum(int);
-void Bclean(Buffer*);
-void Bterm(Buffer*);
-void Bdelete(Buffer*, Posn, Posn);
-void Bflush(Buffer*);
-void Binsert(Buffer*, String*, Posn);
-Buffer *Bopen(Discdesc*);
-int Bread(Buffer*, Rune*, int, Posn);
-void Dclose(Disc*);
-void Ddelete(Disc*, Posn, Posn);
-void Dinsert(Disc*, Rune*, int, Posn);
-Disc *Dopen(Discdesc*);
-int Dread(Disc*, Rune*, int, Posn);
-void Dreplace(Disc*, Posn, Posn, Rune*, int);
-int Fbgetcload(File*, Posn);
-int Fbgetcset(File*, Posn);
-long Fchars(File*, Rune*, Posn, Posn);
-void Fclose(File*);
-void Fdelete(File*, Posn, Posn);
-int Fgetcload(File*, Posn);
-int Fgetcset(File*, Posn);
-void Finsert(File*, String*, Posn);
-File *Fopen(void);
-void Fsetname(File*, String*);
-void Fstart(void);
-int Fupdate(File*, int, int);
-int Read(int, void*, int);
-void Seek(int, long, int);
-int plan9(File*, int, String*, int);
-int Write(int, void*, int);
-int bexecute(File*, Posn);
-void cd(String*);
-void closefiles(File*, String*);
-void closeio(Posn);
-void cmdloop(void);
-void cmdupdate(void);
-void compile(String*);
-void copy(File*, Address);
-File *current(File*);
-void delete(File*);
-void delfile(File*);
-void dellist(List*, int);
-void doubleclick(File*, Posn);
-void dprint(char*, ...);
-void edit(File*, int);
-void *emalloc(ulong);
-void *erealloc(void*, ulong);
-void error(Err);
-void error_c(Err, int);
-void error_s(Err, char*);
-int execute(File*, Posn, Posn);
-int filematch(File*, String*);
-void filename(File*);
-File *getfile(String*);
-int getname(File*, String*, int);
-long getnum(void);
-void hiccough(char*);
-void inslist(List*, int, long);
-Address lineaddr(Posn, Address, int);
-void listfree(List*);
-void load(File*);
-File *lookfile(String*, int);
-void lookorigin(File*, Posn, Posn, long);
-int lookup(int);
-void move(File*, Address);
-void moveto(File*, Range);
-File *newfile(void);
-void nextmatch(File*, String*, Posn, int);
-int newtmp(void);
-void notifyf(void*, char*);
-void panic(char*);
-void printposn(File*, int);
-void print_ss(char*, String*, String*);
-void print_s(char*, String*);
-int rcv(void);
-Range rdata(List*, Posn, Posn);
-Posn readio(File*, int*, int);
-void rescue(void);
-void resetcmd(void);
-void resetsys(void);
-void resetxec(void);
-void rgrow(List*, Posn, Posn);
-void samerr(char*);
-void settempfile(void);
-int skipbl(void);
-void snarf(File*, Posn, Posn, Buffer*, int);
-void sortname(File*);
-void startup(char*, int, char**, char**);
-void state(File*, int);
-int statfd(int, ulong*, ulong*, long*, long*, long*);
-int statfile(char*, ulong*, ulong*, long*, long*, long*);
-void Straddc(String*, int);
-void Strclose(String*);
-int Strcmp(String*, String*);
-void Strdelete(String*, Posn, Posn);
-void Strdupl(String*, Rune*);
-void Strduplstr(String*, String*);
-void Strinit(String*);
-void Strinit0(String*);
-void Strinsert(String*, String*, Posn);
-void Strinsure(String*, ulong);
-void Strzero(String*);
-int Strlen(Rune*);
-char *Strtoc(String*);
-void syserror(char*);
-void telldot(File*);
-void tellpat(void);
-String *tmpcstr(char*);
-String *tmprstr(Rune*, int);
-void freetmpstr(String*);
-void termcommand(void);
-void termwrite(char*);
-File *tofile(String*);
-void toterminal(File*, int);
-void trytoclose(File*);
-void trytoquit(void);
-int undo(void);
-void update(void);
-int waitfor(int);
-void warn(Warn);
-void warn_s(Warn, char*);
-void warn_SS(Warn, String*, String*);
-void warn_S(Warn, String*);
-int whichmenu(File*);
-void writef(File*);
-Posn writeio(File*);
+int alnum(int);
+void Bclean(Buffer*);
+void Bterm(Buffer*);
+void Bdelete(Buffer*, Posn, Posn);
+void Bflush(Buffer*);
+void Binsert(Buffer*, String*, Posn);
+Buffer *Bopen(Discdesc*);
+int Bread(Buffer*, Rune*, int, Posn);
+void Dclose(Disc*);
+void Ddelete(Disc*, Posn, Posn);
+void Dinsert(Disc*, Rune*, int, Posn);
+Disc *Dopen(Discdesc*);
+int Dread(Disc*, Rune*, int, Posn);
+void Dreplace(Disc*, Posn, Posn, Rune*, int);
+int Fbgetcload(File*, Posn);
+int Fbgetcset(File*, Posn);
+long Fchars(File*, Rune*, Posn, Posn);
+void Fclose(File*);
+void Fdelete(File*, Posn, Posn);
+int Fgetcload(File*, Posn);
+int Fgetcset(File*, Posn);
+void Finsert(File*, String*, Posn);
+File *Fopen(void);
+void Fsetname(File*, String*);
+void Fstart(void);
+int Fupdate(File*, int, int);
+int Read(int, void*, int);
+void Seek(int, long, int);
+int plan9(File*, int, String*, int);
+int Write(int, void*, int);
+int bexecute(File*, Posn);
+void cd(String*);
+void closefiles(File*, String*);
+void closeio(Posn);
+void cmdloop(void);
+void cmdupdate(void);
+void compile(String*);
+void copy(File*, Address);
+File *current(File*);
+void delete(File*);
+void delfile(File*);
+void dellist(List*, int);
+void doubleclick(File*, Posn);
+void dprint(char*, ...);
+void edit(File*, int);
+void *emalloc(ulong);
+void *erealloc(void*, ulong);
+void error(Err);
+void error_c(Err, int);
+void error_s(Err, char*);
+int execute(File*, Posn, Posn);
+int filematch(File*, String*);
+void filename(File*);
+File *getfile(String*);
+int getname(File*, String*, int);
+long getnum(void);
+void hiccough(char*);
+void inslist(List*, int, long);
+Address lineaddr(Posn, Address, int);
+void listfree(List*);
+void load(File*);
+File *lookfile(String*, int);
+void lookorigin(File*, Posn, Posn, long);
+int lookup(int);
+void move(File*, Address);
+void moveto(File*, Range);
+File *newfile(void);
+void nextmatch(File*, String*, Posn, int);
+int newtmp(void);
+void notifyf(void*, char*);
+void panic(char*);
+void printposn(File*, int);
+void print_ss(char*, String*, String*);
+void print_s(char*, String*);
+int rcv(void);
+Range rdata(List*, Posn, Posn);
+Posn readio(File*, int*, int);
+void rescue(void);
+void resetcmd(void);
+void resetsys(void);
+void resetxec(void);
+void rgrow(List*, Posn, Posn);
+void samerr(char*);
+void settempfile(void);
+int skipbl(void);
+void snarf(File*, Posn, Posn, Buffer*, int);
+void sortname(File*);
+void startup(char*, int, char**, char**);
+void state(File*, int);
+int statfd(int, ulong*, ulong*, long*, long*, long*);
+int statfile(char*, ulong*, ulong*, long*, long*, long*);
+void Straddc(String*, int);
+void Strclose(String*);
+int Strcmp(String*, String*);
+void Strdelete(String*, Posn, Posn);
+void Strdupl(String*, Rune*);
+void Strduplstr(String*, String*);
+void Strinit(String*);
+void Strinit0(String*);
+void Strinsert(String*, String*, Posn);
+void Strinsure(String*, ulong);
+void Strzero(String*);
+int Strlen(Rune*);
+char *Strtoc(String*);
+void syserror(char*);
+void telldot(File*);
+void tellpat(void);
+String *tmpcstr(char*);
+String *tmprstr(Rune*, int);
+void freetmpstr(String*);
+void termcommand(void);
+void termwrite(char*);
+File *tofile(String*);
+void toterminal(File*, int);
+void trytoclose(File*);
+void trytoquit(void);
+int undo(void);
+void update(void);
+int waitfor(int);
+void warn(Warn);
+void warn_s(Warn, char*);
+void warn_SS(Warn, String*, String*);
+void warn_S(Warn, String*);
+int whichmenu(File*);
+void writef(File*);
+Posn writeio(File*);
Discdesc *Dstart(void);
-extern Rune samname[]; /* compiler dependent */
-extern Rune *left[];
-extern Rune *right[];
+extern Rune samname[]; /* compiler dependent */
+extern Rune *left[];
+extern Rune *right[];
-extern char *rsamname; /* globals */
-extern char *samterm;
-extern Rune genbuf[];
-extern char *genc;
-extern int io;
-extern int patset;
-extern int quitok;
-extern Address addr;
-extern Buffer *undobuf;
-extern Buffer *snarfbuf;
-extern Buffer *plan9buf;
-extern List file;
-extern List tempfile;
-extern File *cmd;
-extern File *curfile;
-extern File *lastfile;
-extern Mod modnum;
-extern Posn cmdpt;
-extern Posn cmdptadv;
-extern Rangeset sel;
-extern String cmdstr;
-extern String genstr;
-extern String lastpat;
-extern String lastregexp;
-extern String plan9cmd;
-extern int downloaded;
-extern int eof;
-extern int bpipeok;
-extern int panicking;
-extern Rune empty[];
-extern int termlocked;
-extern int noflush;
+extern char *rsamname; /* globals */
+extern char *samterm;
+extern Rune genbuf[];
+extern char *genc;
+extern int io;
+extern int patset;
+extern int quitok;
+extern Address addr;
+extern Buffer *undobuf;
+extern Buffer *snarfbuf;
+extern Buffer *plan9buf;
+extern List file;
+extern List tempfile;
+extern File *cmd;
+extern File *curfile;
+extern File *lastfile;
+extern Mod modnum;
+extern Posn cmdpt;
+extern Posn cmdptadv;
+extern Rangeset sel;
+extern String cmdstr;
+extern String genstr;
+extern String lastpat;
+extern String lastregexp;
+extern String plan9cmd;
+extern int downloaded;
+extern int eof;
+extern int bpipeok;
+extern int panicking;
+extern Rune empty[];
+extern int termlocked;
+extern int noflush;
#include "mesg.h"
-void outTs(Hmesg, int);
-void outT0(Hmesg);
-void outTl(Hmesg, long);
-void outTslS(Hmesg, int, long, String*);
-void outTS(Hmesg, String*);
-void outTsS(Hmesg, int, String*);
-void outTsllS(Hmesg, int, long, long, String*);
-void outTsll(Hmesg, int, long, long);
-void outTsl(Hmesg, int, long);
-void outTsv(Hmesg, int, long);
-void outstart(Hmesg);
-void outcopy(int, void*);
-void outshort(int);
-void outlong(long);
-void outvlong(void*);
-void outsend(void);
-void outflush(void);
+void outTs(Hmesg, int);
+void outT0(Hmesg);
+void outTl(Hmesg, long);
+void outTslS(Hmesg, int, long, String*);
+void outTS(Hmesg, String*);
+void outTsS(Hmesg, int, String*);
+void outTsllS(Hmesg, int, long, long, String*);
+void outTsll(Hmesg, int, long, long);
+void outTsl(Hmesg, int, long);
+void outTsv(Hmesg, int, long);
+void outstart(Hmesg);
+void outcopy(int, void*);
+void outshort(int);
+void outlong(long);
+void outvlong(void*);
+void outsend(void);
+void outflush(void);
diff --git a/sam/shell.c b/sam/shell.c
@@ -4,154 +4,154 @@
#include <limits.h>
-extern jmp_buf mainloop;
+extern jmp_buf mainloop;
-char errfile[PATH_MAX + 1];
-String plan9cmd; /* null terminated */
-Buffer *plan9buf;
-void checkerrs(void);
+char errfile[PATH_MAX + 1];
+String plan9cmd; /* null terminated */
+Buffer *plan9buf;
+void checkerrs(void);
int
plan9(File *f, int type, String *s, int nest)
{
- long l;
- int m;
- int pid, fd;
- int retcode;
- int pipe1[2], pipe2[2];
+ long l;
+ int m;
+ int pid, fd;
+ int retcode;
+ int pipe1[2], pipe2[2];
- if(s->s[0]==0 && plan9cmd.s[0]==0)
- error(Enocmd);
- else if(s->s[0])
- Strduplstr(&plan9cmd, s);
- if(downloaded)
- samerr(errfile);
- else
- strcpy(errfile, "/dev/tty");
- if(type!='!' && pipe(pipe1)==-1)
- error(Epipe);
- if(type=='|')
- snarf(f, addr.r.p1, addr.r.p2, plan9buf, 1);
- if(downloaded)
- remove(errfile);
- if((pid=fork()) == 0){
- if(downloaded){ /* also put nasty fd's into errfile */
- fd = create(errfile, 1, 0666L);
- if(fd < 0)
- fd = create("/dev/null", 1, 0666L);
- dup(fd, 2);
- close(fd);
- /* 2 now points at err file */
- if(type == '>')
- dup(2, 1);
- else if(type=='!'){
- dup(2, 1);
- fd = open("/dev/null", 0);
- dup(fd, 0);
- close(fd);
- }
- }
- if(type != '!') {
- if(type=='<' || type=='|')
- dup(pipe1[1], 1);
- else if(type == '>')
- dup(pipe1[0], 0);
- close(pipe1[0]);
- close(pipe1[1]);
- }
- if(type == '|'){
- if(pipe(pipe2) == -1)
- exits("pipe");
- if((pid = fork())==0){
- /*
- * It's ok if we get SIGPIPE here
- */
- close(pipe2[0]);
- io = pipe2[1];
- if(retcode=!setjmp(mainloop)){ /* assig…
- char *c;
- for(l = 0; l<plan9buf->nrunes; l+=m){
- m = plan9buf->nrunes-l;
- if(m>BLOCKSIZE-1)
- m = BLOCKSIZE-1;
- Bread(plan9buf, genbuf, m, l);
- genbuf[m] = 0;
- c = Strtoc(tmprstr(genbuf, m+1…
- Write(pipe2[1], c, strlen(c));
- free(c);
- }
- }
- exits(retcode? "error" : 0);
- }
- if(pid==-1){
- fprintf(stderr, "Can't fork?!\n");
- exits("fork");
- }
- dup(pipe2[0], 0);
- close(pipe2[0]);
- close(pipe2[1]);
- }
- if(type=='<'){
- close(0); /* so it won't read from terminal */
- open("/dev/null", 0);
- }
- execlp(SHPATH, SHPATH, "-c", Strtoc(&plan9cmd), (char *)0);
- exits("exec");
- }
- if(pid == -1)
- error(Efork);
- if(type=='<' || type=='|'){
- int nulls;
- if(downloaded && addr.r.p1 != addr.r.p2)
- outTl(Hsnarflen, addr.r.p2-addr.r.p1);
- snarf(f, addr.r.p1, addr.r.p2, snarfbuf, 0);
- Fdelete(f, addr.r.p1, addr.r.p2);
- close(pipe1[1]);
- io = pipe1[0];
- f->tdot.p1 = -1;
- f->ndot.r.p2 = addr.r.p2+readio(f, &nulls, 0);
- f->ndot.r.p1 = addr.r.p2;
- closeio((Posn)-1);
- }else if(type=='>'){
- close(pipe1[0]);
- io = pipe1[1];
- bpipeok = 1;
- writeio(f);
- bpipeok = 0;
- closeio((Posn)-1);
- }
- retcode = waitfor(pid);
- if(type=='|' || type=='<')
- if(retcode!=0)
- warn(Wbadstatus);
- if(downloaded)
- checkerrs();
- if(!nest)
- dprint("!\n");
- return retcode;
+ if(s->s[0]==0 && plan9cmd.s[0]==0)
+ error(Enocmd);
+ else if(s->s[0])
+ Strduplstr(&plan9cmd, s);
+ if(downloaded)
+ samerr(errfile);
+ else
+ strcpy(errfile, "/dev/tty");
+ if(type!='!' && pipe(pipe1)==-1)
+ error(Epipe);
+ if(type=='|')
+ snarf(f, addr.r.p1, addr.r.p2, plan9buf, 1);
+ if(downloaded)
+ remove(errfile);
+ if((pid=fork()) == 0){
+ if(downloaded){ /* also put nasty fd's into errfile */
+ fd = create(errfile, 1, 0666L);
+ if(fd < 0)
+ fd = create("/dev/null", 1, 0666L);
+ dup(fd, 2);
+ close(fd);
+ /* 2 now points at err file */
+ if(type == '>')
+ dup(2, 1);
+ else if(type=='!'){
+ dup(2, 1);
+ fd = open("/dev/null", 0);
+ dup(fd, 0);
+ close(fd);
+ }
+ }
+ if(type != '!') {
+ if(type=='<' || type=='|')
+ dup(pipe1[1], 1);
+ else if(type == '>')
+ dup(pipe1[0], 0);
+ close(pipe1[0]);
+ close(pipe1[1]);
+ }
+ if(type == '|'){
+ if(pipe(pipe2) == -1)
+ exits("pipe");
+ if((pid = fork())==0){
+ /*
+ * It's ok if we get SIGPIPE here
+ */
+ close(pipe2[0]);
+ io = pipe2[1];
+ if(retcode=!setjmp(mainloop)){ /* assignment = */
+ char *c;
+ for(l = 0; l<plan9buf->nrunes; l+=m){
+ m = plan9buf->nrunes-l;
+ if(m>BLOCKSIZE-1)
+ m = BLOCKSIZE-1;
+ Bread(plan9buf, genbuf, m, l);
+ genbuf[m] = 0;
+ c = Strtoc(tmprstr(genbuf, m+1));
+ Write(pipe2[1], c, strlen(c));
+ free(c);
+ }
+ }
+ exits(retcode? "error" : 0);
+ }
+ if(pid==-1){
+ fprintf(stderr, "Can't fork?!\n");
+ exits("fork");
+ }
+ dup(pipe2[0], 0);
+ close(pipe2[0]);
+ close(pipe2[1]);
+ }
+ if(type=='<'){
+ close(0); /* so it won't read from terminal */
+ open("/dev/null", 0);
+ }
+ execlp(SHPATH, SHPATH, "-c", Strtoc(&plan9cmd), (char *)0);
+ exits("exec");
+ }
+ if(pid == -1)
+ error(Efork);
+ if(type=='<' || type=='|'){
+ int nulls;
+ if(downloaded && addr.r.p1 != addr.r.p2)
+ outTl(Hsnarflen, addr.r.p2-addr.r.p1);
+ snarf(f, addr.r.p1, addr.r.p2, snarfbuf, 0);
+ Fdelete(f, addr.r.p1, addr.r.p2);
+ close(pipe1[1]);
+ io = pipe1[0];
+ f->tdot.p1 = -1;
+ f->ndot.r.p2 = addr.r.p2+readio(f, &nulls, 0);
+ f->ndot.r.p1 = addr.r.p2;
+ closeio((Posn)-1);
+ }else if(type=='>'){
+ close(pipe1[0]);
+ io = pipe1[1];
+ bpipeok = 1;
+ writeio(f);
+ bpipeok = 0;
+ closeio((Posn)-1);
+ }
+ retcode = waitfor(pid);
+ if(type=='|' || type=='<')
+ if(retcode!=0)
+ warn(Wbadstatus);
+ if(downloaded)
+ checkerrs();
+ if(!nest)
+ dprint("!\n");
+ return retcode;
}
void
checkerrs(void)
{
- char buf[256];
- int f, n, nl;
- char *p;
- long l;
+ char buf[256];
+ int f, n, nl;
+ char *p;
+ long l;
- if(statfile(errfile, 0, 0, 0, &l, 0) > 0 && l != 0){
- if((f=open((char *)errfile, 0)) != -1){
- if((n=read(f, buf, sizeof buf-1)) > 0){
- for(nl=0,p=buf; nl<3 && p<&buf[n]; p++)
- if(*p=='\n')
- nl++;
- *p = 0;
- dprint("%s", buf);
- if(p-buf < l-1)
- dprint("(sam: more in %s)\n", errfile);
- }
- close(f);
- }
- }else
- remove((char *)errfile);
+ if(statfile(errfile, 0, 0, 0, &l, 0) > 0 && l != 0){
+ if((f=open((char *)errfile, 0)) != -1){
+ if((n=read(f, buf, sizeof buf-1)) > 0){
+ for(nl=0,p=buf; nl<3 && p<&buf[n]; p++)
+ if(*p=='\n')
+ nl++;
+ *p = 0;
+ dprint("%s", buf);
+ if(p-buf < l-1)
+ dprint("(sam: more in %s)\n", errfile);
+ }
+ close(f);
+ }
+ }else
+ remove((char *)errfile);
}
diff --git a/sam/string.c b/sam/string.c
@@ -1,138 +1,138 @@
/* Copyright (c) 1998 Lucent Technologies - All rights reserved. */
#include "sam.h"
-#define MINSIZE 16 /* minimum number of chars all…
-#define MAXSIZE 256 /* maximum number of chars fo…
+#define MINSIZE 16 /* minimum number of chars allocated */
+#define MAXSIZE 256 /* maximum number of chars for an empty string */
void
Strinit(String *p)
{
- p->s = emalloc(MINSIZE*RUNESIZE);
- p->n = 0;
- p->size = MINSIZE;
+ p->s = emalloc(MINSIZE*RUNESIZE);
+ p->n = 0;
+ p->size = MINSIZE;
}
void
Strinit0(String *p)
{
- p->s = emalloc(MINSIZE*RUNESIZE);
- p->s[0] = 0;
- p->n = 1;
- p->size = MINSIZE;
+ p->s = emalloc(MINSIZE*RUNESIZE);
+ p->s[0] = 0;
+ p->n = 1;
+ p->size = MINSIZE;
}
void
Strclose(String *p)
{
- free(p->s);
+ free(p->s);
}
void
Strzero(String *p)
{
- if(p->size > MAXSIZE){
- p->s = erealloc(p->s, RUNESIZE*MAXSIZE); /* throw away the gar…
- p->size = MAXSIZE;
- }
- p->n = 0;
+ if(p->size > MAXSIZE){
+ p->s = erealloc(p->s, RUNESIZE*MAXSIZE); /* throw away the garbage */
+ p->size = MAXSIZE;
+ }
+ p->n = 0;
}
int
Strlen(Rune *r)
{
- Rune *s;
+ Rune *s;
- for(s=r; *s; s++)
- ;
- return s-r;
+ for(s=r; *s; s++)
+ ;
+ return s-r;
}
void
-Strdupl(String *p, Rune *s) /* copies the null */
+Strdupl(String *p, Rune *s) /* copies the null */
{
- p->n = Strlen(s)+1;
- Strinsure(p, p->n);
- memmove(p->s, s, p->n*RUNESIZE);
+ p->n = Strlen(s)+1;
+ Strinsure(p, p->n);
+ memmove(p->s, s, p->n*RUNESIZE);
}
void
-Strduplstr(String *p, String *q) /* will copy the null if there's one t…
+Strduplstr(String *p, String *q) /* will copy the null if there's one there…
{
- Strinsure(p, q->n);
- p->n = q->n;
- memmove(p->s, q->s, q->n*RUNESIZE);
+ Strinsure(p, q->n);
+ p->n = q->n;
+ memmove(p->s, q->s, q->n*RUNESIZE);
}
void
Straddc(String *p, int c)
{
- Strinsure(p, p->n+1);
- p->s[p->n++] = c;
+ Strinsure(p, p->n+1);
+ p->s[p->n++] = c;
}
void
Strinsure(String *p, ulong n)
{
- if(n > STRSIZE)
- error(Etoolong);
- if(p->size < n){ /* p needs to grow */
- n += 100;
- p->s = erealloc(p->s, n*RUNESIZE);
- p->size = n;
- }
+ if(n > STRSIZE)
+ error(Etoolong);
+ if(p->size < n){ /* p needs to grow */
+ n += 100;
+ p->s = erealloc(p->s, n*RUNESIZE);
+ p->size = n;
+ }
}
void
Strinsert(String *p, String *q, Posn p0)
{
- Strinsure(p, p->n+q->n);
- memmove(p->s+p0+q->n, p->s+p0, (p->n-p0)*RUNESIZE);
- memmove(p->s+p0, q->s, q->n*RUNESIZE);
- p->n += q->n;
+ Strinsure(p, p->n+q->n);
+ memmove(p->s+p0+q->n, p->s+p0, (p->n-p0)*RUNESIZE);
+ memmove(p->s+p0, q->s, q->n*RUNESIZE);
+ p->n += q->n;
}
void
Strdelete(String *p, Posn p1, Posn p2)
{
- memmove(p->s+p1, p->s+p2, (p->n-p2)*RUNESIZE);
- p->n -= p2-p1;
+ memmove(p->s+p1, p->s+p2, (p->n-p2)*RUNESIZE);
+ p->n -= p2-p1;
}
int
Strcmp(String *a, String *b)
{
- int i, c;
+ int i, c;
- for(i=0; i<a->n && i<b->n; i++)
- if(c = (a->s[i] - b->s[i])) /* assign = */
- return c;
- /* damn NULs confuse everything */
- i = a->n - b->n;
- if(i == 1){
- if(a->s[a->n-1] == 0)
- return 0;
- }else if(i == -1){
- if(b->s[b->n-1] == 0)
- return 0;
- }
- return i;
+ for(i=0; i<a->n && i<b->n; i++)
+ if(c = (a->s[i] - b->s[i])) /* assign = */
+ return c;
+ /* damn NULs confuse everything */
+ i = a->n - b->n;
+ if(i == 1){
+ if(a->s[a->n-1] == 0)
+ return 0;
+ }else if(i == -1){
+ if(b->s[b->n-1] == 0)
+ return 0;
+ }
+ return i;
}
char*
Strtoc(String *s)
{
- int i;
- char *c, *d;
- Rune *r;
- c = emalloc(s->n*UTFmax + 1); /* worst case UTFmax bytes per rune, pl…
- d = c;
- r = s->s;
- for(i=0; i<s->n; i++)
- d += runetochar(d, r++);
- if(d==c || d[-1]!=0)
- *d = 0;
- return c;
+ int i;
+ char *c, *d;
+ Rune *r;
+ c = emalloc(s->n*UTFmax + 1); /* worst case UTFmax bytes per rune, plus N…
+ d = c;
+ r = s->s;
+ for(i=0; i<s->n; i++)
+ d += runetochar(d, r++);
+ if(d==c || d[-1]!=0)
+ *d = 0;
+ return c;
}
@@ -142,12 +142,12 @@ Strtoc(String *s)
String*
tmprstr(Rune *r, int n)
{
- static String p;
+ static String p;
- p.s = r;
- p.n = n;
- p.size = n;
- return &p;
+ p.s = r;
+ p.n = n;
+ p.size = n;
+ return &p;
}
/*
@@ -156,24 +156,24 @@ tmprstr(Rune *r, int n)
String*
tmpcstr(char *s)
{
- String *p;
- Rune *r;
- int i, n;
+ String *p;
+ Rune *r;
+ int i, n;
- n = utflen(s); /* don't include NUL */
- p = emalloc(sizeof(String));
- r = emalloc(n*RUNESIZE);
- p->s = r;
- for(i=0; i<n; i++,r++)
- s += chartorune(r, s);
- p->n = n;
- p->size = n;
- return p;
+ n = utflen(s); /* don't include NUL */
+ p = emalloc(sizeof(String));
+ r = emalloc(n*RUNESIZE);
+ p->s = r;
+ for(i=0; i<n; i++,r++)
+ s += chartorune(r, s);
+ p->n = n;
+ p->size = n;
+ return p;
}
void
freetmpstr(String *s)
{
- free(s->s);
- free(s);
+ free(s->s);
+ free(s);
}
diff --git a/sam/sys.c b/sam/sys.c
@@ -10,52 +10,52 @@ static int inerror=FALSE;
void
resetsys(void)
{
- inerror = FALSE;
+ inerror = FALSE;
}
void
syserror(char *a)
{
- char buf[ERRLEN];
-
- if(!inerror){
- inerror=TRUE;
- errstr(buf);
- dprint("%s: ", a);
- error_s(Eio, buf);
- }
+ char buf[ERRLEN];
+
+ if(!inerror){
+ inerror=TRUE;
+ errstr(buf);
+ dprint("%s: ", a);
+ error_s(Eio, buf);
+ }
}
int
Read(int f, void *a, int n)
{
- char buf[ERRLEN];
-
- if(read(f, (char *)a, n)!=n) {
- if (lastfile)
- lastfile->state = Readerr;
- errstr(buf);
- if (downloaded)
- fprintf(stderr, "read error: %s\n", buf);
- rescue();
- exits("read");
- }
- return n;
+ char buf[ERRLEN];
+
+ if(read(f, (char *)a, n)!=n) {
+ if (lastfile)
+ lastfile->state = Readerr;
+ errstr(buf);
+ if (downloaded)
+ fprintf(stderr, "read error: %s\n", buf);
+ rescue();
+ exits("read");
+ }
+ return n;
}
int
Write(int f, void *a, int n)
{
- int m;
+ int m;
- if((m=write(f, (char *)a, n))!=n)
- syserror("write");
- return m;
+ if((m=write(f, (char *)a, n))!=n)
+ syserror("write");
+ return m;
}
void
Seek(int f, long n, int w)
{
- if(seek(f, n, w)==-1)
- syserror("seek");
+ if(seek(f, n, w)==-1)
+ syserror("seek");
}
diff --git a/sam/unix.c b/sam/unix.c
@@ -5,13 +5,13 @@
#include <sys/wait.h>
#include <signal.h>
-#ifdef NEEDVARARG
-#include <varargs.h>
+#ifdef NEEDVARARG
+#include <varargs.h>
#else
-#include <stdarg.h>
+#include <stdarg.h>
#endif
-Rune samname[] = { '~', '~', 's', 'a', 'm', '~', '~', 0 };
+Rune samname[] = { '~', '~', 's', 'a', 'm', '~', '~', 0 };
static Rune l1[] = { '{', '[', '(', '<', 0253, 0};
static Rune l2[] = { '\n', 0};
@@ -26,98 +26,98 @@ Rune *right[]= { r1, r2, r3, 0};
void
print_ss(char *s, String *a, String *b)
{
- char *ap, *bp, *cp;
- Rune *rp;
-
- ap = emalloc(a->n+1);
- for (cp = ap, rp = a->s; *rp; rp++)
- cp += runetochar(cp, rp);
- *cp = 0;
- bp = emalloc(b->n+1);
- for (cp = bp, rp = b->s; *rp; rp++)
- cp += runetochar(cp, rp);
- *cp = 0;
- dprint("?warning: %s `%.*s' and `%.*s'\n", s, a->n, ap, b->n, bp);
- free(ap);
- free(bp);
+ char *ap, *bp, *cp;
+ Rune *rp;
+
+ ap = emalloc(a->n+1);
+ for (cp = ap, rp = a->s; *rp; rp++)
+ cp += runetochar(cp, rp);
+ *cp = 0;
+ bp = emalloc(b->n+1);
+ for (cp = bp, rp = b->s; *rp; rp++)
+ cp += runetochar(cp, rp);
+ *cp = 0;
+ dprint("?warning: %s `%.*s' and `%.*s'\n", s, a->n, ap, b->n, bp);
+ free(ap);
+ free(bp);
}
void
print_s(char *s, String *a)
{
- char *ap, *cp;
- Rune *rp;
-
- ap = emalloc(a->n+1);
- for (cp = ap, rp = a->s; *rp; rp++)
- cp += runetochar(cp, rp);
- *cp = 0;
- dprint("?warning: %s `%.*s'\n", s, a->n, ap);
- free(ap);
+ char *ap, *cp;
+ Rune *rp;
+
+ ap = emalloc(a->n+1);
+ for (cp = ap, rp = a->s; *rp; rp++)
+ cp += runetochar(cp, rp);
+ *cp = 0;
+ dprint("?warning: %s `%.*s'\n", s, a->n, ap);
+ free(ap);
}
int
statfile(char *name, ulong *dev, ulong *id, long *time, long *length, long *ap…
{
- struct stat dirb;
-
- if (stat(name, &dirb) == -1)
- return -1;
- if (dev)
- *dev = dirb.st_dev;
- if (id)
- *id = dirb.st_ino;
- if (time)
- *time = dirb.st_mtime;
- if (length)
- *length = dirb.st_size;
- if(appendonly)
- *appendonly = 0;
- return 1;
+ struct stat dirb;
+
+ if (stat(name, &dirb) == -1)
+ return -1;
+ if (dev)
+ *dev = dirb.st_dev;
+ if (id)
+ *id = dirb.st_ino;
+ if (time)
+ *time = dirb.st_mtime;
+ if (length)
+ *length = dirb.st_size;
+ if(appendonly)
+ *appendonly = 0;
+ return 1;
}
int
statfd(int fd, ulong *dev, ulong *id, long *time, long *length, long *appendon…
{
- struct stat dirb;
-
- if (fstat(fd, &dirb) == -1)
- return -1;
- if (dev)
- *dev = dirb.st_dev;
- if (id)
- *id = dirb.st_ino;
- if (time)
- *time = dirb.st_mtime;
- if (length)
- *length = dirb.st_size;
- if(appendonly)
- *appendonly = 0;
- return 1;
+ struct stat dirb;
+
+ if (fstat(fd, &dirb) == -1)
+ return -1;
+ if (dev)
+ *dev = dirb.st_dev;
+ if (id)
+ *id = dirb.st_ino;
+ if (time)
+ *time = dirb.st_mtime;
+ if (length)
+ *length = dirb.st_size;
+ if(appendonly)
+ *appendonly = 0;
+ return 1;
}
void
hup(int sig)
{
- rescue();
- exit(1);
+ rescue();
+ exit(1);
}
int
notify (void(*f)(void *, char *))
{
- signal(SIGINT, SIG_IGN);
- signal(SIGHUP, hup);
- signal(SIGPIPE, SIG_IGN);
-#ifdef v10
- close(3); /* redirect v10 /dev/tty */
- open("/dev/null", 2);
+ signal(SIGINT, SIG_IGN);
+ signal(SIGHUP, hup);
+ signal(SIGPIPE, SIG_IGN);
+#ifdef v10
+ close(3); /* redirect v10 /dev/tty */
+ open("/dev/null", 2);
#endif
- return 1;
+ return 1;
}
void
-notifyf(void *a, char *b) /* never called */
+notifyf(void *a, char *b) /* never called */
{
}
@@ -133,61 +133,61 @@ newtmp(void)
void
samerr(char *buf)
{
- snprintf(buf, PATH_MAX, "%s/sam.err", getenv("HOME") ? getenv("HOME") …
+ snprintf(buf, PATH_MAX, "%s/sam.err", getenv("HOME") ? getenv("HOME") : "/…
}
int
waitfor(int pid)
{
- int wm;
- int rpid;
+ int wm;
+ int rpid;
- do; while((rpid = wait(&wm)) != pid && rpid != -1);
- return (WEXITSTATUS(wm));
+ do; while((rpid = wait(&wm)) != pid && rpid != -1);
+ return (WEXITSTATUS(wm));
}
void*
emalloc(ulong n)
{
- void *p;
-
- if (n < sizeof(int))
- n = sizeof(int);
- p = malloc(n);
- if(p == 0)
- panic("malloc fails");
- memset(p, 0, n);
- return p;
+ void *p;
+
+ if (n < sizeof(int))
+ n = sizeof(int);
+ p = malloc(n);
+ if(p == 0)
+ panic("malloc fails");
+ memset(p, 0, n);
+ return p;
}
void*
erealloc(void *p, ulong n)
{
- p = realloc(p, n);
- if(p == 0)
- panic("realloc fails");
- return p;
+ p = realloc(p, n);
+ if(p == 0)
+ panic("realloc fails");
+ return p;
}
void
exits(char *message)
{
- if (message == 0)
- exit(0);
- else
- exit(1);
+ if (message == 0)
+ exit(0);
+ else
+ exit(1);
}
void
dprint(char *z, ...)
{
- va_list args;
- char buf[BLOCKSIZE];
+ va_list args;
+ char buf[BLOCKSIZE];
- va_start(args, z);
- vsprintf(buf, z, args);
- termwrite(buf);
- va_end(args);
+ va_start(args, z);
+ vsprintf(buf, z, args);
+ termwrite(buf);
+ va_end(args);
}
diff --git a/sam/xec.c b/sam/xec.c
@@ -2,491 +2,491 @@
#include "sam.h"
#include "parse.h"
-int Glooping;
-int nest;
+int Glooping;
+int nest;
-int append(File*, Cmd*, Posn);
-int display(File*);
-void looper(File*, Cmd*, int);
-void filelooper(Cmd*, int);
-void linelooper(File*, Cmd*);
+int append(File*, Cmd*, Posn);
+int display(File*);
+void looper(File*, Cmd*, int);
+void filelooper(Cmd*, int);
+void linelooper(File*, Cmd*);
void
resetxec(void)
{
- Glooping = nest = 0;
+ Glooping = nest = 0;
}
int
cmdexec(File *f, Cmd *cp)
{
- int i;
- Addr *ap;
- Address a;
-
- if(f && f->state==Unread)
- load(f);
- if(f==0 && (cp->addr==0 || cp->addr->type!='"') &&
- !utfrune("bBnqUXY!", cp->cmdc) &&
- cp->cmdc!=('c'|0x100) && !(cp->cmdc=='D' && cp->ctext))
- error(Enofile);
- i = lookup(cp->cmdc);
- if(i >= 0 && cmdtab[i].defaddr != aNo){
- if((ap=cp->addr)==0 && cp->cmdc!='\n'){
- cp->addr = ap = newaddr();
- ap->type = '.';
- if(cmdtab[i].defaddr == aAll)
- ap->type = '*';
- }else if(ap && ap->type=='"' && ap->next==0 && cp->cmdc!='\n'){
- ap->next = newaddr();
- ap->next->type = '.';
- if(cmdtab[i].defaddr == aAll)
- ap->next->type = '*';
- }
- if(cp->addr){ /* may be false for '\n' (only) */
- static Address none = {0,0,0};
- if(f)
- addr = address(ap, f->dot, 0);
- else /* a " */
- addr = address(ap, none, 0);
- f = addr.f;
- }
- }
- current(f);
- switch(cp->cmdc){
- case '{':
- a = cp->addr? address(cp->addr, f->dot, 0): f->dot;
- for(cp = cp->ccmd; cp; cp = cp->next){
- a.f->dot = a;
- cmdexec(a.f, cp);
- }
- break;
- default:
- i=(*cmdtab[i].fn)(f, cp);
- return i;
- }
- return 1;
+ int i;
+ Addr *ap;
+ Address a;
+
+ if(f && f->state==Unread)
+ load(f);
+ if(f==0 && (cp->addr==0 || cp->addr->type!='"') &&
+ !utfrune("bBnqUXY!", cp->cmdc) &&
+ cp->cmdc!=('c'|0x100) && !(cp->cmdc=='D' && cp->ctext))
+ error(Enofile);
+ i = lookup(cp->cmdc);
+ if(i >= 0 && cmdtab[i].defaddr != aNo){
+ if((ap=cp->addr)==0 && cp->cmdc!='\n'){
+ cp->addr = ap = newaddr();
+ ap->type = '.';
+ if(cmdtab[i].defaddr == aAll)
+ ap->type = '*';
+ }else if(ap && ap->type=='"' && ap->next==0 && cp->cmdc!='\n'){
+ ap->next = newaddr();
+ ap->next->type = '.';
+ if(cmdtab[i].defaddr == aAll)
+ ap->next->type = '*';
+ }
+ if(cp->addr){ /* may be false for '\n' (only) */
+ static Address none = {0,0,0};
+ if(f)
+ addr = address(ap, f->dot, 0);
+ else /* a " */
+ addr = address(ap, none, 0);
+ f = addr.f;
+ }
+ }
+ current(f);
+ switch(cp->cmdc){
+ case '{':
+ a = cp->addr? address(cp->addr, f->dot, 0): f->dot;
+ for(cp = cp->ccmd; cp; cp = cp->next){
+ a.f->dot = a;
+ cmdexec(a.f, cp);
+ }
+ break;
+ default:
+ i=(*cmdtab[i].fn)(f, cp);
+ return i;
+ }
+ return 1;
}
int
a_cmd(File *f, Cmd *cp)
{
- return append(f, cp, addr.r.p2);
+ return append(f, cp, addr.r.p2);
}
int
b_cmd(File *f, Cmd *cp)
{
- USED(f);
- f = cp->cmdc=='b'? tofile(cp->ctext) : getfile(cp->ctext);
- if(f->state == Unread)
- load(f);
- else if(nest == 0)
- filename(f);
- return TRUE;
+ USED(f);
+ f = cp->cmdc=='b'? tofile(cp->ctext) : getfile(cp->ctext);
+ if(f->state == Unread)
+ load(f);
+ else if(nest == 0)
+ filename(f);
+ return TRUE;
}
int
c_cmd(File *f, Cmd *cp)
{
- Fdelete(f, addr.r.p1, addr.r.p2);
- f->ndot.r.p1 = f->ndot.r.p2 = addr.r.p2;
- return append(f, cp, addr.r.p2);
+ Fdelete(f, addr.r.p1, addr.r.p2);
+ f->ndot.r.p1 = f->ndot.r.p2 = addr.r.p2;
+ return append(f, cp, addr.r.p2);
}
int
d_cmd(File *f, Cmd *cp)
{
- USED(cp);
- Fdelete(f, addr.r.p1, addr.r.p2);
- f->ndot.r.p1 = f->ndot.r.p2 = addr.r.p1;
- return TRUE;
+ USED(cp);
+ Fdelete(f, addr.r.p1, addr.r.p2);
+ f->ndot.r.p1 = f->ndot.r.p2 = addr.r.p1;
+ return TRUE;
}
int
D_cmd(File *f, Cmd *cp)
{
- closefiles(f, cp->ctext);
- return TRUE;
+ closefiles(f, cp->ctext);
+ return TRUE;
}
int
e_cmd(File *f, Cmd *cp)
{
- if(getname(f, cp->ctext, cp->cmdc=='e')==0)
- error(Enoname);
- edit(f, cp->cmdc);
- return TRUE;
+ if(getname(f, cp->ctext, cp->cmdc=='e')==0)
+ error(Enoname);
+ edit(f, cp->cmdc);
+ return TRUE;
}
int
f_cmd(File *f, Cmd *cp)
{
- getname(f, cp->ctext, TRUE);
- filename(f);
- return TRUE;
+ getname(f, cp->ctext, TRUE);
+ filename(f);
+ return TRUE;
}
int
g_cmd(File *f, Cmd *cp)
{
- if(f!=addr.f)panic("g_cmd f!=addr.f");
- compile(cp->re);
- if(execute(f, addr.r.p1, addr.r.p2) ^ cp->cmdc=='v'){
- f->dot = addr;
- return cmdexec(f, cp->ccmd);
- }
- return TRUE;
+ if(f!=addr.f)panic("g_cmd f!=addr.f");
+ compile(cp->re);
+ if(execute(f, addr.r.p1, addr.r.p2) ^ cp->cmdc=='v'){
+ f->dot = addr;
+ return cmdexec(f, cp->ccmd);
+ }
+ return TRUE;
}
int
i_cmd(File *f, Cmd *cp)
{
- return append(f, cp, addr.r.p1);
+ return append(f, cp, addr.r.p1);
}
int
k_cmd(File *f, Cmd *cp)
{
- USED(cp);
- f->mark = addr.r;
- return TRUE;
+ USED(cp);
+ f->mark = addr.r;
+ return TRUE;
}
int
m_cmd(File *f, Cmd *cp)
{
- Address addr2;
-
- addr2 = address(cp->caddr, f->dot, 0);
- if(cp->cmdc=='m')
- move(f, addr2);
- else
- copy(f, addr2);
- return TRUE;
+ Address addr2;
+
+ addr2 = address(cp->caddr, f->dot, 0);
+ if(cp->cmdc=='m')
+ move(f, addr2);
+ else
+ copy(f, addr2);
+ return TRUE;
}
int
n_cmd(File *f, Cmd *cp)
{
- int i;
- USED(f);
- USED(cp);
- for(i = 0; i<file.nused; i++){
- if(file.filepptr[i] == cmd)
- continue;
- f = file.filepptr[i];
- Strduplstr(&genstr, &f->name);
- filename(f);
- }
- return TRUE;
+ int i;
+ USED(f);
+ USED(cp);
+ for(i = 0; i<file.nused; i++){
+ if(file.filepptr[i] == cmd)
+ continue;
+ f = file.filepptr[i];
+ Strduplstr(&genstr, &f->name);
+ filename(f);
+ }
+ return TRUE;
}
int
p_cmd(File *f, Cmd *cp)
{
- USED(cp);
- return display(f);
+ USED(cp);
+ return display(f);
}
int
q_cmd(File *f, Cmd *cp)
{
- USED(cp);
- USED(f);
- trytoquit();
- if(downloaded){
- outT0(Hexit);
- return TRUE;
- }
- return FALSE;
+ USED(cp);
+ USED(f);
+ trytoquit();
+ if(downloaded){
+ outT0(Hexit);
+ return TRUE;
+ }
+ return FALSE;
}
int
s_cmd(File *f, Cmd *cp)
{
- int i, j, c, n;
- Posn p1, op, didsub = 0, delta = 0;
-
- n = cp->num;
- op= -1;
- compile(cp->re);
- for(p1 = addr.r.p1; p1<=addr.r.p2 && execute(f, p1, addr.r.p2); ){
- if(sel.p[0].p1==sel.p[0].p2){ /* empty match? */
- if(sel.p[0].p1==op){
- p1++;
- continue;
- }
- p1 = sel.p[0].p2+1;
- }else
- p1 = sel.p[0].p2;
- op = sel.p[0].p2;
- if(--n>0)
- continue;
- Strzero(&genstr);
- for(i = 0; i<cp->ctext->n; i++)
- if((c = cp->ctext->s[i])=='\\' && i<cp->ctext->n-1){
- c = cp->ctext->s[++i];
- if('1'<=c && c<='9') {
- j = c-'0';
- if(sel.p[j].p2-sel.p[j].p1>BLOCKSIZE)
- error(Elongtag);
- Fchars(f, genbuf, sel.p[j].p1, sel.p[j…
- Strinsert(&genstr, tmprstr(genbuf, (se…
- }else
- Straddc(&genstr, c);
- }else if(c!='&')
- Straddc(&genstr, c);
- else{
- if(sel.p[0].p2-sel.p[0].p1>BLOCKSIZE)
- error(Elongrhs);
- Fchars(f, genbuf, sel.p[0].p1, sel.p[0].p2);
- Strinsert(&genstr,
- tmprstr(genbuf, (int)(sel.p[0].p2-sel.…
- genstr.n);
- }
- if(sel.p[0].p1!=sel.p[0].p2){
- Fdelete(f, sel.p[0].p1, sel.p[0].p2);
- delta-=sel.p[0].p2-sel.p[0].p1;
- }
- if(genstr.n){
- Finsert(f, &genstr, sel.p[0].p2);
- delta+=genstr.n;
- }
- didsub = 1;
- if(!cp->flag)
- break;
- }
- if(!didsub && nest==0)
- error(Enosub);
- f->ndot.r.p1 = addr.r.p1, f->ndot.r.p2 = addr.r.p2+delta;
- return TRUE;
+ int i, j, c, n;
+ Posn p1, op, didsub = 0, delta = 0;
+
+ n = cp->num;
+ op= -1;
+ compile(cp->re);
+ for(p1 = addr.r.p1; p1<=addr.r.p2 && execute(f, p1, addr.r.p2); ){
+ if(sel.p[0].p1==sel.p[0].p2){ /* empty match? */
+ if(sel.p[0].p1==op){
+ p1++;
+ continue;
+ }
+ p1 = sel.p[0].p2+1;
+ }else
+ p1 = sel.p[0].p2;
+ op = sel.p[0].p2;
+ if(--n>0)
+ continue;
+ Strzero(&genstr);
+ for(i = 0; i<cp->ctext->n; i++)
+ if((c = cp->ctext->s[i])=='\\' && i<cp->ctext->n-1){
+ c = cp->ctext->s[++i];
+ if('1'<=c && c<='9') {
+ j = c-'0';
+ if(sel.p[j].p2-sel.p[j].p1>BLOCKSIZE)
+ error(Elongtag);
+ Fchars(f, genbuf, sel.p[j].p1, sel.p[j].p2);
+ Strinsert(&genstr, tmprstr(genbuf, (sel.p[j].p2-sel.p[j].p…
+ }else
+ Straddc(&genstr, c);
+ }else if(c!='&')
+ Straddc(&genstr, c);
+ else{
+ if(sel.p[0].p2-sel.p[0].p1>BLOCKSIZE)
+ error(Elongrhs);
+ Fchars(f, genbuf, sel.p[0].p1, sel.p[0].p2);
+ Strinsert(&genstr,
+ tmprstr(genbuf, (int)(sel.p[0].p2-sel.p[0].p1)),
+ genstr.n);
+ }
+ if(sel.p[0].p1!=sel.p[0].p2){
+ Fdelete(f, sel.p[0].p1, sel.p[0].p2);
+ delta-=sel.p[0].p2-sel.p[0].p1;
+ }
+ if(genstr.n){
+ Finsert(f, &genstr, sel.p[0].p2);
+ delta+=genstr.n;
+ }
+ didsub = 1;
+ if(!cp->flag)
+ break;
+ }
+ if(!didsub && nest==0)
+ error(Enosub);
+ f->ndot.r.p1 = addr.r.p1, f->ndot.r.p2 = addr.r.p2+delta;
+ return TRUE;
}
int
u_cmd(File *f, Cmd *cp)
{
- int n;
- USED(f);
- USED(cp);
- n = cp->num;
- while(n-- && undo())
- ;
- return TRUE;
+ int n;
+ USED(f);
+ USED(cp);
+ n = cp->num;
+ while(n-- && undo())
+ ;
+ return TRUE;
}
int
w_cmd(File *f, Cmd *cp)
{
- if(getname(f, cp->ctext, FALSE)==0)
- error(Enoname);
- writef(f);
- return TRUE;
+ if(getname(f, cp->ctext, FALSE)==0)
+ error(Enoname);
+ writef(f);
+ return TRUE;
}
int
x_cmd(File *f, Cmd *cp)
{
- if(cp->re)
- looper(f, cp, cp->cmdc=='x');
- else
- linelooper(f, cp);
- return TRUE;
+ if(cp->re)
+ looper(f, cp, cp->cmdc=='x');
+ else
+ linelooper(f, cp);
+ return TRUE;
}
int
X_cmd(File *f, Cmd *cp)
{
- USED(f);
- filelooper(cp, cp->cmdc=='X');
- return TRUE;
+ USED(f);
+ filelooper(cp, cp->cmdc=='X');
+ return TRUE;
}
int
plan9_cmd(File *f, Cmd *cp)
{
- plan9(f, cp->cmdc, cp->ctext, nest);
- return TRUE;
+ plan9(f, cp->cmdc, cp->ctext, nest);
+ return TRUE;
}
int
eq_cmd(File *f, Cmd *cp)
{
- int charsonly;
-
- switch(cp->ctext->n){
- case 1:
- charsonly = FALSE;
- break;
- case 2:
- if(cp->ctext->s[0]=='#'){
- charsonly = TRUE;
- break;
- }
- default:
- SET(charsonly);
- error(Enewline);
- }
- printposn(f, charsonly);
- return TRUE;
+ int charsonly;
+
+ switch(cp->ctext->n){
+ case 1:
+ charsonly = FALSE;
+ break;
+ case 2:
+ if(cp->ctext->s[0]=='#'){
+ charsonly = TRUE;
+ break;
+ }
+ default:
+ SET(charsonly);
+ error(Enewline);
+ }
+ printposn(f, charsonly);
+ return TRUE;
}
int
nl_cmd(File *f, Cmd *cp)
{
- if(cp->addr == 0){
- /* First put it on newline boundaries */
- addr = lineaddr((Posn)0, f->dot, -1);
- addr.r.p2 = lineaddr((Posn)0, f->dot, 1).r.p2;
- if(addr.r.p1==f->dot.r.p1 && addr.r.p2==f->dot.r.p2)
- addr = lineaddr((Posn)1, f->dot, 1);
- display(f);
- }else if(downloaded)
- moveto(f, addr.r);
- else
- display(f);
- return TRUE;
+ if(cp->addr == 0){
+ /* First put it on newline boundaries */
+ addr = lineaddr((Posn)0, f->dot, -1);
+ addr.r.p2 = lineaddr((Posn)0, f->dot, 1).r.p2;
+ if(addr.r.p1==f->dot.r.p1 && addr.r.p2==f->dot.r.p2)
+ addr = lineaddr((Posn)1, f->dot, 1);
+ display(f);
+ }else if(downloaded)
+ moveto(f, addr.r);
+ else
+ display(f);
+ return TRUE;
}
int
cd_cmd(File *f, Cmd *cp)
{
- USED(f);
- cd(cp->ctext);
- return TRUE;
+ USED(f);
+ cd(cp->ctext);
+ return TRUE;
}
int
append(File *f, Cmd *cp, Posn p)
{
- if(cp->ctext->n>0 && cp->ctext->s[cp->ctext->n-1]==0)
- --cp->ctext->n;
- if(cp->ctext->n>0)
- Finsert(f, cp->ctext, p);
- f->ndot.r.p1 = p;
- f->ndot.r.p2 = p+cp->ctext->n;
- return TRUE;
+ if(cp->ctext->n>0 && cp->ctext->s[cp->ctext->n-1]==0)
+ --cp->ctext->n;
+ if(cp->ctext->n>0)
+ Finsert(f, cp->ctext, p);
+ f->ndot.r.p1 = p;
+ f->ndot.r.p2 = p+cp->ctext->n;
+ return TRUE;
}
int
display(File *f)
{
- Posn p1, p2;
- int np, n;
- char *c;
-
- p1 = addr.r.p1;
- p2 = addr.r.p2;
- while(p1 < p2){
- np = p2-p1;
- if(np>BLOCKSIZE-1)
- np = BLOCKSIZE-1;
- n = Fchars(f, genbuf, p1, p1+np);
- if(n <= 0)
- panic("display");
- genbuf[n] = 0;
- c = Strtoc(tmprstr(genbuf, n+1));
- if(downloaded)
- termwrite(c);
- else
- Write(1, c, strlen(c));
- free(c);
- p1+=n;
- }
- f->dot = addr;
- return TRUE;
+ Posn p1, p2;
+ int np, n;
+ char *c;
+
+ p1 = addr.r.p1;
+ p2 = addr.r.p2;
+ while(p1 < p2){
+ np = p2-p1;
+ if(np>BLOCKSIZE-1)
+ np = BLOCKSIZE-1;
+ n = Fchars(f, genbuf, p1, p1+np);
+ if(n <= 0)
+ panic("display");
+ genbuf[n] = 0;
+ c = Strtoc(tmprstr(genbuf, n+1));
+ if(downloaded)
+ termwrite(c);
+ else
+ Write(1, c, strlen(c));
+ free(c);
+ p1+=n;
+ }
+ f->dot = addr;
+ return TRUE;
}
void
looper(File *f, Cmd *cp, int xy)
{
- Posn p, op;
- Range r;
-
- r = addr.r;
- op= xy? -1 : r.p1;
- nest++;
- compile(cp->re);
- for(p = r.p1; p<=r.p2; ){
- if(!execute(f, p, r.p2)){ /* no match, but y should still run …
- if(xy || op>r.p2)
- break;
- f->dot.r.p1 = op, f->dot.r.p2 = r.p2;
- p = r.p2+1; /* exit next loop */
- }else{
- if(sel.p[0].p1==sel.p[0].p2){ /* empty match? */
- if(sel.p[0].p1==op){
- p++;
- continue;
- }
- p = sel.p[0].p2+1;
- }else
- p = sel.p[0].p2;
- if(xy)
- f->dot.r = sel.p[0];
- else
- f->dot.r.p1 = op, f->dot.r.p2 = sel.p[0].p1;
- }
- op = sel.p[0].p2;
- cmdexec(f, cp->ccmd);
- compile(cp->re);
- }
- --nest;
+ Posn p, op;
+ Range r;
+
+ r = addr.r;
+ op= xy? -1 : r.p1;
+ nest++;
+ compile(cp->re);
+ for(p = r.p1; p<=r.p2; ){
+ if(!execute(f, p, r.p2)){ /* no match, but y should still run */
+ if(xy || op>r.p2)
+ break;
+ f->dot.r.p1 = op, f->dot.r.p2 = r.p2;
+ p = r.p2+1; /* exit next loop */
+ }else{
+ if(sel.p[0].p1==sel.p[0].p2){ /* empty match? */
+ if(sel.p[0].p1==op){
+ p++;
+ continue;
+ }
+ p = sel.p[0].p2+1;
+ }else
+ p = sel.p[0].p2;
+ if(xy)
+ f->dot.r = sel.p[0];
+ else
+ f->dot.r.p1 = op, f->dot.r.p2 = sel.p[0].p1;
+ }
+ op = sel.p[0].p2;
+ cmdexec(f, cp->ccmd);
+ compile(cp->re);
+ }
+ --nest;
}
void
linelooper(File *f, Cmd *cp)
{
- Posn p;
- Range r, linesel;
- Address a3;
-
- nest++;
- r = addr.r;
- a3.f = f;
- a3.r.p1 = a3.r.p2 = r.p1;
- for(p = r.p1; p<r.p2; p = a3.r.p2){
- a3.r.p1 = a3.r.p2;
-/*pjw if(p!=r.p1 || (linesel = lineaddr((Posn)0, a3, 1)).r.p2==…
- if(p!=r.p1 || ((linesel = lineaddr((Posn)0, a3, 1).r), linesel…
- linesel = lineaddr((Posn)1, a3, 1).r;
- if(linesel.p1 >= r.p2)
- break;
- if(linesel.p2 >= r.p2)
- linesel.p2 = r.p2;
- if(linesel.p2 > linesel.p1)
- if(linesel.p1>=a3.r.p2 && linesel.p2>a3.r.p2){
- f->dot.r = linesel;
- cmdexec(f, cp->ccmd);
- a3.r = linesel;
- continue;
- }
- break;
- }
- --nest;
+ Posn p;
+ Range r, linesel;
+ Address a3;
+
+ nest++;
+ r = addr.r;
+ a3.f = f;
+ a3.r.p1 = a3.r.p2 = r.p1;
+ for(p = r.p1; p<r.p2; p = a3.r.p2){
+ a3.r.p1 = a3.r.p2;
+/*pjw if(p!=r.p1 || (linesel = lineaddr((Posn)0, a3, 1)).r.p2==p)*/
+ if(p!=r.p1 || ((linesel = lineaddr((Posn)0, a3, 1).r), linesel.p2==p))
+ linesel = lineaddr((Posn)1, a3, 1).r;
+ if(linesel.p1 >= r.p2)
+ break;
+ if(linesel.p2 >= r.p2)
+ linesel.p2 = r.p2;
+ if(linesel.p2 > linesel.p1)
+ if(linesel.p1>=a3.r.p2 && linesel.p2>a3.r.p2){
+ f->dot.r = linesel;
+ cmdexec(f, cp->ccmd);
+ a3.r = linesel;
+ continue;
+ }
+ break;
+ }
+ --nest;
}
void
filelooper(Cmd *cp, int XY)
{
- File *f, *cur;
- int i;
-
- if(Glooping++)
- error(EnestXY);
- nest++;
- settempfile();
- cur = curfile;
- for(i = 0; i<tempfile.nused; i++){
- f = tempfile.filepptr[i];
- if(f==cmd)
- continue;
- if(cp->re==0 || filematch(f, cp->re)==XY)
- cmdexec(f, cp->ccmd);
- }
- if(cur && whichmenu(cur)>=0) /* check that cur is still a file …
- current(cur);
- --Glooping;
- --nest;
+ File *f, *cur;
+ int i;
+
+ if(Glooping++)
+ error(EnestXY);
+ nest++;
+ settempfile();
+ cur = curfile;
+ for(i = 0; i<tempfile.nused; i++){
+ f = tempfile.filepptr[i];
+ if(f==cmd)
+ continue;
+ if(cp->re==0 || filematch(f, cp->re)==XY)
+ cmdexec(f, cp->ccmd);
+ }
+ if(cur && whichmenu(cur)>=0) /* check that cur is still a file */
+ current(cur);
+ --Glooping;
+ --nest;
}
diff --git a/samterm/flayer.c b/samterm/flayer.c
@@ -6,441 +6,441 @@
#include "flayer.h"
#include "samterm.h"
-#define DELTA 10
+#define DELTA 10
-static Flayer **llist; /* front to back */
-static int nllist;
-static int nlalloc;
+static Flayer **llist; /* front to back */
+static int nllist;
+static int nlalloc;
static Rectangle lDrect;
-extern Bitmap screen;
-extern Mouse mouse;
+extern Bitmap screen;
+extern Mouse mouse;
extern unsigned long _bgpixel;
-Vis visibility(Flayer *);
-void newvisibilities(int);
-void llinsert(Flayer*);
-void lldelete(Flayer*);
+Vis visibility(Flayer *);
+void newvisibilities(int);
+void llinsert(Flayer*);
+void lldelete(Flayer*);
void
flstart(Rectangle r)
{
- lDrect = r;
+ lDrect = r;
}
void
flnew(Flayer *l, Rune *(*fn)(Flayer*, long, ulong*), int u0, void *u1)
{
- if(nllist == nlalloc){
- nlalloc += DELTA;
- llist = realloc(llist, nlalloc*sizeof(Flayer**));
- if(llist == 0)
- panic("flnew");
- }
- l->textfn = fn;
- l->user0 = u0;
- l->user1 = u1;
+ if(nllist == nlalloc){
+ nlalloc += DELTA;
+ llist = realloc(llist, nlalloc*sizeof(Flayer**));
+ if(llist == 0)
+ panic("flnew");
+ }
+ l->textfn = fn;
+ l->user0 = u0;
+ l->user1 = u1;
l->bg = _bgpixel;
- llinsert(l);
+ llinsert(l);
}
Rectangle
flrect(Flayer *l, Rectangle r)
{
- rectclip(&r, lDrect);
- l->entire = r;
- l->scroll = inset(r, FLMARGIN);
- r.min.x =
- l->scroll.max.x = r.min.x+FLMARGIN+FLSCROLLWID+(FLGAP-FLMARGIN);
- return r;
+ rectclip(&r, lDrect);
+ l->entire = r;
+ l->scroll = inset(r, FLMARGIN);
+ r.min.x =
+ l->scroll.max.x = r.min.x+FLMARGIN+FLSCROLLWID+(FLGAP-FLMARGIN);
+ return r;
}
void
flinit(Flayer *l, Rectangle r, XftFont *ft, unsigned long bg)
{
- lldelete(l);
- llinsert(l);
- l->visible = All;
- l->origin = l->p0 = l->p1 = 0;
- frinit(&l->f, inset(flrect(l, r), FLMARGIN), ft, &screen, bg);
+ lldelete(l);
+ llinsert(l);
+ l->visible = All;
+ l->origin = l->p0 = l->p1 = 0;
+ frinit(&l->f, inset(flrect(l, r), FLMARGIN), ft, &screen, bg);
l->bg = bg;
- newvisibilities(1);
- bitblt2(&screen, l->entire.min, &screen, l->entire, 0, 0, l->bg);
- scrdraw(l, 0L);
- flborder(l, 0);
+ newvisibilities(1);
+ bitblt2(&screen, l->entire.min, &screen, l->entire, 0, 0, l->bg);
+ scrdraw(l, 0L);
+ flborder(l, 0);
}
void
flclose(Flayer *l)
{
- if(l->visible == All)
- bitblt2(&screen, l->entire.min, &screen, l->entire, 0, _bgpixe…
- else if(l->visible == Some){
- if(l->f.b == 0)
- l->f.b = balloc(l->entire, screen.ldepth);
- if(l->f.b){
- bitblt2(l->f.b, l->entire.min, l->f.b, l->entire, 0, _…
- flrefresh(l, l->entire, 0);
- }
- }
- frclear(&l->f);
- lldelete(l);
- if(l->f.b && l->visible!=All)
- bfree(l->f.b);
- l->textfn = 0;
- newvisibilities(1);
+ if(l->visible == All)
+ bitblt2(&screen, l->entire.min, &screen, l->entire, 0, _bgpixel, _bgpi…
+ else if(l->visible == Some){
+ if(l->f.b == 0)
+ l->f.b = balloc(l->entire, screen.ldepth);
+ if(l->f.b){
+ bitblt2(l->f.b, l->entire.min, l->f.b, l->entire, 0, _bgpixel, _bg…
+ flrefresh(l, l->entire, 0);
+ }
+ }
+ frclear(&l->f);
+ lldelete(l);
+ if(l->f.b && l->visible!=All)
+ bfree(l->f.b);
+ l->textfn = 0;
+ newvisibilities(1);
}
void
flborder(Flayer *l, int wide)
{
- if(flprepare(l)){
- border(l->f.b, l->entire, FLMARGIN, 0, l->bg);
- border(l->f.b, l->entire, wide? FLMARGIN : 1, F&~D, l->bg);
- if(l->visible==Some)
- flrefresh(l, l->entire, 0);
- }
+ if(flprepare(l)){
+ border(l->f.b, l->entire, FLMARGIN, 0, l->bg);
+ border(l->f.b, l->entire, wide? FLMARGIN : 1, F&~D, l->bg);
+ if(l->visible==Some)
+ flrefresh(l, l->entire, 0);
+ }
}
Flayer *
flwhich(Point p)
{
- int i;
-
- if(p.x==0 && p.y==0)
- return nllist? llist[0] : 0;
- for(i=0; i<nllist; i++)
- if(ptinrect(p, llist[i]->entire))
- return llist[i];
- return 0;
+ int i;
+
+ if(p.x==0 && p.y==0)
+ return nllist? llist[0] : 0;
+ for(i=0; i<nllist; i++)
+ if(ptinrect(p, llist[i]->entire))
+ return llist[i];
+ return 0;
}
void
flupfront(Flayer *l)
{
- int v = l->visible;
+ int v = l->visible;
- lldelete(l);
- llinsert(l);
- if(v!=All)
- newvisibilities(0);
+ lldelete(l);
+ llinsert(l);
+ if(v!=All)
+ newvisibilities(0);
}
void
newvisibilities(int redraw)
- /* if redraw false, we know it's a flupfront, and needn't
- * redraw anyone becoming partially covered */
+ /* if redraw false, we know it's a flupfront, and needn't
+ * redraw anyone becoming partially covered */
{
- int i;
- Vis ov;
- Flayer *l;
-
- for(i = 0; i<nllist; i++){
- l = llist[i];
- ov = l->visible;
- l->visible = visibility(l);
-#define V(a, b) (((a)<<2)|((b)))
- switch(V(ov, l->visible)){
- case V(Some, None):
- if(l->f.b)
- bfree(l->f.b);
- case V(All, None):
- case V(All, Some):
- l->f.b = 0;
- frclear(&l->f);
- break;
-
- case V(Some, Some):
- if(l->f.b==0 && redraw)
- case V(None, Some):
- flprepare(l);
- if(l->f.b && redraw){
- flrefresh(l, l->entire, 0);
- bfree(l->f.b);
- l->f.b = 0;
- frclear(&l->f);
- }
- case V(None, None):
- case V(All, All):
- break;
-
- case V(Some, All):
- if(l->f.b){
- bitblt2(&screen, l->entire.min, l->f.b, l->ent…
- bfree(l->f.b);
- l->f.b = &screen;
- break;
- }
- case V(None, All):
- flprepare(l);
- break;
- }
- if(ov==None && l->visible!=None)
- flnewlyvisible(l);
- }
+ int i;
+ Vis ov;
+ Flayer *l;
+
+ for(i = 0; i<nllist; i++){
+ l = llist[i];
+ ov = l->visible;
+ l->visible = visibility(l);
+#define V(a, b) (((a)<<2)|((b)))
+ switch(V(ov, l->visible)){
+ case V(Some, None):
+ if(l->f.b)
+ bfree(l->f.b);
+ case V(All, None):
+ case V(All, Some):
+ l->f.b = 0;
+ frclear(&l->f);
+ break;
+
+ case V(Some, Some):
+ if(l->f.b==0 && redraw)
+ case V(None, Some):
+ flprepare(l);
+ if(l->f.b && redraw){
+ flrefresh(l, l->entire, 0);
+ bfree(l->f.b);
+ l->f.b = 0;
+ frclear(&l->f);
+ }
+ case V(None, None):
+ case V(All, All):
+ break;
+
+ case V(Some, All):
+ if(l->f.b){
+ bitblt2(&screen, l->entire.min, l->f.b, l->entire, S, 0, l->bg…
+ bfree(l->f.b);
+ l->f.b = &screen;
+ break;
+ }
+ case V(None, All):
+ flprepare(l);
+ break;
+ }
+ if(ov==None && l->visible!=None)
+ flnewlyvisible(l);
+ }
}
void
llinsert(Flayer *l)
{
- int i;
- for(i=nllist; i>0; --i)
- llist[i]=llist[i-1];
- llist[0]=l;
- nllist++;
+ int i;
+ for(i=nllist; i>0; --i)
+ llist[i]=llist[i-1];
+ llist[0]=l;
+ nllist++;
}
void
lldelete(Flayer *l)
{
- int i;
-
- for(i=0; i<nllist; i++)
- if(llist[i]==l){
- --nllist;
- for(; i<nllist; i++)
- llist[i] = llist[i+1];
- return;
- }
- panic("lldelete");
+ int i;
+
+ for(i=0; i<nllist; i++)
+ if(llist[i]==l){
+ --nllist;
+ for(; i<nllist; i++)
+ llist[i] = llist[i+1];
+ return;
+ }
+ panic("lldelete");
}
void
flinsert(Flayer *l, Rune *sp, Rune *ep, long p0)
{
- if(flprepare(l)){
- frinsert(&l->f, sp, ep, p0-l->origin);
- scrdraw(l, scrtotal(l));
- if(l->visible==Some)
- flrefresh(l, l->entire, 0);
- }
+ if(flprepare(l)){
+ frinsert(&l->f, sp, ep, p0-l->origin);
+ scrdraw(l, scrtotal(l));
+ if(l->visible==Some)
+ flrefresh(l, l->entire, 0);
+ }
}
void
fldelete(Flayer *l, long p0, long p1)
{
- if(flprepare(l)){
- p0 -= l->origin;
- if(p0 < 0)
- p0 = 0;
- p1 -= l->origin;
- if(p1<0)
- p1 = 0;
- frdelete(&l->f, p0, p1);
- scrdraw(l, scrtotal(l));
- if(l->visible==Some)
- flrefresh(l, l->entire, 0);
- }
+ if(flprepare(l)){
+ p0 -= l->origin;
+ if(p0 < 0)
+ p0 = 0;
+ p1 -= l->origin;
+ if(p1<0)
+ p1 = 0;
+ frdelete(&l->f, p0, p1);
+ scrdraw(l, scrtotal(l));
+ if(l->visible==Some)
+ flrefresh(l, l->entire, 0);
+ }
}
int
flselect(Flayer *l)
{
- int ret = 0;
- if(l->visible!=All)
- flupfront(l);
- if(mouse.msec-l->click<Clicktime)
- ret = 1;
- frselect(&l->f, &mouse);
- if(l->f.p0==l->f.p1){
- if(ret == 1 && l->f.p0+l->origin==l->p0){
- ret = 1;
- l->click = 0;
- }else {
- ret = 0;
- l->click = mouse.msec;
- }
- }else {
- ret = 0;
- l->click = 0;
- }
- l->p0 = l->f.p0+l->origin, l->p1 = l->f.p1+l->origin;
- return ret;
+ int ret = 0;
+ if(l->visible!=All)
+ flupfront(l);
+ if(mouse.msec-l->click<Clicktime)
+ ret = 1;
+ frselect(&l->f, &mouse);
+ if(l->f.p0==l->f.p1){
+ if(ret == 1 && l->f.p0+l->origin==l->p0){
+ ret = 1;
+ l->click = 0;
+ }else {
+ ret = 0;
+ l->click = mouse.msec;
+ }
+ }else {
+ ret = 0;
+ l->click = 0;
+ }
+ l->p0 = l->f.p0+l->origin, l->p1 = l->f.p1+l->origin;
+ return ret;
}
void
flsetselect(Flayer *l, long p0, long p1)
{
- ulong fp0, fp1;
-
- l->click = 0;
- if(l->visible==None || !flprepare(l)){
- l->p0 = p0, l->p1 = p1;
- return;
- }
- l->p0 = p0, l->p1 = p1;
- flfp0p1(l, &fp0, &fp1);
- if(fp0==l->f.p0 && fp1==l->f.p1)
- return;
- frselectp(&l->f, F&~D);
- l->f.p0 = fp0, l->f.p1 = fp1;
- frselectp(&l->f, F&~D);
- if(l->visible==Some)
- flrefresh(l, l->entire, 0);
+ ulong fp0, fp1;
+
+ l->click = 0;
+ if(l->visible==None || !flprepare(l)){
+ l->p0 = p0, l->p1 = p1;
+ return;
+ }
+ l->p0 = p0, l->p1 = p1;
+ flfp0p1(l, &fp0, &fp1);
+ if(fp0==l->f.p0 && fp1==l->f.p1)
+ return;
+ frselectp(&l->f, F&~D);
+ l->f.p0 = fp0, l->f.p1 = fp1;
+ frselectp(&l->f, F&~D);
+ if(l->visible==Some)
+ flrefresh(l, l->entire, 0);
}
void
flfp0p1(Flayer *l, ulong *pp0, ulong *pp1)
{
- long p0 = l->p0-l->origin, p1 = l->p1-l->origin;
-
- if(p0 < 0)
- p0 = 0;
- if(p1 < 0)
- p1 = 0;
- if(p0 > l->f.nchars)
- p0 = l->f.nchars;
- if(p1 > l->f.nchars)
- p1 = l->f.nchars;
- *pp0 = p0;
- *pp1 = p1;
+ long p0 = l->p0-l->origin, p1 = l->p1-l->origin;
+
+ if(p0 < 0)
+ p0 = 0;
+ if(p1 < 0)
+ p1 = 0;
+ if(p0 > l->f.nchars)
+ p0 = l->f.nchars;
+ if(p1 > l->f.nchars)
+ p1 = l->f.nchars;
+ *pp0 = p0;
+ *pp1 = p1;
}
Rectangle
rscale(Rectangle r, Point old, Point new)
{
- r.min.x = r.min.x*new.x/old.x;
- r.min.y = r.min.y*new.y/old.y;
- r.max.x = r.max.x*new.x/old.x;
- r.max.y = r.max.y*new.y/old.y;
- return r;
+ r.min.x = r.min.x*new.x/old.x;
+ r.min.y = r.min.y*new.y/old.y;
+ r.max.x = r.max.x*new.x/old.x;
+ r.max.y = r.max.y*new.y/old.y;
+ return r;
}
void
flreshape(Rectangle dr)
{
- int i;
- Flayer *l;
- Frame *f;
- Rectangle r, olDrect;
- int move;
-
- olDrect = lDrect;
- lDrect = dr;
- move = 0;
+ int i;
+ Flayer *l;
+ Frame *f;
+ Rectangle r, olDrect;
+ int move;
+
+ olDrect = lDrect;
+ lDrect = dr;
+ move = 0;
bitblt2(&screen, lDrect.min, &screen, lDrect, 0, 0, _bgpixel);
- for(i=0; i<nllist; i++){
- l = llist[i];
- f = &l->f;
- if(move)
- r = raddp(rsubp(l->entire, olDrect.min), dr.min);
- else{
- r = raddp(rscale(rsubp(l->entire, olDrect.min),
- sub(olDrect.max, olDrect.min),
- sub(dr.max, dr.min)), dr.min);
- if(l->visible==Some && f->b){
- bfree(f->b);
- frclear(f);
- }
- f->b = 0;
- if(l->visible!=None)
- frclear(f);
- }
- if(!rectclip(&r, dr))
- panic("flreshape");
- if(r.max.x-r.min.x<100)
- r.min.x = dr.min.x;
- if(r.max.x-r.min.x<100)
- r.max.x = dr.max.x;
- if(r.max.y-r.min.y<2*FLMARGIN+f->fheight)
- r.min.y = dr.min.y;
- if(r.max.y-r.min.y<2*FLMARGIN+f->fheight)
- r.max.y = dr.max.y;
- if(!move)
- l->visible = None;
- frsetrects(f, inset(flrect(l, r), FLMARGIN), f->b);
- if(!move && f->b)
- scrdraw(l, scrtotal(l));
- }
- newvisibilities(1);
+ for(i=0; i<nllist; i++){
+ l = llist[i];
+ f = &l->f;
+ if(move)
+ r = raddp(rsubp(l->entire, olDrect.min), dr.min);
+ else{
+ r = raddp(rscale(rsubp(l->entire, olDrect.min),
+ sub(olDrect.max, olDrect.min),
+ sub(dr.max, dr.min)), dr.min);
+ if(l->visible==Some && f->b){
+ bfree(f->b);
+ frclear(f);
+ }
+ f->b = 0;
+ if(l->visible!=None)
+ frclear(f);
+ }
+ if(!rectclip(&r, dr))
+ panic("flreshape");
+ if(r.max.x-r.min.x<100)
+ r.min.x = dr.min.x;
+ if(r.max.x-r.min.x<100)
+ r.max.x = dr.max.x;
+ if(r.max.y-r.min.y<2*FLMARGIN+f->fheight)
+ r.min.y = dr.min.y;
+ if(r.max.y-r.min.y<2*FLMARGIN+f->fheight)
+ r.max.y = dr.max.y;
+ if(!move)
+ l->visible = None;
+ frsetrects(f, inset(flrect(l, r), FLMARGIN), f->b);
+ if(!move && f->b)
+ scrdraw(l, scrtotal(l));
+ }
+ newvisibilities(1);
}
int
flprepare(Flayer *l)
{
- Frame *f;
- ulong n;
- Rune *r;
-
- if(l->visible == None)
- return 0;
- f = &l->f;
- if(f->b == 0){
- if(l->visible == All)
- f->b = &screen;
- else if((f->b = balloc(l->entire, screen.ldepth))==0)
- return 0;
- bitblt2(f->b, l->entire.min, f->b, l->entire, 0, 0, l->bg);
- border(f->b, l->entire, l==llist[0]? FLMARGIN : 1, F&~D, l->bg…
- n = f->nchars;
- frinit(f, f->entire, f->font, f->b, l->bg);
- r = (*l->textfn)(l, n, &n);
- frinsert(f, r, r+n, (ulong)0);
- frselectp(f, F&~D);
- flfp0p1(l, &l->f.p0, &l->f.p1);
- frselectp(f, F&~D);
- scrdraw(l, scrtotal(l));
- }
- return 1;
+ Frame *f;
+ ulong n;
+ Rune *r;
+
+ if(l->visible == None)
+ return 0;
+ f = &l->f;
+ if(f->b == 0){
+ if(l->visible == All)
+ f->b = &screen;
+ else if((f->b = balloc(l->entire, screen.ldepth))==0)
+ return 0;
+ bitblt2(f->b, l->entire.min, f->b, l->entire, 0, 0, l->bg);
+ border(f->b, l->entire, l==llist[0]? FLMARGIN : 1, F&~D, l->bg);
+ n = f->nchars;
+ frinit(f, f->entire, f->font, f->b, l->bg);
+ r = (*l->textfn)(l, n, &n);
+ frinsert(f, r, r+n, (ulong)0);
+ frselectp(f, F&~D);
+ flfp0p1(l, &l->f.p0, &l->f.p1);
+ frselectp(f, F&~D);
+ scrdraw(l, scrtotal(l));
+ }
+ return 1;
}
-static int somevis, someinvis, justvis;
+static int somevis, someinvis, justvis;
Vis
visibility(Flayer *l)
{
- somevis = someinvis = 0;
- justvis = 1;
- flrefresh(l, l->entire, 0);
- justvis = 0;
- if(somevis==0)
- return None;
- if(someinvis==0)
- return All;
- return Some;
+ somevis = someinvis = 0;
+ justvis = 1;
+ flrefresh(l, l->entire, 0);
+ justvis = 0;
+ if(somevis==0)
+ return None;
+ if(someinvis==0)
+ return All;
+ return Some;
}
void
flrefresh(Flayer *l, Rectangle r, int i)
{
- Flayer *t;
- Rectangle s;
+ Flayer *t;
+ Rectangle s;
Top:
- if((t=llist[i++]) == l){
- if(!justvis)
- bitblt2(&screen, r.min, l->f.b, r, S, 0, l->bg);
- somevis = 1;
- }else{
- if(!rectXrect(t->entire, r))
- goto Top; /* avoid stacking unnecessarily */
- if(t->entire.min.x>r.min.x){
- s = r;
- s.max.x = t->entire.min.x;
- flrefresh(l, s, i);
- r.min.x = t->entire.min.x;
- }
- if(t->entire.min.y>r.min.y){
- s = r;
- s.max.y = t->entire.min.y;
- flrefresh(l, s, i);
- r.min.y = t->entire.min.y;
- }
- if(t->entire.max.x<r.max.x){
- s = r;
- s.min.x = t->entire.max.x;
- flrefresh(l, s, i);
- r.max.x = t->entire.max.x;
- }
- if(t->entire.max.y<r.max.y){
- s = r;
- s.min.y = t->entire.max.y;
- flrefresh(l, s, i);
- r.max.y = t->entire.max.y;
- }
- /* remaining piece of r is blocked by t; forget about it */
- someinvis = 1;
- }
+ if((t=llist[i++]) == l){
+ if(!justvis)
+ bitblt2(&screen, r.min, l->f.b, r, S, 0, l->bg);
+ somevis = 1;
+ }else{
+ if(!rectXrect(t->entire, r))
+ goto Top; /* avoid stacking unnecessarily */
+ if(t->entire.min.x>r.min.x){
+ s = r;
+ s.max.x = t->entire.min.x;
+ flrefresh(l, s, i);
+ r.min.x = t->entire.min.x;
+ }
+ if(t->entire.min.y>r.min.y){
+ s = r;
+ s.max.y = t->entire.min.y;
+ flrefresh(l, s, i);
+ r.min.y = t->entire.min.y;
+ }
+ if(t->entire.max.x<r.max.x){
+ s = r;
+ s.min.x = t->entire.max.x;
+ flrefresh(l, s, i);
+ r.max.x = t->entire.max.x;
+ }
+ if(t->entire.max.y<r.max.y){
+ s = r;
+ s.min.y = t->entire.max.y;
+ flrefresh(l, s, i);
+ r.max.y = t->entire.max.y;
+ }
+ /* remaining piece of r is blocked by t; forget about it */
+ someinvis = 1;
+ }
}
diff --git a/samterm/flayer.h b/samterm/flayer.h
@@ -1,13 +1,13 @@
/* Copyright (c) 1998 Lucent Technologies - All rights reserved. */
#undef None
typedef enum Vis{
- None=0,
- Some,
- All
+ None=0,
+ Some,
+ All
}Vis;
enum{
- Clicktime=1000 /* one second */
+ Clicktime=1000 /* one second */
};
typedef struct Flayer Flayer;
@@ -18,35 +18,35 @@ typedef struct Flayer Flayer;
struct Flayer
{
unsigned long bg;
- Frame f;
- long origin; /* offset of first char in flayer */
- long p0, p1;
- long click; /* time at which selection click occ…
- Rune *(*textfn)(Flayer*, long, ulong*);
- int user0;
- void *user1;
- Rectangle entire;
- Rectangle scroll;
- Vis visible;
+ Frame f;
+ long origin; /* offset of first char in flayer */
+ long p0, p1;
+ long click; /* time at which selection click occurred, in HZ */
+ Rune *(*textfn)(Flayer*, long, ulong*);
+ int user0;
+ void *user1;
+ Rectangle entire;
+ Rectangle scroll;
+ Vis visible;
};
-void flborder(Flayer*, int);
-void flclose(Flayer*);
-void fldelete(Flayer*, long, long);
-void flfp0p1(Flayer*, ulong*, ulong*);
-void flinit(Flayer*, Rectangle, XftFont*, unsigned long bg);
-void flinsert(Flayer*, Rune*, Rune*, long);
-void flnew(Flayer*, Rune *(*fn)(Flayer*, long, ulong*), int, void*);
-int flprepare(Flayer*);
+void flborder(Flayer*, int);
+void flclose(Flayer*);
+void fldelete(Flayer*, long, long);
+void flfp0p1(Flayer*, ulong*, ulong*);
+void flinit(Flayer*, Rectangle, XftFont*, unsigned long bg);
+void flinsert(Flayer*, Rune*, Rune*, long);
+void flnew(Flayer*, Rune *(*fn)(Flayer*, long, ulong*), int, void*);
+int flprepare(Flayer*);
Rectangle flrect(Flayer*, Rectangle);
-void flrefresh(Flayer*, Rectangle, int);
-void flreshape(Rectangle);
-int flselect(Flayer*);
-void flsetselect(Flayer*, long, long);
-void flstart(Rectangle);
-void flupfront(Flayer*);
-Flayer *flwhich(Point);
+void flrefresh(Flayer*, Rectangle, int);
+void flreshape(Rectangle);
+int flselect(Flayer*);
+void flsetselect(Flayer*, long, long);
+void flstart(Rectangle);
+void flupfront(Flayer*);
+Flayer *flwhich(Point);
-#define FLMARGIN 4
-#define FLSCROLLWID 12
-#define FLGAP 4
+#define FLMARGIN 4
+#define FLSCROLLWID 12
+#define FLGAP 4
diff --git a/samterm/icons.c b/samterm/icons.c
@@ -4,17 +4,17 @@
#include <libg.h>
uchar darkgreybits[] = {
- 0xDD, 0xDD, 0x77, 0x77, 0xDD, 0xDD, 0x77, 0x77,
- 0xDD, 0xDD, 0x77, 0x77, 0xDD, 0xDD, 0x77, 0x77,
- 0xDD, 0xDD, 0x77, 0x77, 0xDD, 0xDD, 0x77, 0x77,
- 0xDD, 0xDD, 0x77, 0x77, 0xDD, 0xDD, 0x77, 0x77,
+ 0xDD, 0xDD, 0x77, 0x77, 0xDD, 0xDD, 0x77, 0x77,
+ 0xDD, 0xDD, 0x77, 0x77, 0xDD, 0xDD, 0x77, 0x77,
+ 0xDD, 0xDD, 0x77, 0x77, 0xDD, 0xDD, 0x77, 0x77,
+ 0xDD, 0xDD, 0x77, 0x77, 0xDD, 0xDD, 0x77, 0x77,
};
-Bitmap *darkgrey;
+Bitmap *darkgrey;
void
iconinit(void)
{
- darkgrey = balloc(Rect(0, 0, 16, 16), 0);
- wrbitmap(darkgrey, 0, 16, darkgreybits);
+ darkgrey = balloc(Rect(0, 0, 16, 16), 0);
+ wrbitmap(darkgrey, 0, 16, darkgreybits);
}
diff --git a/samterm/io.c b/samterm/io.c
@@ -6,143 +6,143 @@
#include "flayer.h"
#include "samterm.h"
-int cursorfd;
-int input;
-int got;
-int block;
-Keystroke keystroke;
-int reshaped;
-uchar *hostp;
-uchar *hoststop;
-uchar *externbase;
-uchar *externp;
-uchar *externstop;
-void panic(char*);
+int cursorfd;
+int input;
+int got;
+int block;
+Keystroke keystroke;
+int reshaped;
+uchar *hostp;
+uchar *hoststop;
+uchar *externbase;
+uchar *externp;
+uchar *externstop;
+void panic(char*);
void
initio(void){
- einit(Emouse|Ekeyboard);
- estart(Ehost, 0, 0);
- extstart();
+ einit(Emouse|Ekeyboard);
+ estart(Ehost, 0, 0);
+ extstart();
}
void
frgetmouse(void)
{
- mouse = emouse();
+ mouse = emouse();
}
void
mouseunblock(void)
{
- got &= ~Emouse;
+ got &= ~Emouse;
}
void
kbdblock(void)
-{ /* ca suffit */
- block = Ekeyboard|Eextern;
+{ /* ca suffit */
+ block = Ekeyboard|Eextern;
}
int
button(int but)
{
- frgetmouse();
- return mouse.buttons&(1<<(but-1));
+ frgetmouse();
+ return mouse.buttons&(1<<(but-1));
}
void
externload(Event *e)
{
- externbase = malloc(e->n);
- if(externbase == 0)
- return;
- memmove(externbase, e->data, e->n);
- externp = externbase;
- externstop = externbase + e->n;
- got |= Eextern;
+ externbase = malloc(e->n);
+ if(externbase == 0)
+ return;
+ memmove(externbase, e->data, e->n);
+ externp = externbase;
+ externstop = externbase + e->n;
+ got |= Eextern;
}
int
waitforio(void)
{
- ulong type;
- static Event e;
-
- if(got & ~block)
- return got & ~block;
- type = eread(~(got|block), &e);
- switch(type){
- case Ehost:
- hostp = e.data;
- hoststop = hostp + e.n;
- block = 0;
- break;
- case Eextern:
- externload(&e);
- break;
- case Ekeyboard:
- keystroke = e.keystroke;
- break;
- case Emouse:
- mouse = e.mouse;
- break;
- }
- got |= type;
- return got;
+ ulong type;
+ static Event e;
+
+ if(got & ~block)
+ return got & ~block;
+ type = eread(~(got|block), &e);
+ switch(type){
+ case Ehost:
+ hostp = e.data;
+ hoststop = hostp + e.n;
+ block = 0;
+ break;
+ case Eextern:
+ externload(&e);
+ break;
+ case Ekeyboard:
+ keystroke = e.keystroke;
+ break;
+ case Emouse:
+ mouse = e.mouse;
+ break;
+ }
+ got |= type;
+ return got;
}
int
rcvchar(void)
{
- int c;
+ int c;
- if(!(got & Ehost))
- return -1;
- c = *hostp++;
- if(hostp == hoststop)
- got &= ~Ehost;
- return c;
+ if(!(got & Ehost))
+ return -1;
+ c = *hostp++;
+ if(hostp == hoststop)
+ got &= ~Ehost;
+ return c;
}
char*
rcvstring(void)
{
- *hoststop = 0;
- got &= ~Ehost;
- return (char*)hostp;
+ *hoststop = 0;
+ got &= ~Ehost;
+ return (char*)hostp;
}
int
getch(void)
{
- int c;
+ int c;
- while((c = rcvchar()) == -1){
- block = ~Ehost;
- waitforio();
- block = 0;
- }
- return c;
+ while((c = rcvchar()) == -1){
+ block = ~Ehost;
+ waitforio();
+ block = 0;
+ }
+ return c;
}
int
externchar(void)
{
- Rune r;
+ Rune r;
loop:
- if(got & (Eextern & ~block)){
- externp += chartorune(&r, (char*)externp);
- if(externp >= externstop){
- got &= ~Eextern;
- free(externbase);
- }
- if(r == 0)
- goto loop;
- return r;
- }
- return -1;
+ if(got & (Eextern & ~block)){
+ externp += chartorune(&r, (char*)externp);
+ if(externp >= externstop){
+ got &= ~Eextern;
+ free(externbase);
+ }
+ if(r == 0)
+ goto loop;
+ return r;
+ }
+ return -1;
}
Keystroke
@@ -155,52 +155,52 @@ Keystroke
kbdchar(void)
{
Keystroke k = {0};
- static Event e;
+ static Event e;
- k.c = externchar();
- if(k.c > 0)
- return k;
- if(got & Ekeyboard){
- k = keystroke;
+ k.c = externchar();
+ if(k.c > 0)
+ return k;
+ if(got & Ekeyboard){
+ k = keystroke;
memset(&keystroke, 0, sizeof(keystroke));
- got &= ~Ekeyboard;
- return k;
- }
- while(ecanread(Eextern)){
- eread(Eextern, &e);
- externload(&e);
- k.c = externchar();
- if(k.c > 0)
- return k;
- }
- if(!ecankbd()){
+ got &= ~Ekeyboard;
+ return k;
+ }
+ while(ecanread(Eextern)){
+ eread(Eextern, &e);
+ externload(&e);
+ k.c = externchar();
+ if(k.c > 0)
+ return k;
+ }
+ if(!ecankbd()){
k.c = -1;
- return k;
+ return k;
}
- return ekbd();
+ return ekbd();
}
void
ereshaped(Rectangle r)
{
- USED(r);
+ USED(r);
- reshaped = 1;
+ reshaped = 1;
}
int
RESHAPED(void)
{
- if(reshaped){
- screen.r = bscreenrect(&screen.clipr);
- reshaped = 0;
- return 1;
- }
- return 0;
+ if(reshaped){
+ screen.r = bscreenrect(&screen.clipr);
+ reshaped = 0;
+ return 1;
+ }
+ return 0;
}
void
mouseexit(void)
{
- exits(0);
+ exits(0);
}
diff --git a/samterm/main.c b/samterm/main.c
@@ -13,22 +13,22 @@
extern unsigned long _bgpixel;
extern void hmoveto(int, long, Flayer *);
-Text cmd;
-Rune *scratch;
-long nscralloc;
-extern Bitmap screen;
+Text cmd;
+Rune *scratch;
+long nscralloc;
+extern Bitmap screen;
unsigned int cursor;
-Mouse mouse;
-Flayer *which = 0;
+Mouse mouse;
+Flayer *which = 0;
Flayer *flast = 0;
-Flayer *work = 0;
-long snarflen;
-long typestart = -1;
-long typeend = -1;
-long typeesc = -1;
-long modified = 0; /* strange lookahead for menus */
-char lock = 1;
-char hasunlocked = 0;
+Flayer *work = 0;
+long snarflen;
+long typestart = -1;
+long typeend = -1;
+long typeesc = -1;
+long modified = 0; /* strange lookahead for menus */
+char lock = 1;
+char hasunlocked = 0;
int expandtabs = 0;
char *machine = "localhost";
int nofifo = 0;
@@ -42,11 +42,11 @@ int oldcompat = 0;
int
main(int argc, char *argv[])
{
- int i, got, scr, opt;
- Text *t;
- Rectangle r;
- Flayer *nwhich;
- int fwdbut;
+ int i, got, scr, opt;
+ Text *t;
+ Rectangle r;
+ Flayer *nwhich;
+ int fwdbut;
while ((opt = getopt(argc, argv, "efr:")) != -1){
switch (opt){
@@ -64,81 +64,81 @@ main(int argc, char *argv[])
}
}
- getscreen(argc, argv);
- fwdbut = scrollfwdbut();
- iconinit();
- initio();
- scratch = alloc(100*RUNESIZE);
- nscralloc = 100;
- r = screen.r;
- r.max.y = r.min.y+Dy(r)/5;
- flstart(screen.clipr);
- rinit(&cmd.rasp);
- flnew(&cmd.l[0], stgettext, 1, &cmd);
+ getscreen(argc, argv);
+ fwdbut = scrollfwdbut();
+ iconinit();
+ initio();
+ scratch = alloc(100*RUNESIZE);
+ nscralloc = 100;
+ r = screen.r;
+ r.max.y = r.min.y+Dy(r)/5;
+ flstart(screen.clipr);
+ rinit(&cmd.rasp);
+ flnew(&cmd.l[0], stgettext, 1, &cmd);
cmd.l[0].bg = getbg();
- flinit(&cmd.l[0], r, font, cmd.l[0].bg);
- cmd.nwin = 1;
- which = &cmd.l[0];
- cmd.tag = Untagged;
- outTs(Tversion, VERSION);
- startnewfile(Tstartcmdfile, &cmd);
-
- got = 0;
- for(;;got = waitforio()){
- if(hasunlocked && RESHAPED())
- reshape();
- if(got&RHost)
- rcv();
- if(got&RExtern){
- for(i=0; cmd.l[i].textfn==0; i++)
- ;
- current(&cmd.l[i]);
- flsetselect(which, cmd.rasp.nrunes, cmd.rasp.nrunes);
- type(which, RExtern);
- }
- if(got&RKeyboard)
- if(which)
- type(which, RKeyboard);
- else
- kbdblock();
- if(got&RMouse){
- if(lock==2 || !ptinrect(mouse.xy, screen.r)){
- mouseunblock();
- continue;
- }
- nwhich = flwhich(mouse.xy);
- scr = which && ptinrect(mouse.xy, which->scroll);
- if(mouse.buttons)
- flushtyping(1);
+ flinit(&cmd.l[0], r, font, cmd.l[0].bg);
+ cmd.nwin = 1;
+ which = &cmd.l[0];
+ cmd.tag = Untagged;
+ outTs(Tversion, VERSION);
+ startnewfile(Tstartcmdfile, &cmd);
+
+ got = 0;
+ for(;;got = waitforio()){
+ if(hasunlocked && RESHAPED())
+ reshape();
+ if(got&RHost)
+ rcv();
+ if(got&RExtern){
+ for(i=0; cmd.l[i].textfn==0; i++)
+ ;
+ current(&cmd.l[i]);
+ flsetselect(which, cmd.rasp.nrunes, cmd.rasp.nrunes);
+ type(which, RExtern);
+ }
+ if(got&RKeyboard)
+ if(which)
+ type(which, RKeyboard);
+ else
+ kbdblock();
+ if(got&RMouse){
+ if(lock==2 || !ptinrect(mouse.xy, screen.r)){
+ mouseunblock();
+ continue;
+ }
+ nwhich = flwhich(mouse.xy);
+ scr = which && ptinrect(mouse.xy, which->scroll);
+ if(mouse.buttons)
+ flushtyping(1);
if(mouse.buttons&1){
- if(nwhich){
- if(nwhich!=which)
- current(nwhich);
- else if(scr)
- scroll(which, 1, fwdbut == 3 ?…
- else{
- t=(Text *)which->user1;
- if(flselect(which)){
- outTsl(Tdclick, t->tag…
- t->lock++;
- }else if(t!=&cmd)
- outcmd();
- }
- }
- }else if((mouse.buttons&2) && which){
- if(scr)
- scroll(which, 2, 2);
- else
- menu2hit();
- }else if((mouse.buttons&4)){
- if(scr)
- scroll(which, 3, fwdbut == 3 ? 3 : 1);
- else
- menu3hit();
- }
- mouseunblock();
- }
- }
+ if(nwhich){
+ if(nwhich!=which)
+ current(nwhich);
+ else if(scr)
+ scroll(which, 1, fwdbut == 3 ? 1 : 3);
+ else{
+ t=(Text *)which->user1;
+ if(flselect(which)){
+ outTsl(Tdclick, t->tag, which->p0);
+ t->lock++;
+ }else if(t!=&cmd)
+ outcmd();
+ }
+ }
+ }else if((mouse.buttons&2) && which){
+ if(scr)
+ scroll(which, 2, 2);
+ else
+ menu2hit();
+ }else if((mouse.buttons&4)){
+ if(scr)
+ scroll(which, 3, fwdbut == 3 ? 3 : 1);
+ else
+ menu3hit();
+ }
+ mouseunblock();
+ }
+ }
return EXIT_SUCCESS;
}
@@ -146,253 +146,253 @@ main(int argc, char *argv[])
void
reshape(void){
- int i;
+ int i;
- flreshape(screen.clipr);
- for(i = 0; i<nname; i++)
- if(text[i])
- hcheck(text[i]->tag);
+ flreshape(screen.clipr);
+ for(i = 0; i<nname; i++)
+ if(text[i])
+ hcheck(text[i]->tag);
}
void
current(Flayer *nw)
{
- Text *t;
+ Text *t;
- if(which)
- flborder(which, 0);
- if(nw){
- flushtyping(1);
- flupfront(nw);
- flborder(nw, 1);
- buttons(Up);
- t = (Text *)nw->user1;
- t->front = nw-&t->l[0];
- if(t != &cmd)
- work = nw;
- }
- which = nw;
+ if(which)
+ flborder(which, 0);
+ if(nw){
+ flushtyping(1);
+ flupfront(nw);
+ flborder(nw, 1);
+ buttons(Up);
+ t = (Text *)nw->user1;
+ t->front = nw-&t->l[0];
+ if(t != &cmd)
+ work = nw;
+ }
+ which = nw;
}
void
closeup(Flayer *l)
{
- Text *t=(Text *)l->user1;
- int m;
-
- m = whichmenu(t->tag);
- if(m < 0)
- return;
- flclose(l);
- if(l == which){
- which = 0;
- current(flwhich(Pt(0, 0)));
- }
- if(l == flast)
- flast = 0;
- if(l == work)
- work = 0;
- if(--t->nwin == 0){
- rclear(&t->rasp);
- free((uchar *)t);
- text[m] = 0;
- }else if(l == &t->l[t->front]){
- for(m=0; m<NL; m++) /* find one; any one will do */
- if(t->l[m].textfn){
- t->front = m;
- return;
- }
- panic("close");
- }
+ Text *t=(Text *)l->user1;
+ int m;
+
+ m = whichmenu(t->tag);
+ if(m < 0)
+ return;
+ flclose(l);
+ if(l == which){
+ which = 0;
+ current(flwhich(Pt(0, 0)));
+ }
+ if(l == flast)
+ flast = 0;
+ if(l == work)
+ work = 0;
+ if(--t->nwin == 0){
+ rclear(&t->rasp);
+ free((uchar *)t);
+ text[m] = 0;
+ }else if(l == &t->l[t->front]){
+ for(m=0; m<NL; m++) /* find one; any one will do */
+ if(t->l[m].textfn){
+ t->front = m;
+ return;
+ }
+ panic("close");
+ }
}
Flayer *
findl(Text *t)
{
- int i;
- for(i = 0; i<NL; i++)
- if(t->l[i].textfn==0)
- return &t->l[i];
- return 0;
+ int i;
+ for(i = 0; i<NL; i++)
+ if(t->l[i].textfn==0)
+ return &t->l[i];
+ return 0;
}
void
duplicate(Flayer *l, Rectangle r, XftFont *f, int close)
{
- Text *t=(Text *)l->user1;
- Flayer *nl = findl(t);
- Rune *rp;
- ulong n;
-
- if(nl){
- flnew(nl, stgettext, l->user0, (char *)t);
- flinit(nl, r, f, l->bg);
- nl->origin = l->origin;
- rp = (*l->textfn)(l, l->f.nchars, &n);
- flinsert(nl, rp, rp+n, l->origin);
- flsetselect(nl, l->p0, l->p1);
- if(close){
- flclose(l);
- if(l==which)
- which = 0;
- }else
- t->nwin++;
- current(nl);
- hcheck(t->tag);
- }
- cursorswitch(cursor);
+ Text *t=(Text *)l->user1;
+ Flayer *nl = findl(t);
+ Rune *rp;
+ ulong n;
+
+ if(nl){
+ flnew(nl, stgettext, l->user0, (char *)t);
+ flinit(nl, r, f, l->bg);
+ nl->origin = l->origin;
+ rp = (*l->textfn)(l, l->f.nchars, &n);
+ flinsert(nl, rp, rp+n, l->origin);
+ flsetselect(nl, l->p0, l->p1);
+ if(close){
+ flclose(l);
+ if(l==which)
+ which = 0;
+ }else
+ t->nwin++;
+ current(nl);
+ hcheck(t->tag);
+ }
+ cursorswitch(cursor);
}
void
buttons(int updown)
{
- while(((mouse.buttons&7)!=0) != updown)
- frgetmouse();
+ while(((mouse.buttons&7)!=0) != updown)
+ frgetmouse();
}
int
getr(Rectangle *rp)
{
- Point p;
- Rectangle r;
-
- *rp = getrect(3, &mouse);
- if(rp->max.x && rp->max.x-rp->min.x<=5 && rp->max.y-rp->min.y<=5){
- p = rp->min;
- r = cmd.l[cmd.front].entire;
- *rp = screen.r;
- if(cmd.nwin==1){
- if (p.y <= r.min.y)
- rp->max.y = r.min.y;
- else if (p.y >= r.max.y)
- rp->min.y = r.max.y;
- if (p.x <= r.min.x)
- rp->max.x = r.min.x;
- else if (p.x >= r.max.x)
- rp->min.x = r.max.x;
- }
- }
- return rectclip(rp, screen.r) &&
- rp->max.x-rp->min.x>100 && rp->max.y-rp->min.y>40;
+ Point p;
+ Rectangle r;
+
+ *rp = getrect(3, &mouse);
+ if(rp->max.x && rp->max.x-rp->min.x<=5 && rp->max.y-rp->min.y<=5){
+ p = rp->min;
+ r = cmd.l[cmd.front].entire;
+ *rp = screen.r;
+ if(cmd.nwin==1){
+ if (p.y <= r.min.y)
+ rp->max.y = r.min.y;
+ else if (p.y >= r.max.y)
+ rp->min.y = r.max.y;
+ if (p.x <= r.min.x)
+ rp->max.x = r.min.x;
+ else if (p.x >= r.max.x)
+ rp->min.x = r.max.x;
+ }
+ }
+ return rectclip(rp, screen.r) &&
+ rp->max.x-rp->min.x>100 && rp->max.y-rp->min.y>40;
}
void
snarf(Text *t, int w)
{
- Flayer *l = &t->l[w];
+ Flayer *l = &t->l[w];
- if(l->p1>l->p0){
- snarflen = l->p1-l->p0;
- outTsll(Tsnarf, t->tag, l->p0, l->p1);
- }
+ if(l->p1>l->p0){
+ snarflen = l->p1-l->p0;
+ outTsll(Tsnarf, t->tag, l->p0, l->p1);
+ }
}
void
cut(Text *t, int w, int save, int check)
{
- long p0, p1;
- Flayer *l;
-
- l = &t->l[w];
- p0 = l->p0;
- p1 = l->p1;
- if(p0 == p1)
- return;
- if(p0 < 0)
- panic("cut");
- if(save)
- snarf(t, w);
- outTsll(Tcut, t->tag, p0, p1);
- flsetselect(l, p0, p0);
- t->lock++;
- hcut(t->tag, p0, p1-p0);
- if(check)
- hcheck(t->tag);
+ long p0, p1;
+ Flayer *l;
+
+ l = &t->l[w];
+ p0 = l->p0;
+ p1 = l->p1;
+ if(p0 == p1)
+ return;
+ if(p0 < 0)
+ panic("cut");
+ if(save)
+ snarf(t, w);
+ outTsll(Tcut, t->tag, p0, p1);
+ flsetselect(l, p0, p0);
+ t->lock++;
+ hcut(t->tag, p0, p1-p0);
+ if(check)
+ hcheck(t->tag);
}
void
paste(Text *t, int w)
{
- if(snarflen){
- cut(t, w, 0, 0);
- t->lock++;
- outTsl(Tpaste, t->tag, t->l[w].p0);
- }
+ if(snarflen){
+ cut(t, w, 0, 0);
+ t->lock++;
+ outTsl(Tpaste, t->tag, t->l[w].p0);
+ }
}
void
scrorigin(Flayer *l, int but, long p0)
{
- Text *t=(Text *)l->user1;
+ Text *t=(Text *)l->user1;
- switch(but){
- case 1:
+ switch(but){
+ case 1:
if (oldcompat)
- outTsll(Torigin, t->tag, l->origin, p0);
+ outTsll(Torigin, t->tag, l->origin, p0);
else
- outTslll(Torigin, t->tag, l->origin, p0, getlayer(l, t));
- break;
- case 2:
+ outTslll(Torigin, t->tag, l->origin, p0, getlayer(l, t));
+ break;
+ case 2:
if (oldcompat)
- outTsll(Torigin, t->tag, p0, 1L);
+ outTsll(Torigin, t->tag, p0, 1L);
else
- outTslll(Torigin, t->tag, p0, 1L, getlayer(l, t));
- break;
- case 3:
- horigin(t->tag, p0, NULL);
- }
+ outTslll(Torigin, t->tag, p0, 1L, getlayer(l, t));
+ break;
+ case 3:
+ horigin(t->tag, p0, NULL);
+ }
}
int
alnum(int c)
{
- /*
- * Hard to get absolutely right. Use what we know about ASCII
- * and assume anything above the Latin control characters is
- * potentially an alphanumeric.
- */
- if(c<=' ')
- return 0;
- if(0x7F<=c && c<=0xA0)
- return 0;
- if(utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c))
- return 0;
- return 1;
+ /*
+ * Hard to get absolutely right. Use what we know about ASCII
+ * and assume anything above the Latin control characters is
+ * potentially an alphanumeric.
+ */
+ if(c<=' ')
+ return 0;
+ if(0x7F<=c && c<=0xA0)
+ return 0;
+ if(utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c))
+ return 0;
+ return 1;
}
int
raspc(Rasp *r, long p)
{
- ulong n;
- rload(r, p, p+1, &n);
- if(n)
- return scratch[0];
- return 0;
+ ulong n;
+ rload(r, p, p+1, &n);
+ if(n)
+ return scratch[0];
+ return 0;
}
long
ctlw(Rasp *r, long o, long p)
{
- int c;
+ int c;
- if(--p < o)
- return o;
- if(raspc(r, p)=='\n')
- return p;
- for(; p>=o && !alnum(c=raspc(r, p)); --p)
- if(c=='\n')
- return p+1;
- for(; p>o && alnum(raspc(r, p-1)); --p)
- ;
- return p>=o? p : o;
+ if(--p < o)
+ return o;
+ if(raspc(r, p)=='\n')
+ return p;
+ for(; p>=o && !alnum(c=raspc(r, p)); --p)
+ if(c=='\n')
+ return p+1;
+ for(; p>o && alnum(raspc(r, p-1)); --p)
+ ;
+ return p>=o? p : o;
}
long
ctlu(Rasp *r, long o, long p)
{
- for(; p-1>=o && raspc(r, p-1)!='\n'; --p)
- ;
- return p>=o? p : o;
+ for(; p-1>=o && raspc(r, p-1)!='\n'; --p)
+ ;
+ return p>=o? p : o;
}
int
@@ -415,25 +415,25 @@ center(Flayer *l, long a)
int
onethird(Flayer *l, long a)
{
- Text *t;
- Rectangle s;
- long lines;
-
- t = l->user1;
- if(!t->lock && (a<l->origin || l->origin+l->f.nchars<a)){
- if(a > t->rasp.nrunes)
- a = t->rasp.nrunes;
- s = inset(l->scroll, 1);
- lines = ((s.max.y-s.min.y)/l->f.fheight+1)/3;
- if (lines < 2)
- lines = 2;
+ Text *t;
+ Rectangle s;
+ long lines;
+
+ t = l->user1;
+ if(!t->lock && (a<l->origin || l->origin+l->f.nchars<a)){
+ if(a > t->rasp.nrunes)
+ a = t->rasp.nrunes;
+ s = inset(l->scroll, 1);
+ lines = ((s.max.y-s.min.y)/l->f.fheight+1)/3;
+ if (lines < 2)
+ lines = 2;
if (oldcompat)
- outTsll(Torigin, t->tag, a, lines);
+ outTsll(Torigin, t->tag, a, lines);
else
- outTslll(Torigin, t->tag, a, lines, getlayer(l, t));
- return 1;
- }
- return 0;
+ outTslll(Torigin, t->tag, a, lines, getlayer(l, t));
+ return 1;
+ }
+ return 0;
}
@@ -445,28 +445,28 @@ extern Display * _dpy;
void
flushtyping(int clearesc)
{
- Text *t;
- ulong n;
-
- if(clearesc)
- typeesc = -1;
- if(typestart == typeend) {
- modified = 0;
- return;
- }
- t = which->user1;
- if(t != &cmd)
- modified = 1;
- rload(&t->rasp, typestart, typeend, &n);
- scratch[n] = 0;
- if(t==&cmd && typeend==t->rasp.nrunes && scratch[typeend-typestart-1]=…
- setlock();
- outcmd();
- }
- outTslS(Ttype, t->tag, typestart, scratch);
- typestart = -1;
- typeend = -1;
- XFlush(_dpy);
+ Text *t;
+ ulong n;
+
+ if(clearesc)
+ typeesc = -1;
+ if(typestart == typeend) {
+ modified = 0;
+ return;
+ }
+ t = which->user1;
+ if(t != &cmd)
+ modified = 1;
+ rload(&t->rasp, typestart, typeend, &n);
+ scratch[n] = 0;
+ if(t==&cmd && typeend==t->rasp.nrunes && scratch[typeend-typestart-1]=='\n…
+ setlock();
+ outcmd();
+ }
+ outTslS(Ttype, t->tag, typestart, scratch);
+ typestart = -1;
+ typeend = -1;
+ XFlush(_dpy);
}
static long
@@ -678,7 +678,7 @@ cmddelword(Flayer *l, long a, Text *t)
l->p1 = a;
if (l->p1 != l->p0){
if(typestart<=l->p0 && l->p1<=typeend){
- t->lock++; /* to call hcut */
+ t->lock++; /* to call hcut */
hcut(t->tag, l->p0, l->p1-l->p0);
/* hcheck is local because we know rasp is contiguous */
hcheck(t->tag);
@@ -700,7 +700,7 @@ cmddelbol(Flayer *l, long a, Text *t)
l->p1 = a;
if (l->p1 != l->p0){
if(typestart<=l->p0 && l->p1<=typeend){
- t->lock++; /* to call hcut */
+ t->lock++; /* to call hcut */
hcut(t->tag, l->p0, l->p1-l->p0);
/* hcheck is local because we know rasp is contiguous */
hcheck(t->tag);
@@ -722,7 +722,7 @@ cmddel(Flayer *l, long a, Text *t)
l->p1 = a;
if (l->p1 != l->p0){
if(typestart<=l->p0 && l->p1<=typeend){
- t->lock++; /* to call hcut */
+ t->lock++; /* to call hcut */
hcut(t->tag, l->p0, l->p1-l->p0);
/* hcheck is local because we know rasp is contiguous */
hcheck(t->tag);
@@ -842,29 +842,29 @@ CommandEntry commands[Cmax] ={
};
void
-type(Flayer *l, int res) /* what a bloody mess this is -- but it's gett…
+type(Flayer *l, int res) /* what a bloody mess this is -- but it's getting …
{
- Text *t = (Text *)l->user1;
- Rune buf[100];
+ Text *t = (Text *)l->user1;
+ Rune buf[100];
Keystroke k = {0};
- Rune *p = buf;
- int backspacing, moving;
- long a;
+ Rune *p = buf;
+ int backspacing, moving;
+ long a;
- if(lock || t->lock){
- kbdblock();
- return;
- }
+ if(lock || t->lock){
+ kbdblock();
+ return;
+ }
k = qpeekc();
- a = l->p0;
+ a = l->p0;
if (a != l->p1 && k.k != Kcommand){
- flushtyping(1);
- cut(t, t->front, 1, 1);
- return; /* it may now be locked */
- }
+ flushtyping(1);
+ cut(t, t->front, 1, 1);
+ return; /* it may now be locked */
+ }
- while (((k = kbdchar()), k.c) > 0) {
+ while (((k = kbdchar()), k.c) > 0) {
if (k.k == Kcommand)
break;
@@ -880,10 +880,10 @@ type(Flayer *l, int res) /* what a bloody mess thi…
break;
}
- *p++ = k.c;
- if (k.c == '\n' || p >= buf + sizeof(buf) / sizeof(buf[0]))
- break;
- }
+ *p++ = k.c;
+ if (k.c == '\n' || p >= buf + sizeof(buf) / sizeof(buf[0]))
+ break;
+ }
if (k.k == Kcommand){
if (k.c < 0 || k.c >= Cmax || commands[k.c].f == NULL)
@@ -909,7 +909,7 @@ type(Flayer *l, int res) /* what a bloody mess this …
typeesc = a;
hgrow(t->tag, a, p-buf, 0);
- t->lock++; /* pretend we Trequest'ed for hdatarune*/
+ t->lock++; /* pretend we Trequest'ed for hdatarune*/
hdatarune(t->tag, a, buf, p-buf);
a += p-buf;
l->p0 = a;
@@ -938,42 +938,42 @@ type(Flayer *l, int res) /* what a bloody mess thi…
void
outcmd(void)
{
- if(work)
- outTsll(Tworkfile, ((Text *)work->user1)->tag, work->p0, work-…
+ if(work)
+ outTsll(Tworkfile, ((Text *)work->user1)->tag, work->p0, work->p1);
}
void
panic(char *s)
{
- fprintf(stderr, "samterm:panic: ");
- perror(s);
- abort();
+ fprintf(stderr, "samterm:panic: ");
+ perror(s);
+ abort();
}
Rune*
stgettext(Flayer *l, long n, ulong *np)
{
- Text *t;
+ Text *t;
- t = l->user1;
- rload(&t->rasp, l->origin, l->origin+n, np);
- return scratch;
+ t = l->user1;
+ rload(&t->rasp, l->origin, l->origin+n, np);
+ return scratch;
}
long
scrtotal(Flayer *l)
{
- return ((Text *)l->user1)->rasp.nrunes;
+ return ((Text *)l->user1)->rasp.nrunes;
}
void*
alloc(ulong n)
{
- void *p;
+ void *p;
- p = malloc(n);
- if(p == 0)
- panic("alloc");
- memset(p, 0, n);
- return p;
+ p = malloc(n);
+ if(p == 0)
+ panic("alloc");
+ memset(p, 0, n);
+ return p;
}
diff --git a/samterm/menu.c b/samterm/menu.c
@@ -6,377 +6,377 @@
#include "flayer.h"
#include "samterm.h"
-uchar *name[MAXFILES]; /* first byte is ' ' or '\'': modified st…
-Text *text[MAXFILES]; /* pointer to Text associated with file */
-ushort tag[MAXFILES]; /* text[i].tag, even if text[i] no…
-int nname;
-int mw;
+uchar *name[MAXFILES]; /* first byte is ' ' or '\'': modified state */
+Text *text[MAXFILES]; /* pointer to Text associated with file */
+ushort tag[MAXFILES]; /* text[i].tag, even if text[i] not defined */
+int nname;
+int mw;
-char *genmenu3(int);
-char *genmenu2(int);
-char *genmenu2c(int);
+char *genmenu3(int);
+char *genmenu2(int);
+char *genmenu2c(int);
extern unsigned long _bgpixel;
enum Menu2
{
- Cut,
- Paste,
- Snarf,
- Look,
- Exch,
- Search,
- NMENU2 = Search,
- Send = Search,
- NMENU2C
+ Cut,
+ Paste,
+ Snarf,
+ Look,
+ Exch,
+ Search,
+ NMENU2 = Search,
+ Send = Search,
+ NMENU2C
};
enum Menu3
{
- New,
- Zerox,
- Reshape,
- Close,
- Write,
- NMENU3
+ New,
+ Zerox,
+ Reshape,
+ Close,
+ Write,
+ NMENU3
};
-char *menu2str[] = {
- "cut",
- "paste",
- "snarf",
- "look",
- "<exch>",
- 0, /* storage for last pattern */
+char *menu2str[] = {
+ "cut",
+ "paste",
+ "snarf",
+ "look",
+ "<exch>",
+ 0, /* storage for last pattern */
};
-char *menu3str[] = {
- "new",
- "zerox",
- "reshape",
- "close",
- "write",
+char *menu3str[] = {
+ "new",
+ "zerox",
+ "reshape",
+ "close",
+ "write",
};
-Menu menu2 = {0, genmenu2};
-Menu menu2c ={0, genmenu2c};
-Menu menu3 = {0, genmenu3};
+Menu menu2 = {0, genmenu2};
+Menu menu2c ={0, genmenu2c};
+Menu menu3 = {0, genmenu3};
void
menu2hit(void)
{
- Text *t=(Text *)which->user1;
- int w = which-t->l;
- int m;
-
- m = menuhit(2, &mouse, t==&cmd? &menu2c : &menu2);
- if(lock || t->lock)
- return;
-
- switch(m){
- case Cut:
- cut(t, w, 1, 1);
- break;
-
- case Paste:
- paste(t, w);
- break;
-
- case Snarf:
- snarf(t, w);
- break;
-
- case Exch:
- snarf(t, w);
- outT0(Tstartsnarf);
- setlock();
- break;
-
- case Look:
- outTsll(Tlook, t->tag, which->p0, which->p1);
- setlock();
- break;
-
- case Search:
- outcmd();
- if(t==&cmd)
- outTsll(Tsend, 0 /*ignored*/, which->p0, which->p1);
- else
- outT0(Tsearch);
- setlock();
- break;
- }
+ Text *t=(Text *)which->user1;
+ int w = which-t->l;
+ int m;
+
+ m = menuhit(2, &mouse, t==&cmd? &menu2c : &menu2);
+ if(lock || t->lock)
+ return;
+
+ switch(m){
+ case Cut:
+ cut(t, w, 1, 1);
+ break;
+
+ case Paste:
+ paste(t, w);
+ break;
+
+ case Snarf:
+ snarf(t, w);
+ break;
+
+ case Exch:
+ snarf(t, w);
+ outT0(Tstartsnarf);
+ setlock();
+ break;
+
+ case Look:
+ outTsll(Tlook, t->tag, which->p0, which->p1);
+ setlock();
+ break;
+
+ case Search:
+ outcmd();
+ if(t==&cmd)
+ outTsll(Tsend, 0 /*ignored*/, which->p0, which->p1);
+ else
+ outT0(Tsearch);
+ setlock();
+ break;
+ }
}
void
menu3hit(void)
{
- Rectangle r;
- Flayer *l;
- int m, i;
- Text *t;
-
- mw = -1;
- switch(m = menuhit(3, &mouse, &menu3)){
- case -1:
- break;
-
- case New:
- if(!lock)
- sweeptext(1, 0);
- break;
-
- case Zerox:
- case Reshape:
- if(!lock){
- cursorswitch(BullseyeCursor);
- buttons(Down);
- if((mouse.buttons&4) && (l = flwhich(mouse.xy)) && get…
- duplicate(l, r, l->f.font, m==Reshape);
- else
- cursorswitch(cursor);
- buttons(Up);
- }
- break;
-
- case Close:
- if(!lock){
- cursorswitch(BullseyeCursor);
- buttons(Down);
- if((mouse.buttons&4) && (l = flwhich(mouse.xy)) && !lo…
- t=(Text *)l->user1;
- if (t->nwin>1)
- closeup(l);
- else if(t!=&cmd) {
- outTs(Tclose, t->tag);
- setlock();
- }
- }
- cursorswitch(cursor);
- buttons(Up);
- }
- break;
-
- case Write:
- if(!lock){
- cursorswitch(BullseyeCursor);
- buttons(Down);
- if((mouse.buttons&4) && (l = flwhich(mouse.xy))){
- outTs(Twrite, ((Text *)l->user1)->tag);
- setlock();
- }else
- cursorswitch(cursor);
- buttons(Up);
- }
- break;
-
- default:
- if(t = text[m-NMENU3]){
- i = t->front;
- if(t->nwin==0 || t->l[i].textfn==0)
- return; /* not ready yet; try again lat…
- if(t->nwin>1 && which==&t->l[i])
- do
- if(++i==NL)
- i = 0;
- while(i!=t->front && t->l[i].textfn==0);
- current(&t->l[i]);
- }else if(!lock)
- sweeptext(0, tag[m-NMENU3]);
- break;
- }
+ Rectangle r;
+ Flayer *l;
+ int m, i;
+ Text *t;
+
+ mw = -1;
+ switch(m = menuhit(3, &mouse, &menu3)){
+ case -1:
+ break;
+
+ case New:
+ if(!lock)
+ sweeptext(1, 0);
+ break;
+
+ case Zerox:
+ case Reshape:
+ if(!lock){
+ cursorswitch(BullseyeCursor);
+ buttons(Down);
+ if((mouse.buttons&4) && (l = flwhich(mouse.xy)) && getr(&r))
+ duplicate(l, r, l->f.font, m==Reshape);
+ else
+ cursorswitch(cursor);
+ buttons(Up);
+ }
+ break;
+
+ case Close:
+ if(!lock){
+ cursorswitch(BullseyeCursor);
+ buttons(Down);
+ if((mouse.buttons&4) && (l = flwhich(mouse.xy)) && !lock){
+ t=(Text *)l->user1;
+ if (t->nwin>1)
+ closeup(l);
+ else if(t!=&cmd) {
+ outTs(Tclose, t->tag);
+ setlock();
+ }
+ }
+ cursorswitch(cursor);
+ buttons(Up);
+ }
+ break;
+
+ case Write:
+ if(!lock){
+ cursorswitch(BullseyeCursor);
+ buttons(Down);
+ if((mouse.buttons&4) && (l = flwhich(mouse.xy))){
+ outTs(Twrite, ((Text *)l->user1)->tag);
+ setlock();
+ }else
+ cursorswitch(cursor);
+ buttons(Up);
+ }
+ break;
+
+ default:
+ if(t = text[m-NMENU3]){
+ i = t->front;
+ if(t->nwin==0 || t->l[i].textfn==0)
+ return; /* not ready yet; try again later */
+ if(t->nwin>1 && which==&t->l[i])
+ do
+ if(++i==NL)
+ i = 0;
+ while(i!=t->front && t->l[i].textfn==0);
+ current(&t->l[i]);
+ }else if(!lock)
+ sweeptext(0, tag[m-NMENU3]);
+ break;
+ }
}
Text *
sweeptext(int new, int tag)
{
- Rectangle r;
- Text *t;
-
- if(getr(&r) && (t = malloc(sizeof(Text)))){
- memset((void*)t, 0, sizeof(Text));
- current((Flayer *)0);
- flnew(&t->l[0], stgettext, 0, (char *)t);
- flinit(&t->l[0], r, font, getbg()); /*bnl*/
- t->nwin = 1;
- rinit(&t->rasp);
- if(new)
- startnewfile(Tstartnewfile, t);
- else{
- rinit(&t->rasp);
- t->tag = tag;
- startfile(t);
- }
- return t;
- }
- return 0;
+ Rectangle r;
+ Text *t;
+
+ if(getr(&r) && (t = malloc(sizeof(Text)))){
+ memset((void*)t, 0, sizeof(Text));
+ current((Flayer *)0);
+ flnew(&t->l[0], stgettext, 0, (char *)t);
+ flinit(&t->l[0], r, font, getbg()); /*bnl*/
+ t->nwin = 1;
+ rinit(&t->rasp);
+ if(new)
+ startnewfile(Tstartnewfile, t);
+ else{
+ rinit(&t->rasp);
+ t->tag = tag;
+ startfile(t);
+ }
+ return t;
+ }
+ return 0;
}
int
whichmenu(int tg)
{
- int i;
+ int i;
- for(i=0; i<nname; i++)
- if(tag[i] == tg)
- return i;
- return -1;
+ for(i=0; i<nname; i++)
+ if(tag[i] == tg)
+ return i;
+ return -1;
}
void
menuins(int n, uchar *s, Text *t, int m, int tg)
{
- int i;
-
- if(nname == MAXFILES)
- panic("menuins");
- for(i=nname; i>n; --i)
- name[i]=name[i-1], text[i]=text[i-1], tag[i]=tag[i-1];
- text[n] = t;
- tag[n] = tg;
- name[n] = alloc(strlen((char*)s)+2);
- name[n][0] = m;
- strcpy((char*)name[n]+1, (char*)s);
- nname++;
- menu3.lasthit = n+NMENU3;
+ int i;
+
+ if(nname == MAXFILES)
+ panic("menuins");
+ for(i=nname; i>n; --i)
+ name[i]=name[i-1], text[i]=text[i-1], tag[i]=tag[i-1];
+ text[n] = t;
+ tag[n] = tg;
+ name[n] = alloc(strlen((char*)s)+2);
+ name[n][0] = m;
+ strcpy((char*)name[n]+1, (char*)s);
+ nname++;
+ menu3.lasthit = n+NMENU3;
}
void
menudel(int n)
{
- int i;
-
- if(nname==0 || n>=nname || text[n])
- panic("menudel");
- free(name[n]);
- --nname;
- for(i = n; i<nname; i++)
- name[i]=name[i+1], text[i]=text[i+1], tag[i]=tag[i+1];
+ int i;
+
+ if(nname==0 || n>=nname || text[n])
+ panic("menudel");
+ free(name[n]);
+ --nname;
+ for(i = n; i<nname; i++)
+ name[i]=name[i+1], text[i]=text[i+1], tag[i]=tag[i+1];
}
void
setpat(char *s)
{
- static char pat[17];
+ static char pat[17];
- pat[0] = '/';
- strncpy(pat+1, s, 15);
- menu2str[Search] = pat;
+ pat[0] = '/';
+ strncpy(pat+1, s, 15);
+ menu2str[Search] = pat;
}
-#define NBUF 64
+#define NBUF 64
static uchar buf[NBUF*UTFmax]={' ', ' ', ' ', ' '};
char *
paren(char *s)
{
- uchar *t = buf;
+ uchar *t = buf;
- *t++ = '(';
- do; while(*t++ = *s++);
- t[-1] = ')';
- *t = 0;
- return (char *)buf;
+ *t++ = '(';
+ do; while(*t++ = *s++);
+ t[-1] = ')';
+ *t = 0;
+ return (char *)buf;
}
char*
genmenu2(int n)
{
- Text *t=(Text *)which->user1;
- char *p;
- if(n>=NMENU2+(menu2str[Search]!=0))
- return 0;
- p = menu2str[n];
- if(!lock && !t->lock || n==Search || n==Look)
- return p;
- return paren(p);
+ Text *t=(Text *)which->user1;
+ char *p;
+ if(n>=NMENU2+(menu2str[Search]!=0))
+ return 0;
+ p = menu2str[n];
+ if(!lock && !t->lock || n==Search || n==Look)
+ return p;
+ return paren(p);
}
char*
genmenu2c(int n)
{
- Text *t=(Text *)which->user1;
- char *p;
- if(n >= NMENU2C)
- return 0;
- if(n == Send)
- p="send";
- else
- p = menu2str[n];
- if(!lock && !t->lock)
- return p;
- return paren(p);
+ Text *t=(Text *)which->user1;
+ char *p;
+ if(n >= NMENU2C)
+ return 0;
+ if(n == Send)
+ p="send";
+ else
+ p = menu2str[n];
+ if(!lock && !t->lock)
+ return p;
+ return paren(p);
}
char *
genmenu3(int n)
{
- Text *t;
- int c, i, k, l, w;
- Rune r;
- char *p;
-
- if(n >= NMENU3+nname)
- return 0;
- if(n < NMENU3){
- p = menu3str[n];
- if(lock)
- p = paren(p);
- return p;
- }
- n -= NMENU3;
- if(n == 0) /* unless we've been fooled, this is cmd */
- return (char *)&name[n][1];
- if(mw == -1){
- mw = 7; /* strlen("~~sam~~"); */
- for(i=1; i<nname; i++){
- w = utflen((char*)name[i]+1)+4; /* include "'+.…
- if(w > mw)
- mw = w;
- }
- }
- if(mw > NBUF)
- mw = NBUF;
- t = text[n];
- buf[0] = name[n][0];
- buf[1] = '-';
- buf[2] = ' ';
- buf[3] = ' ';
- if(t){
- if(t->nwin == 1)
- buf[1] = '+';
- else if(t->nwin > 1)
- buf[1] = '*';
- if(work && t==(Text *)work->user1) {
- buf[2]= '.';
- if(modified)
- buf[0] = '\'';
- }
- }
- l = utflen((char*)name[n]+1);
- if(l > NBUF-4-2){
- i = 4;
- k = 1;
- while(i < NBUF/2){
- k += chartorune(&r, (char*)name[n]+k);
- i++;
- }
- c = name[n][k];
- name[n][k] = 0;
- strcpy((char*)buf+4, (char*)name[n]+1);
- name[n][k] = c;
- strcat((char*)buf, "...");
- while((l-i) >= NBUF/2-4){
- k += chartorune(&r, (char*)name[n]+k);
- i++;
- }
- strcat((char*)buf, (char*)name[n]+k);
- }else
- strcpy((char*)buf+4, (char*)name[n]+1);
- i = utflen((char*)buf);
- k = strlen((char*)buf);
- while(i<mw && k<sizeof buf-1){
- buf[k++] = ' ';
- i++;
- }
- buf[k] = 0;
- return (char *)buf;
+ Text *t;
+ int c, i, k, l, w;
+ Rune r;
+ char *p;
+
+ if(n >= NMENU3+nname)
+ return 0;
+ if(n < NMENU3){
+ p = menu3str[n];
+ if(lock)
+ p = paren(p);
+ return p;
+ }
+ n -= NMENU3;
+ if(n == 0) /* unless we've been fooled, this is cmd */
+ return (char *)&name[n][1];
+ if(mw == -1){
+ mw = 7; /* strlen("~~sam~~"); */
+ for(i=1; i<nname; i++){
+ w = utflen((char*)name[i]+1)+4; /* include "'+. " */
+ if(w > mw)
+ mw = w;
+ }
+ }
+ if(mw > NBUF)
+ mw = NBUF;
+ t = text[n];
+ buf[0] = name[n][0];
+ buf[1] = '-';
+ buf[2] = ' ';
+ buf[3] = ' ';
+ if(t){
+ if(t->nwin == 1)
+ buf[1] = '+';
+ else if(t->nwin > 1)
+ buf[1] = '*';
+ if(work && t==(Text *)work->user1) {
+ buf[2]= '.';
+ if(modified)
+ buf[0] = '\'';
+ }
+ }
+ l = utflen((char*)name[n]+1);
+ if(l > NBUF-4-2){
+ i = 4;
+ k = 1;
+ while(i < NBUF/2){
+ k += chartorune(&r, (char*)name[n]+k);
+ i++;
+ }
+ c = name[n][k];
+ name[n][k] = 0;
+ strcpy((char*)buf+4, (char*)name[n]+1);
+ name[n][k] = c;
+ strcat((char*)buf, "...");
+ while((l-i) >= NBUF/2-4){
+ k += chartorune(&r, (char*)name[n]+k);
+ i++;
+ }
+ strcat((char*)buf, (char*)name[n]+k);
+ }else
+ strcpy((char*)buf+4, (char*)name[n]+1);
+ i = utflen((char*)buf);
+ k = strlen((char*)buf);
+ while(i<mw && k<sizeof buf-1){
+ buf[k++] = ' ';
+ i++;
+ }
+ buf[k] = 0;
+ return (char *)buf;
}
diff --git a/samterm/mesg.c b/samterm/mesg.c
@@ -10,294 +10,294 @@
extern char *exname;
extern Flayer *flast;
-#define HSIZE 3 /* Type + short count */
-Header h;
-uchar indata[DATASIZE+1]; /* room for NUL */
-uchar outdata[DATASIZE];
-short outcount;
-int hversion;
-
-void inmesg(Hmesg, int);
-int inshort(int);
-long inlong(int);
-long invlong(int);
-void hsetdot(int, long, long);
-void hmoveto(int, long, Flayer *);
-void hsetsnarf(int);
-void clrlock(void);
-int snarfswap(char*, int, char**);
+#define HSIZE 3 /* Type + short count */
+Header h;
+uchar indata[DATASIZE+1]; /* room for NUL */
+uchar outdata[DATASIZE];
+short outcount;
+int hversion;
+
+void inmesg(Hmesg, int);
+int inshort(int);
+long inlong(int);
+long invlong(int);
+void hsetdot(int, long, long);
+void hmoveto(int, long, Flayer *);
+void hsetsnarf(int);
+void clrlock(void);
+int snarfswap(char*, int, char**);
void
rcv(void)
{
- int c;
- static int state = 0;
- static int count = 0;
- static int i = 0;
- static int errs = 0;
-
- while((c=rcvchar()) != -1)
- switch(state){
- case 0:
- h.type = c;
- state++;
- break;
-
- case 1:
- h.count0 = c;
- state++;
- break;
-
- case 2:
- h.count1 = c;
- count = h.count0|(h.count1<<8);
- i = 0;
- if(count > DATASIZE){
- if(++errs < 5){
- dumperrmsg(count, h.type, h.count0, c);
- state = 0;
- continue;
- }
- fprintf(stderr, "type %d count %d\n", h.type, …
- panic("count>DATASIZE");
- }
- if(count == 0)
- goto zerocount;
- state++;
- break;
-
- case 3:
- indata[i++] = c;
- if(i == count){
- zerocount:
- indata[i] = 0;
- inmesg(h.type, count);
- state = count = 0;
- continue;
- }
- break;
- }
+ int c;
+ static int state = 0;
+ static int count = 0;
+ static int i = 0;
+ static int errs = 0;
+
+ while((c=rcvchar()) != -1)
+ switch(state){
+ case 0:
+ h.type = c;
+ state++;
+ break;
+
+ case 1:
+ h.count0 = c;
+ state++;
+ break;
+
+ case 2:
+ h.count1 = c;
+ count = h.count0|(h.count1<<8);
+ i = 0;
+ if(count > DATASIZE){
+ if(++errs < 5){
+ dumperrmsg(count, h.type, h.count0, c);
+ state = 0;
+ continue;
+ }
+ fprintf(stderr, "type %d count %d\n", h.type, count);
+ panic("count>DATASIZE");
+ }
+ if(count == 0)
+ goto zerocount;
+ state++;
+ break;
+
+ case 3:
+ indata[i++] = c;
+ if(i == count){
+ zerocount:
+ indata[i] = 0;
+ inmesg(h.type, count);
+ state = count = 0;
+ continue;
+ }
+ break;
+ }
}
Text *
whichtext(int tg)
{
- int i;
+ int i;
- for(i=0; i<nname; i++)
- if(tag[i] == tg)
- return text[i];
- panic("whichtext");
- return 0;
+ for(i=0; i<nname; i++)
+ if(tag[i] == tg)
+ return text[i];
+ panic("whichtext");
+ return 0;
}
void
inmesg(Hmesg type, int count)
{
- Text *t;
- int i, m;
- long l, l2;
- Flayer *lp;
-
- m = inshort(0);
- l = inlong(2);
- switch(type){
- case -1:
- panic("rcv error");
- default:
- fprintf(stderr, "type %d\n", type);
- panic("rcv unknown");
-
- case Hversion:
- hversion = m;
+ Text *t;
+ int i, m;
+ long l, l2;
+ Flayer *lp;
+
+ m = inshort(0);
+ l = inlong(2);
+ switch(type){
+ case -1:
+ panic("rcv error");
+ default:
+ fprintf(stderr, "type %d\n", type);
+ panic("rcv unknown");
+
+ case Hversion:
+ hversion = m;
if (hversion != VERSION)
panic("host-terminal version mismatch");
- break;
-
- case Hbindname:
- l = invlong(2); /* for 64-bit pointers */
- if((i=whichmenu(m)) < 0)
- break;
- /* in case of a race, a bindname may already have occurred */
- if((t=whichtext(m)) == 0)
- t=(Text *)l;
- else /* let the old one win; clean up the new one */
- while(((Text *)l)->nwin>0)
- closeup(&((Text *)l)->l[((Text *)l)->front]);
- text[i] = t;
- text[i]->tag = m;
- break;
-
- case Hcurrent:
- if(whichmenu(m)<0)
- break;
- t = whichtext(m);
- i = which && ((Text *)which->user1)==&cmd && m!=cmd.tag;
- if(t==0 && (t = sweeptext(0, m))==0)
- break;
- if(t->l[t->front].textfn==0)
- panic("Hcurrent");
- lp = &t->l[t->front];
- if(i){
- flupfront(lp);
- flborder(lp, 0);
- work = lp;
+ break;
+
+ case Hbindname:
+ l = invlong(2); /* for 64-bit pointers */
+ if((i=whichmenu(m)) < 0)
+ break;
+ /* in case of a race, a bindname may already have occurred */
+ if((t=whichtext(m)) == 0)
+ t=(Text *)l;
+ else /* let the old one win; clean up the new one */
+ while(((Text *)l)->nwin>0)
+ closeup(&((Text *)l)->l[((Text *)l)->front]);
+ text[i] = t;
+ text[i]->tag = m;
+ break;
+
+ case Hcurrent:
+ if(whichmenu(m)<0)
+ break;
+ t = whichtext(m);
+ i = which && ((Text *)which->user1)==&cmd && m!=cmd.tag;
+ if(t==0 && (t = sweeptext(0, m))==0)
+ break;
+ if(t->l[t->front].textfn==0)
+ panic("Hcurrent");
+ lp = &t->l[t->front];
+ if(i){
+ flupfront(lp);
+ flborder(lp, 0);
+ work = lp;
flast = lp;
- }else
- current(lp);
- break;
-
- case Hmovname:
- if((m=whichmenu(m)) < 0)
- break;
- t = text[m];
- l = tag[m];
- i = name[m][0];
- text[m] = 0; /* suppress panic in menudel */
- menudel(m);
- if(t == &cmd)
- m = 0;
- else{
- if (nname>0 && text[0]==&cmd)
- m = 1;
- else m = 0;
- for(; m<nname; m++)
- if(strcmp((char*)indata+2, (char*)name[m]+1)<0)
- break;
- }
- menuins(m, indata+2, t, i, (int)l);
- break;
-
- case Hgrow:
- if(whichmenu(m) >= 0)
- hgrow(m, l, inlong(6), 1);
- break;
-
- case Hnewname:
- menuins(0, (uchar *)"", (Text *)0, ' ', m);
- break;
-
- case Hcheck0:
- i = whichmenu(m);
- if(i>=0) {
- t = text[i];
- if (t)
- t->lock++;
- outTs(Tcheck, m);
- }
- break;
-
- case Hcheck:
- i = whichmenu(m);
- if(i>=0) {
- t = text[i];
- if (t && t->lock)
- t->lock--;
- hcheck(m);
- }
- break;
-
- case Hunlock:
- clrlock();
- break;
-
- case Hdata:
- if(whichmenu(m) >= 0)
- l += hdata(m, l, indata+6, count-6);
- Checkscroll:
- if(m == cmd.tag){
- for(i=0; i<NL; i++){
- lp = &cmd.l[i];
- if(lp->textfn)
- center(lp, l>=0? l : lp->p1);
- }
- }
- break;
-
- case Horigin:
- if(whichmenu(m) >= 0){
+ }else
+ current(lp);
+ break;
+
+ case Hmovname:
+ if((m=whichmenu(m)) < 0)
+ break;
+ t = text[m];
+ l = tag[m];
+ i = name[m][0];
+ text[m] = 0; /* suppress panic in menudel */
+ menudel(m);
+ if(t == &cmd)
+ m = 0;
+ else{
+ if (nname>0 && text[0]==&cmd)
+ m = 1;
+ else m = 0;
+ for(; m<nname; m++)
+ if(strcmp((char*)indata+2, (char*)name[m]+1)<0)
+ break;
+ }
+ menuins(m, indata+2, t, i, (int)l);
+ break;
+
+ case Hgrow:
+ if(whichmenu(m) >= 0)
+ hgrow(m, l, inlong(6), 1);
+ break;
+
+ case Hnewname:
+ menuins(0, (uchar *)"", (Text *)0, ' ', m);
+ break;
+
+ case Hcheck0:
+ i = whichmenu(m);
+ if(i>=0) {
+ t = text[i];
+ if (t)
+ t->lock++;
+ outTs(Tcheck, m);
+ }
+ break;
+
+ case Hcheck:
+ i = whichmenu(m);
+ if(i>=0) {
+ t = text[i];
+ if (t && t->lock)
+ t->lock--;
+ hcheck(m);
+ }
+ break;
+
+ case Hunlock:
+ clrlock();
+ break;
+
+ case Hdata:
+ if(whichmenu(m) >= 0)
+ l += hdata(m, l, indata+6, count-6);
+ Checkscroll:
+ if(m == cmd.tag){
+ for(i=0; i<NL; i++){
+ lp = &cmd.l[i];
+ if(lp->textfn)
+ center(lp, l>=0? l : lp->p1);
+ }
+ }
+ break;
+
+ case Horigin:
+ if(whichmenu(m) >= 0){
if (oldcompat)
horigin(m, l, NULL);
else{
Text *t = whichtext(m);
l2 = inlong(6);
- horigin(m, l, &t->l[l2]);
+ horigin(m, l, &t->l[l2]);
}
}
- break;
-
- case Hunlockfile:
- if(whichmenu(m)>=0 && (t = whichtext(m))->lock){
- --t->lock;
- l = -1;
- goto Checkscroll;
- }
- break;
-
- case Hsetdot:
- if(whichmenu(m) >= 0)
- hsetdot(m, l, inlong(6));
- break;
-
- case Hgrowdata:
- if(whichmenu(m)<0)
- break;
- hgrow(m, l, inlong(6), 0);
- whichtext(m)->lock++; /* fake the request */
- l += hdata(m, l, indata+10, count-10);
- goto Checkscroll;
-
- case Hmoveto:
- if(whichmenu(m)>=0)
- hmoveto(m, l, NULL);
- break;
-
- case Hclean:
- if((m = whichmenu(m)) >= 0)
- name[m][0] = ' ';
- break;
-
- case Hdirty:
- if((m = whichmenu(m))>=0)
- name[m][0] = '\'';
- break;
-
- case Hdelname:
- if((m=whichmenu(m)) >= 0)
- menudel(m);
- break;
-
- case Hcut:
- if(whichmenu(m) >= 0)
- hcut(m, l, inlong(6));
- break;
-
- case Hclose:
- if(whichmenu(m)<0 || (t = whichtext(m))==0)
- break;
- l = t->nwin;
- for(i = 0,lp = t->l; l>0 && i<NL; i++,lp++)
- if(lp->textfn){
- closeup(lp);
- --l;
- }
- break;
-
- case Hsetpat:
- setpat((char *)indata);
- break;
-
- case Hsetsnarf:
- hsetsnarf(m);
- break;
-
- case Hsnarflen:
- snarflen = inlong(0);
- break;
-
- case Hack:
- outT0(Tack);
- break;
+ break;
+
+ case Hunlockfile:
+ if(whichmenu(m)>=0 && (t = whichtext(m))->lock){
+ --t->lock;
+ l = -1;
+ goto Checkscroll;
+ }
+ break;
+
+ case Hsetdot:
+ if(whichmenu(m) >= 0)
+ hsetdot(m, l, inlong(6));
+ break;
+
+ case Hgrowdata:
+ if(whichmenu(m)<0)
+ break;
+ hgrow(m, l, inlong(6), 0);
+ whichtext(m)->lock++; /* fake the request */
+ l += hdata(m, l, indata+10, count-10);
+ goto Checkscroll;
+
+ case Hmoveto:
+ if(whichmenu(m)>=0)
+ hmoveto(m, l, NULL);
+ break;
+
+ case Hclean:
+ if((m = whichmenu(m)) >= 0)
+ name[m][0] = ' ';
+ break;
+
+ case Hdirty:
+ if((m = whichmenu(m))>=0)
+ name[m][0] = '\'';
+ break;
+
+ case Hdelname:
+ if((m=whichmenu(m)) >= 0)
+ menudel(m);
+ break;
+
+ case Hcut:
+ if(whichmenu(m) >= 0)
+ hcut(m, l, inlong(6));
+ break;
+
+ case Hclose:
+ if(whichmenu(m)<0 || (t = whichtext(m))==0)
+ break;
+ l = t->nwin;
+ for(i = 0,lp = t->l; l>0 && i<NL; i++,lp++)
+ if(lp->textfn){
+ closeup(lp);
+ --l;
+ }
+ break;
+
+ case Hsetpat:
+ setpat((char *)indata);
+ break;
+
+ case Hsetsnarf:
+ hsetsnarf(m);
+ break;
+
+ case Hsnarflen:
+ snarflen = inlong(0);
+ break;
+
+ case Hack:
+ outT0(Tack);
+ break;
#ifndef NOFIFO
case Hextcmd:
@@ -313,275 +313,275 @@ inmesg(Hmesg type, int count)
break;
#endif
- case Hexit:
- outT0(Texit);
- mouseexit();
- break;
- }
+ case Hexit:
+ outT0(Texit);
+ mouseexit();
+ break;
+ }
}
void
setlock(void)
{
- lock++;
- cursorswitch(cursor = LockCursor);
+ lock++;
+ cursorswitch(cursor = LockCursor);
}
void
clrlock(void)
{
- hasunlocked = 1;
- if(lock > 0)
- lock--;
- if(lock == 0)
- cursorswitch(cursor=DefaultCursor);
+ hasunlocked = 1;
+ if(lock > 0)
+ lock--;
+ if(lock == 0)
+ cursorswitch(cursor=DefaultCursor);
}
void
startfile(Text *t)
{
- outTsv(Tstartfile, t->tag, t); /* for 64-bit pointers */
- setlock();
+ outTsv(Tstartfile, t->tag, t); /* for 64-bit pointers */
+ setlock();
}
void
startnewfile(int type, Text *t)
{
- t->tag = Untagged;
- outTv(type, t); /* for 64-bit pointers …
+ t->tag = Untagged;
+ outTv(type, t); /* for 64-bit pointers */
}
int
inshort(int n)
{
- return indata[n]|(indata[n+1]<<8);
+ return indata[n]|(indata[n+1]<<8);
}
long
inlong(int n)
{
- return indata[n]|(indata[n+1]<<8)|
- ((long)indata[n+2]<<16)|((long)indata[n+3]<<24);
+ return indata[n]|(indata[n+1]<<8)|
+ ((long)indata[n+2]<<16)|((long)indata[n+3]<<24);
}
long
invlong(int n)
{
- long l;
+ long l;
- l = (indata[n+7]<<24) | (indata[n+6]<<16) | (indata[n+5]<<8) | indata[…
- l = (l<<16) | (indata[n+3]<<8) | indata[n+2];
- l = (l<<16) | (indata[n+1]<<8) | indata[n];
- return l;
+ l = (indata[n+7]<<24) | (indata[n+6]<<16) | (indata[n+5]<<8) | indata[n+4];
+ l = (l<<16) | (indata[n+3]<<8) | indata[n+2];
+ l = (l<<16) | (indata[n+1]<<8) | indata[n];
+ return l;
}
void
outT0(Tmesg type)
{
- outstart(type);
- outsend();
+ outstart(type);
+ outsend();
}
void
outTl(Tmesg type, long l)
{
- outstart(type);
- outlong(l);
- outsend();
+ outstart(type);
+ outlong(l);
+ outsend();
}
void
outTs(Tmesg type, int s)
{
- outstart(type);
- outshort(s);
- outsend();
+ outstart(type);
+ outshort(s);
+ outsend();
}
void
outTss(Tmesg type, int s1, int s2)
{
- outstart(type);
- outshort(s1);
- outshort(s2);
- outsend();
+ outstart(type);
+ outshort(s1);
+ outshort(s2);
+ outsend();
}
void
outTslll(Tmesg type, int s1, long l1, long l2, long l3)
{
- outstart(type);
- outshort(s1);
- outlong(l1);
- outlong(l2);
- outlong(l3);
- outsend();
+ outstart(type);
+ outshort(s1);
+ outlong(l1);
+ outlong(l2);
+ outlong(l3);
+ outsend();
}
void
outTsll(Tmesg type, int s1, long l1, long l2)
{
- outstart(type);
- outshort(s1);
- outlong(l1);
- outlong(l2);
- outsend();
+ outstart(type);
+ outshort(s1);
+ outlong(l1);
+ outlong(l2);
+ outsend();
}
void
outTsl(Tmesg type, int s1, long l1)
{
- outstart(type);
- outshort(s1);
- outlong(l1);
- outsend();
+ outstart(type);
+ outshort(s1);
+ outlong(l1);
+ outsend();
}
void
outTsv(Tmesg type, int s1, void *l1)
{
- outstart(type);
- outshort(s1);
- outvlong(l1);
- outsend();
+ outstart(type);
+ outshort(s1);
+ outvlong(l1);
+ outsend();
}
void
outTv(Tmesg type, void *l1)
{
- outstart(type);
- outvlong(l1);
- outsend();
+ outstart(type);
+ outvlong(l1);
+ outsend();
}
void
outTslS(Tmesg type, int s1, long l1, Rune *s)
{
- char buf[DATASIZE*3+1];
- char *c;
+ char buf[DATASIZE*3+1];
+ char *c;
- outstart(type);
- outshort(s1);
- outlong(l1);
- c = buf;
- while(*s)
- c += runetochar(c, s++);
- *c++ = 0;
- outcopy(c-buf, (uchar *)buf);
- outsend();
+ outstart(type);
+ outshort(s1);
+ outlong(l1);
+ c = buf;
+ while(*s)
+ c += runetochar(c, s++);
+ *c++ = 0;
+ outcopy(c-buf, (uchar *)buf);
+ outsend();
}
void
outTsls(Tmesg type, int s1, long l1, int s2)
{
- outstart(type);
- outshort(s1);
- outlong(l1);
- outshort(s2);
- outsend();
+ outstart(type);
+ outshort(s1);
+ outlong(l1);
+ outshort(s2);
+ outsend();
}
void
outstart(Tmesg type)
{
- outdata[0] = type;
- outcount = 0;
+ outdata[0] = type;
+ outcount = 0;
}
void
outcopy(int count, uchar *data)
{
- while(count--)
- outdata[HSIZE+outcount++] = *data++;
+ while(count--)
+ outdata[HSIZE+outcount++] = *data++;
}
void
outshort(int s)
{
- uchar buf[2];
+ uchar buf[2];
- buf[0]=s;
- buf[1]=s>>8;
- outcopy(2, buf);
+ buf[0]=s;
+ buf[1]=s>>8;
+ outcopy(2, buf);
}
void
outlong(long l)
{
- uchar buf[4];
+ uchar buf[4];
- buf[0]=l;
- buf[1]=l>>8;
- buf[2]=l>>16;
- buf[3]=l>>24;
- outcopy(4, buf);
+ buf[0]=l;
+ buf[1]=l>>8;
+ buf[2]=l>>16;
+ buf[3]=l>>24;
+ outcopy(4, buf);
}
void
outvlong(void *v)
{
- int i;
- uintptr_t l;
- uchar buf[8];
+ int i;
+ uintptr_t l;
+ uchar buf[8];
- l = (uintptr_t)v;
- for(i = 0; i < sizeof(buf); i++, l >>= 8)
- buf[i] = l;
+ l = (uintptr_t)v;
+ for(i = 0; i < sizeof(buf); i++, l >>= 8)
+ buf[i] = l;
- outcopy(8, buf);
+ outcopy(8, buf);
}
void
outsend(void)
{
- if(outcount>DATASIZE-HSIZE)
- panic("outcount>sizeof outdata");
- outdata[1]=outcount;
- outdata[2]=outcount>>8;
- if(write(1, (char *)outdata, outcount+HSIZE)!=outcount+HSIZE)
- exits("write error");
+ if(outcount>DATASIZE-HSIZE)
+ panic("outcount>sizeof outdata");
+ outdata[1]=outcount;
+ outdata[2]=outcount>>8;
+ if(write(1, (char *)outdata, outcount+HSIZE)!=outcount+HSIZE)
+ exits("write error");
}
void
hsetdot(int m, long p0, long p1)
{
- Text *t = whichtext(m);
- Flayer *l = &t->l[t->front];
+ Text *t = whichtext(m);
+ Flayer *l = &t->l[t->front];
- flushtyping(1);
- flsetselect(l, p0, p1);
+ flushtyping(1);
+ flsetselect(l, p0, p1);
}
void
horigin(int m, long p0, Flayer *l)
{
- Text *t = whichtext(m);
- l = l ? l : &t->l[t->front];
- long a;
- ulong n;
- Rune *r;
+ Text *t = whichtext(m);
+ l = l ? l : &t->l[t->front];
+ long a;
+ ulong n;
+ Rune *r;
if (getlayer(l, t) < 0)
return; /* the user managed to close the layer during the round trip w…
- if(!flprepare(l)){
- l->origin = p0;
- return;
- }
- a = p0-l->origin;
- if(a>=0 && a<l->f.nchars)
- frdelete(&l->f, 0, a);
- else if(a<0 && -a<l->f.nchars){
- r = rload(&t->rasp, p0, l->origin, &n);
- frinsert(&l->f, r, r+n, 0);
- }else
- frdelete(&l->f, 0, l->f.nchars);
- l->origin = p0;
- scrdraw(l, t->rasp.nrunes);
- if(l->visible==Some)
- flrefresh(l, l->entire, 0);
- hcheck(m);
+ if(!flprepare(l)){
+ l->origin = p0;
+ return;
+ }
+ a = p0-l->origin;
+ if(a>=0 && a<l->f.nchars)
+ frdelete(&l->f, 0, a);
+ else if(a<0 && -a<l->f.nchars){
+ r = rload(&t->rasp, p0, l->origin, &n);
+ frinsert(&l->f, r, r+n, 0);
+ }else
+ frdelete(&l->f, 0, l->f.nchars);
+ l->origin = p0;
+ scrdraw(l, t->rasp.nrunes);
+ if(l->visible==Some)
+ flrefresh(l, l->entire, 0);
+ hcheck(m);
}
void
@@ -601,220 +601,220 @@ hmoveto(int m, long p0, Flayer *l)
void
hcheck(int m)
{
- Flayer *l;
- Text *t;
- int reqd = 0, i;
- long n, nl, a;
- Rune *r;
-
- if(m == Untagged)
- return;
- t = whichtext(m);
- if(t == 0) /* possible in a half-built window */
- return;
- for(l = &t->l[0], i = 0; i<NL; i++, l++){
- if(l->textfn==0 || !flprepare(l)) /* BUG: don't
- need this if BUG be…
- is fixed */
- continue;
- a = t->l[i].origin;
- n = rcontig(&t->rasp, a, a+l->f.nchars, 1);
- if(n<l->f.nchars) /* text missing in middle of screen */
- a+=n;
- else{ /* text missing at end of screen?…
+ Flayer *l;
+ Text *t;
+ int reqd = 0, i;
+ long n, nl, a;
+ Rune *r;
+
+ if(m == Untagged)
+ return;
+ t = whichtext(m);
+ if(t == 0) /* possible in a half-built window */
+ return;
+ for(l = &t->l[0], i = 0; i<NL; i++, l++){
+ if(l->textfn==0 || !flprepare(l)) /* BUG: don't
+ need this if BUG below
+ is fixed */
+ continue;
+ a = t->l[i].origin;
+ n = rcontig(&t->rasp, a, a+l->f.nchars, 1);
+ if(n<l->f.nchars) /* text missing in middle of screen */
+ a+=n;
+ else{ /* text missing at end of screen? */
Again:
- if(l->f.lastlinefull)
- goto Checksel; /* all's well */
- a = t->l[i].origin+l->f.nchars;
- n = t->rasp.nrunes-a;
- if(n==0)
- goto Checksel;
- if(n>TBLOCKSIZE)
- n = TBLOCKSIZE;
- n = rcontig(&t->rasp, a, a+n, 1);
- if(n>0){
- rload(&t->rasp, a, a+n, 0);
- nl = l->f.nchars;
- r = scratch;
- flinsert(l, r, r+n, l->origin+nl);
- if(nl == l->f.nchars) /* made no progre…
- goto Checksel;
- goto Again;
- }
- }
- if(!reqd){
- n = rcontig(&t->rasp, a, a+TBLOCKSIZE, 0);
- if(n <= 0)
- panic("hcheck request==0");
- outTsls(Trequest, m, a, (int)n);
- outTs(Tcheck, m);
- t->lock++; /* for the Trequest */
- t->lock++; /* for the Tcheck */
- reqd++;
- }
- Checksel:
- flsetselect(l, l->p0, l->p1);
- }
+ if(l->f.lastlinefull)
+ goto Checksel; /* all's well */
+ a = t->l[i].origin+l->f.nchars;
+ n = t->rasp.nrunes-a;
+ if(n==0)
+ goto Checksel;
+ if(n>TBLOCKSIZE)
+ n = TBLOCKSIZE;
+ n = rcontig(&t->rasp, a, a+n, 1);
+ if(n>0){
+ rload(&t->rasp, a, a+n, 0);
+ nl = l->f.nchars;
+ r = scratch;
+ flinsert(l, r, r+n, l->origin+nl);
+ if(nl == l->f.nchars) /* made no progress */
+ goto Checksel;
+ goto Again;
+ }
+ }
+ if(!reqd){
+ n = rcontig(&t->rasp, a, a+TBLOCKSIZE, 0);
+ if(n <= 0)
+ panic("hcheck request==0");
+ outTsls(Trequest, m, a, (int)n);
+ outTs(Tcheck, m);
+ t->lock++; /* for the Trequest */
+ t->lock++; /* for the Tcheck */
+ reqd++;
+ }
+ Checksel:
+ flsetselect(l, l->p0, l->p1);
+ }
}
void
flnewlyvisible(Flayer *l)
{
- hcheck(((Text *)l->user1)->tag);
+ hcheck(((Text *)l->user1)->tag);
}
void
hsetsnarf(int nc)
{
- char *s2;
- char *s1;
- int i;
- int n;
-
- cursorswitch(DeadCursor);
- s2 = alloc(nc+1);
- for(i=0; i<nc; i++)
- s2[i] = getch();
- s2[nc] = 0;
- n = snarfswap(s2, nc, &s1);
- if(n >= 0){
- if(!s1)
- n = 0;
- if(n > SNARFSIZE-1)
- n = SNARFSIZE-1;
- s1 = realloc(s1, n+1);
- if (!s1)
- exits("malloc");
- s1[n] = 0;
- snarflen = n;
- outTs(Tsetsnarf, n);
- if(n>0 && write(1, s1, n)!=n)
- exits("write error");
- free(s1);
- }else
- outTs(Tsetsnarf, 0);
- free(s2);
- cursorswitch(cursor);
+ char *s2;
+ char *s1;
+ int i;
+ int n;
+
+ cursorswitch(DeadCursor);
+ s2 = alloc(nc+1);
+ for(i=0; i<nc; i++)
+ s2[i] = getch();
+ s2[nc] = 0;
+ n = snarfswap(s2, nc, &s1);
+ if(n >= 0){
+ if(!s1)
+ n = 0;
+ if(n > SNARFSIZE-1)
+ n = SNARFSIZE-1;
+ s1 = realloc(s1, n+1);
+ if (!s1)
+ exits("malloc");
+ s1[n] = 0;
+ snarflen = n;
+ outTs(Tsetsnarf, n);
+ if(n>0 && write(1, s1, n)!=n)
+ exits("write error");
+ free(s1);
+ }else
+ outTs(Tsetsnarf, 0);
+ free(s2);
+ cursorswitch(cursor);
}
void
hgrow(int m, long a, long new, int req)
{
- int i;
- Flayer *l;
- Text *t = whichtext(m);
- long o, b;
-
- if(new <= 0)
- panic("hgrow");
- rresize(&t->rasp, a, 0L, new);
- for(l = &t->l[0], i = 0; i<NL; i++, l++){
- if(l->textfn == 0)
- continue;
- o = l->origin;
- b = a-o-rmissing(&t->rasp, o, a);
- if(a < o)
- l->origin+=new;
- if(a < l->p0)
- l->p0+=new;
- if(a < l->p1)
- l->p1+=new;
- /* must prevent b temporarily becoming unsigned */
- if(!req || a<o || (b>0 && b>l->f.nchars) ||
- (l->f.nchars==0 && a-o>0))
- continue;
- if(new>TBLOCKSIZE)
- new = TBLOCKSIZE;
- outTsls(Trequest, m, a, (int)new);
- t->lock++;
- req = 0;
- }
+ int i;
+ Flayer *l;
+ Text *t = whichtext(m);
+ long o, b;
+
+ if(new <= 0)
+ panic("hgrow");
+ rresize(&t->rasp, a, 0L, new);
+ for(l = &t->l[0], i = 0; i<NL; i++, l++){
+ if(l->textfn == 0)
+ continue;
+ o = l->origin;
+ b = a-o-rmissing(&t->rasp, o, a);
+ if(a < o)
+ l->origin+=new;
+ if(a < l->p0)
+ l->p0+=new;
+ if(a < l->p1)
+ l->p1+=new;
+ /* must prevent b temporarily becoming unsigned */
+ if(!req || a<o || (b>0 && b>l->f.nchars) ||
+ (l->f.nchars==0 && a-o>0))
+ continue;
+ if(new>TBLOCKSIZE)
+ new = TBLOCKSIZE;
+ outTsls(Trequest, m, a, (int)new);
+ t->lock++;
+ req = 0;
+ }
}
int
hdata1(Text *t, long a, Rune *r, int len)
{
- int i;
- Flayer *l;
- long o, b;
-
- for(l = &t->l[0], i=0; i<NL; i++, l++){
- if(l->textfn==0)
- continue;
- o = l->origin;
- b = a-o-rmissing(&t->rasp, o, a);
- /* must prevent b temporarily becoming unsigned */
- if(a<o || (b>0 && b>l->f.nchars))
- continue;
- flinsert(l, r, r+len, o+b);
- }
- rdata(&t->rasp, a, a+len, r);
- rclean(&t->rasp);
- return len;
+ int i;
+ Flayer *l;
+ long o, b;
+
+ for(l = &t->l[0], i=0; i<NL; i++, l++){
+ if(l->textfn==0)
+ continue;
+ o = l->origin;
+ b = a-o-rmissing(&t->rasp, o, a);
+ /* must prevent b temporarily becoming unsigned */
+ if(a<o || (b>0 && b>l->f.nchars))
+ continue;
+ flinsert(l, r, r+len, o+b);
+ }
+ rdata(&t->rasp, a, a+len, r);
+ rclean(&t->rasp);
+ return len;
}
int
hdata(int m, long a, uchar *s, int len)
{
- int i, w;
- Text *t = whichtext(m);
- Rune buf[DATASIZE], *r;
+ int i, w;
+ Text *t = whichtext(m);
+ Rune buf[DATASIZE], *r;
- if(t->lock)
- --t->lock;
- if(len == 0)
- return 0;
- r = buf;
- for(i=0; i<len; i+=w,s+=w)
- w = chartorune(r++, (char*)s);
- return hdata1(t, a, buf, r-buf);
+ if(t->lock)
+ --t->lock;
+ if(len == 0)
+ return 0;
+ r = buf;
+ for(i=0; i<len; i+=w,s+=w)
+ w = chartorune(r++, (char*)s);
+ return hdata1(t, a, buf, r-buf);
}
int
hdatarune(int m, long a, Rune *r, int len)
{
- Text *t = whichtext(m);
+ Text *t = whichtext(m);
- if(t->lock)
- --t->lock;
- if(len == 0)
- return 0;
- return hdata1(t, a, r, len);
+ if(t->lock)
+ --t->lock;
+ if(len == 0)
+ return 0;
+ return hdata1(t, a, r, len);
}
void
hcut(int m, long a, long old)
{
- Flayer *l;
- Text *t = whichtext(m);
- int i;
- long o, b;
-
- if(t->lock)
- --t->lock;
- for(l = &t->l[0], i = 0; i<NL; i++, l++){
- if(l->textfn == 0)
- continue;
- o = l->origin;
- b = a-o-rmissing(&t->rasp, o, a);
- /* must prevent b temporarily becoming unsigned */
- if((b<0 || b<l->f.nchars) && a+old>=o){
- fldelete(l, b<0? o : o+b,
- a+old-rmissing(&t->rasp, o, a+old));
- }
- if(a+old<o)
- l->origin-=old;
- else if(a<=o)
- l->origin = a;
- if(a+old<l->p0)
- l->p0-=old;
- else if(a<=l->p0)
- l->p0 = a;
- if(a+old<l->p1)
- l->p1-=old;
- else if(a<=l->p1)
- l->p1 = a;
- }
- rresize(&t->rasp, a, old, 0L);
- rclean(&t->rasp);
+ Flayer *l;
+ Text *t = whichtext(m);
+ int i;
+ long o, b;
+
+ if(t->lock)
+ --t->lock;
+ for(l = &t->l[0], i = 0; i<NL; i++, l++){
+ if(l->textfn == 0)
+ continue;
+ o = l->origin;
+ b = a-o-rmissing(&t->rasp, o, a);
+ /* must prevent b temporarily becoming unsigned */
+ if((b<0 || b<l->f.nchars) && a+old>=o){
+ fldelete(l, b<0? o : o+b,
+ a+old-rmissing(&t->rasp, o, a+old));
+ }
+ if(a+old<o)
+ l->origin-=old;
+ else if(a<=o)
+ l->origin = a;
+ if(a+old<l->p0)
+ l->p0-=old;
+ else if(a<=l->p0)
+ l->p0 = a;
+ if(a+old<l->p1)
+ l->p1-=old;
+ else if(a<=l->p1)
+ l->p1 = a;
+ }
+ rresize(&t->rasp, a, old, 0L);
+ rclean(&t->rasp);
}
diff --git a/samterm/rasp.c b/samterm/rasp.c
@@ -9,255 +9,255 @@
void
rinit(Rasp *r)
{
- r->nrunes=0;
- r->sect=0;
+ r->nrunes=0;
+ r->sect=0;
}
void
rclear(Rasp *r)
{
- Section *s, *ns;
+ Section *s, *ns;
- for(s=r->sect; s; s=ns){
- ns = s->next;
- free(s->text);
- free(s);
- }
- r->sect = 0;
+ for(s=r->sect; s; s=ns){
+ ns = s->next;
+ free(s->text);
+ free(s);
+ }
+ r->sect = 0;
}
Section*
-rsinsert(Rasp *r, Section *s) /* insert before s */
+rsinsert(Rasp *r, Section *s) /* insert before s */
{
- Section *t;
- Section *u;
+ Section *t;
+ Section *u;
- t = alloc(sizeof(Section));
- if(r->sect == s){ /* includes empty list case: r->sect==s==0 */
- r->sect = t;
- t->next = s;
- }else{
- u = r->sect;
- if(u == 0)
- panic("rsinsert 1");
- do{
- if(u->next == s){
- t->next = s;
- u->next = t;
- goto Return;
- }
- u=u->next;
- }while(u);
- panic("rsinsert 2");
- }
+ t = alloc(sizeof(Section));
+ if(r->sect == s){ /* includes empty list case: r->sect==s==0 */
+ r->sect = t;
+ t->next = s;
+ }else{
+ u = r->sect;
+ if(u == 0)
+ panic("rsinsert 1");
+ do{
+ if(u->next == s){
+ t->next = s;
+ u->next = t;
+ goto Return;
+ }
+ u=u->next;
+ }while(u);
+ panic("rsinsert 2");
+ }
Return:
- return t;
+ return t;
}
void
rsdelete(Rasp *r, Section *s)
{
- Section *t;
+ Section *t;
- if(s == 0)
- panic("rsdelete");
- if(r->sect == s){
- r->sect = s->next;
- goto Free;
- }
- for(t=r->sect; t; t=t->next)
- if(t->next == s){
- t->next = s->next;
- Free:
- if(s->text)
- free(s->text);
- free(s);
- return;
- }
- panic("rsdelete 2");
+ if(s == 0)
+ panic("rsdelete");
+ if(r->sect == s){
+ r->sect = s->next;
+ goto Free;
+ }
+ for(t=r->sect; t; t=t->next)
+ if(t->next == s){
+ t->next = s->next;
+ Free:
+ if(s->text)
+ free(s->text);
+ free(s);
+ return;
+ }
+ panic("rsdelete 2");
}
void
splitsect(Rasp *r, Section *s, long n0)
{
- if(s == 0)
- panic("splitsect");
- rsinsert(r, s->next);
- if(s->text == 0)
- s->next->text = 0;
- else{
- s->next->text = alloc(RUNESIZE*(TBLOCKSIZE+1));
- Strcpy(s->next->text, s->text+n0);
- s->text[n0] = 0;
- }
- s->next->nrunes = s->nrunes-n0;
- s->nrunes = n0;
+ if(s == 0)
+ panic("splitsect");
+ rsinsert(r, s->next);
+ if(s->text == 0)
+ s->next->text = 0;
+ else{
+ s->next->text = alloc(RUNESIZE*(TBLOCKSIZE+1));
+ Strcpy(s->next->text, s->text+n0);
+ s->text[n0] = 0;
+ }
+ s->next->nrunes = s->nrunes-n0;
+ s->nrunes = n0;
}
Section *
-findsect(Rasp *r, Section *s, long p, long q) /* find sect containing q…
+findsect(Rasp *r, Section *s, long p, long q) /* find sect containing q and …
{
- if(s==0 && p!=q)
- panic("findsect");
- for(; s && p+s->nrunes<=q; s=s->next)
- p += s->nrunes;
- if(p != q){
- splitsect(r, s, q-p);
- s = s->next;
- }
- return s;
+ if(s==0 && p!=q)
+ panic("findsect");
+ for(; s && p+s->nrunes<=q; s=s->next)
+ p += s->nrunes;
+ if(p != q){
+ splitsect(r, s, q-p);
+ s = s->next;
+ }
+ return s;
}
void
rresize(Rasp *r, long a, long old, long new)
{
- Section *s, *t, *ns;
+ Section *s, *t, *ns;
- s = findsect(r, r->sect, 0L, a);
- t = findsect(r, s, a, a+old);
- for(; s!=t; s=ns){
- ns=s->next;
- rsdelete(r, s);
- }
- /* now insert the new piece before t */
- if(new > 0){
- ns=rsinsert(r, t);
- ns->nrunes=new;
- ns->text=0;
- }
- r->nrunes += new-old;
+ s = findsect(r, r->sect, 0L, a);
+ t = findsect(r, s, a, a+old);
+ for(; s!=t; s=ns){
+ ns=s->next;
+ rsdelete(r, s);
+ }
+ /* now insert the new piece before t */
+ if(new > 0){
+ ns=rsinsert(r, t);
+ ns->nrunes=new;
+ ns->text=0;
+ }
+ r->nrunes += new-old;
}
void
rdata(Rasp *r, long p0, long p1, Rune *cp)
{
- Section *s, *t, *ns;
+ Section *s, *t, *ns;
- s = findsect(r, r->sect, 0L, p0);
- t = findsect(r, s, p0, p1);
- for(; s!=t; s=ns){
- ns=s->next;
- if(s->text)
- panic("rdata");
- rsdelete(r, s);
- }
- p1 -= p0;
- s = rsinsert(r, t);
- s->text = alloc(RUNESIZE*(TBLOCKSIZE+1));
- memmove(s->text, cp, RUNESIZE*p1);
- s->text[p1] = 0;
- s->nrunes = p1;
+ s = findsect(r, r->sect, 0L, p0);
+ t = findsect(r, s, p0, p1);
+ for(; s!=t; s=ns){
+ ns=s->next;
+ if(s->text)
+ panic("rdata");
+ rsdelete(r, s);
+ }
+ p1 -= p0;
+ s = rsinsert(r, t);
+ s->text = alloc(RUNESIZE*(TBLOCKSIZE+1));
+ memmove(s->text, cp, RUNESIZE*p1);
+ s->text[p1] = 0;
+ s->nrunes = p1;
}
void
rclean(Rasp *r)
{
- Section *s;
+ Section *s;
- for(s=r->sect; s; s=s->next)
- while(s->next && (s->text!=0)==(s->next->text!=0)){
- if(s->text){
- if(s->nrunes+s->next->nrunes>TBLOCKSIZE)
- break;
- Strcpy(s->text+s->nrunes, s->next->text);
- }
- s->nrunes += s->next->nrunes;
- rsdelete(r, s->next);
- }
+ for(s=r->sect; s; s=s->next)
+ while(s->next && (s->text!=0)==(s->next->text!=0)){
+ if(s->text){
+ if(s->nrunes+s->next->nrunes>TBLOCKSIZE)
+ break;
+ Strcpy(s->text+s->nrunes, s->next->text);
+ }
+ s->nrunes += s->next->nrunes;
+ rsdelete(r, s->next);
+ }
}
void
Strcpy(Rune *to, Rune *from)
{
- do; while(*to++ = *from++);
+ do; while(*to++ = *from++);
}
Rune*
rload(Rasp *r, ulong p0, ulong p1, ulong *nrp)
{
- Section *s;
- long p;
- int n, nb;
+ Section *s;
+ long p;
+ int n, nb;
- nb = 0;
- Strgrow(&scratch, &nscralloc, p1-p0+1);
- scratch[0] = 0;
- for(p=0,s=r->sect; s && p+s->nrunes<=p0; s=s->next)
- p += s->nrunes;
- while(p<p1 && s){
- /*
- * Subtle and important. If we are preparing to handle an 'rd…
- * call, it's because we have an 'rresize' hole here, so the
- * screen doesn't have data for that space anyway (it got cut
- * first). So pretend it isn't there.
- */
- if(s->text){
- n = s->nrunes-(p0-p);
- if(n>p1-p0) /* all in this section */
- n = p1-p0;
- memmove(scratch+nb, s->text+(p0-p), n*RUNESIZE);
- nb += n;
- scratch[nb] = 0;
- }
- p += s->nrunes;
- p0 = p;
- s = s->next;
- }
- if(nrp)
- *nrp = nb;
- return scratch;
+ nb = 0;
+ Strgrow(&scratch, &nscralloc, p1-p0+1);
+ scratch[0] = 0;
+ for(p=0,s=r->sect; s && p+s->nrunes<=p0; s=s->next)
+ p += s->nrunes;
+ while(p<p1 && s){
+ /*
+ * Subtle and important. If we are preparing to handle an 'rdata'
+ * call, it's because we have an 'rresize' hole here, so the
+ * screen doesn't have data for that space anyway (it got cut
+ * first). So pretend it isn't there.
+ */
+ if(s->text){
+ n = s->nrunes-(p0-p);
+ if(n>p1-p0) /* all in this section */
+ n = p1-p0;
+ memmove(scratch+nb, s->text+(p0-p), n*RUNESIZE);
+ nb += n;
+ scratch[nb] = 0;
+ }
+ p += s->nrunes;
+ p0 = p;
+ s = s->next;
+ }
+ if(nrp)
+ *nrp = nb;
+ return scratch;
}
int
rmissing(Rasp *r, ulong p0, ulong p1)
{
- Section *s;
- long p;
- int n, nm=0;
+ Section *s;
+ long p;
+ int n, nm=0;
- for(p=0,s=r->sect; s && p+s->nrunes<=p0; s=s->next)
- p += s->nrunes;
- while(p<p1 && s){
- if(s->text == 0){
- n = s->nrunes-(p0-p);
- if(n > p1-p0) /* all in this section */
- n = p1-p0;
- nm += n;
- }
- p += s->nrunes;
- p0 = p;
- s = s->next;
- }
- return nm;
+ for(p=0,s=r->sect; s && p+s->nrunes<=p0; s=s->next)
+ p += s->nrunes;
+ while(p<p1 && s){
+ if(s->text == 0){
+ n = s->nrunes-(p0-p);
+ if(n > p1-p0) /* all in this section */
+ n = p1-p0;
+ nm += n;
+ }
+ p += s->nrunes;
+ p0 = p;
+ s = s->next;
+ }
+ return nm;
}
int
rcontig(Rasp *r, ulong p0, ulong p1, int text)
{
- Section *s;
- long p, n;
- int np=0;
+ Section *s;
+ long p, n;
+ int np=0;
- for(p=0,s=r->sect; s && p+s->nrunes<=p0; s=s->next)
- p += s->nrunes;
- while(p<p1 && s && (text? (s->text!=0) : (s->text==0))){
- n = s->nrunes-(p0-p);
- if(n > p1-p0) /* all in this section */
- n = p1-p0;
- np += n;
- p += s->nrunes;
- p0 = p;
- s = s->next;
- }
- return np;
+ for(p=0,s=r->sect; s && p+s->nrunes<=p0; s=s->next)
+ p += s->nrunes;
+ while(p<p1 && s && (text? (s->text!=0) : (s->text==0))){
+ n = s->nrunes-(p0-p);
+ if(n > p1-p0) /* all in this section */
+ n = p1-p0;
+ np += n;
+ p += s->nrunes;
+ p0 = p;
+ s = s->next;
+ }
+ return np;
}
void
-Strgrow(Rune **s, long *n, int want) /* can always toss the old data wh…
+Strgrow(Rune **s, long *n, int want) /* can always toss the old data when c…
{
- if(*n >= want)
- return;
- free(*s);
- *s = alloc(RUNESIZE*want);
- *n = want;
+ if(*n >= want)
+ return;
+ free(*s);
+ *s = alloc(RUNESIZE*want);
+ *n = want;
}
diff --git a/samterm/samterm.h b/samterm/samterm.h
@@ -1,159 +1,159 @@
/* Copyright (c) 1998 Lucent Technologies - All rights reserved. */
-#define SAMTERM
+#define SAMTERM
#include "../config.h"
-#define RUNESIZE sizeof(Rune)
-#define MAXFILES 256
-#define NL 5
+#define RUNESIZE sizeof(Rune)
+#define MAXFILES 256
+#define NL 5
enum{
- Up,
- Down
+ Up,
+ Down
};
-typedef struct Text Text;
-typedef struct Section Section;
-typedef struct Rasp Rasp;
+typedef struct Text Text;
+typedef struct Section Section;
+typedef struct Rasp Rasp;
struct Section
{
- long nrunes;
- Rune *text; /* if null, we haven't got it */
- Section *next;
+ long nrunes;
+ Rune *text; /* if null, we haven't got it */
+ Section *next;
};
struct Rasp
{
- long nrunes;
- Section *sect;
+ long nrunes;
+ Section *sect;
};
-#define Untagged ((ushort)65535)
+#define Untagged ((ushort)65535)
struct Text
{
- Rasp rasp;
- short nwin;
- short front; /* input window */
- ushort tag;
- char lock;
- Flayer l[NL]; /* screen storage */
+ Rasp rasp;
+ short nwin;
+ short front; /* input window */
+ ushort tag;
+ char lock;
+ Flayer l[NL]; /* screen storage */
};
enum Resource
{
- Eextern = 0x08,
- Ehost = 0x04,
- RHost = Ehost,
- RExtern = Eextern,
- RKeyboard = Ekeyboard,
- RMouse = Emouse
+ Eextern = 0x08,
+ Ehost = 0x04,
+ RHost = Ehost,
+ RExtern = Eextern,
+ RKeyboard = Ekeyboard,
+ RMouse = Emouse
};
-extern Text *text[];
-extern uchar *name[];
-extern ushort tag[];
-extern int nname;
-extern unsigned int cursor;
-extern Flayer *which;
-extern Flayer *work;
-extern Text cmd;
-extern Rune *scratch;
-extern long nscralloc;
-extern char lock;
-extern char hasunlocked;
-extern long snarflen;
-extern Mouse mouse;
-extern long modified;
+extern Text *text[];
+extern uchar *name[];
+extern ushort tag[];
+extern int nname;
+extern unsigned int cursor;
+extern Flayer *which;
+extern Flayer *work;
+extern Text cmd;
+extern Rune *scratch;
+extern long nscralloc;
+extern char lock;
+extern char hasunlocked;
+extern long snarflen;
+extern Mouse mouse;
+extern long modified;
-Rune *stgettext(Flayer*, long, ulong*);
-void *alloc(ulong n);
+Rune *stgettext(Flayer*, long, ulong*);
+void *alloc(ulong n);
-void iconinit(void);
-void getscreen(int, char**);
-void initio(void);
-void setlock(void);
-void outcmd(void);
-void rinit(Rasp*);
-void startnewfile(int, Text*);
-void cursorset(Point);
-void getmouse(void);
-void mouseunblock(void);
-void kbdblock(void);
-void extstart(void);
-int button(int but);
-int load(char*, int);
-int waitforio(void);
-int rcvchar(void);
-int getch(void);
+void iconinit(void);
+void getscreen(int, char**);
+void initio(void);
+void setlock(void);
+void outcmd(void);
+void rinit(Rasp*);
+void startnewfile(int, Text*);
+void cursorset(Point);
+void getmouse(void);
+void mouseunblock(void);
+void kbdblock(void);
+void extstart(void);
+int button(int but);
+int load(char*, int);
+int waitforio(void);
+int rcvchar(void);
+int getch(void);
Keystroke qpeekc(void);
-Keystroke kbdchar(void);
-void mouseexit(void);
-void cut(Text*, int, int, int);
-void paste(Text*, int);
-void snarf(Text*, int);
-int center(Flayer*, long);
-int xmenuhit(int, Menu*);
-void buttons(int);
-int getr(Rectangle*);
-void current(Flayer*);
-void duplicate(Flayer*, Rectangle, XftFont*, int);
-void startfile(Text*);
-void panic(char*);
-void closeup(Flayer*);
-void Strgrow(Rune**, long*, int);
-int RESHAPED(void);
-void reshape(void);
-void rcv(void);
-void type(Flayer*, int);
-void menu2hit(void);
-void menu3hit(void);
-void scroll(Flayer*, int, int);
-void hcheck(int);
-void rclear(Rasp*);
-int whichmenu(int);
-void hcut(int, long, long);
-void horigin(int, long, Flayer *);
-void hgrow(int, long, long, int);
-int hdata(int, long, uchar*, int);
-int hdatarune(int, long, Rune*, int);
-Rune *rload(Rasp*, ulong, ulong, ulong*);
-void menuins(int, uchar*, Text*, int, int);
-void menudel(int);
-Text *sweeptext(int, int);
-void setpat(char*);
-void scrdraw(Flayer*, long tot);
-int rcontig(Rasp*, ulong, ulong, int);
-int rmissing(Rasp*, ulong, ulong);
-void rresize(Rasp *, long, long, long);
-void rdata(Rasp*, long, long, Rune*);
-void rclean(Rasp*);
-void scrorigin(Flayer*, int, long);
-long scrtotal(Flayer*);
-void flnewlyvisible(Flayer*);
-char *rcvstring(void);
-void Strcpy(Rune*, Rune*);
-void Strncpy(Rune*, Rune*, long);
-void flushtyping(int);
-void dumperrmsg(int, int, int, int);
-int screensize(int*,int*);
+Keystroke kbdchar(void);
+void mouseexit(void);
+void cut(Text*, int, int, int);
+void paste(Text*, int);
+void snarf(Text*, int);
+int center(Flayer*, long);
+int xmenuhit(int, Menu*);
+void buttons(int);
+int getr(Rectangle*);
+void current(Flayer*);
+void duplicate(Flayer*, Rectangle, XftFont*, int);
+void startfile(Text*);
+void panic(char*);
+void closeup(Flayer*);
+void Strgrow(Rune**, long*, int);
+int RESHAPED(void);
+void reshape(void);
+void rcv(void);
+void type(Flayer*, int);
+void menu2hit(void);
+void menu3hit(void);
+void scroll(Flayer*, int, int);
+void hcheck(int);
+void rclear(Rasp*);
+int whichmenu(int);
+void hcut(int, long, long);
+void horigin(int, long, Flayer *);
+void hgrow(int, long, long, int);
+int hdata(int, long, uchar*, int);
+int hdatarune(int, long, Rune*, int);
+Rune *rload(Rasp*, ulong, ulong, ulong*);
+void menuins(int, uchar*, Text*, int, int);
+void menudel(int);
+Text *sweeptext(int, int);
+void setpat(char*);
+void scrdraw(Flayer*, long tot);
+int rcontig(Rasp*, ulong, ulong, int);
+int rmissing(Rasp*, ulong, ulong);
+void rresize(Rasp *, long, long, long);
+void rdata(Rasp*, long, long, Rune*);
+void rclean(Rasp*);
+void scrorigin(Flayer*, int, long);
+long scrtotal(Flayer*);
+void flnewlyvisible(Flayer*);
+char *rcvstring(void);
+void Strcpy(Rune*, Rune*);
+void Strncpy(Rune*, Rune*, long);
+void flushtyping(int);
+void dumperrmsg(int, int, int, int);
+int screensize(int*,int*);
#include "../sam/mesg.h"
-void outTs(Tmesg, int);
-void outT0(Tmesg);
-void outTl(Tmesg, long);
-void outTslS(Tmesg, int, long, Rune*);
-void outTslll(Tmesg, int, long, long, long);
-void outTsll(Tmesg, int, long, long);
-void outTsl(Tmesg, int, long);
-void outTsv(Tmesg, int, void*);
-void outTv(Tmesg, void*);
-void outstart(Tmesg);
-void outcopy(int, uchar*);
-void outshort(int);
-void outlong(long);
-void outvlong(void*);
-void outsend(void);
+void outTs(Tmesg, int);
+void outT0(Tmesg);
+void outTl(Tmesg, long);
+void outTslS(Tmesg, int, long, Rune*);
+void outTslll(Tmesg, int, long, long, long);
+void outTsll(Tmesg, int, long, long);
+void outTsl(Tmesg, int, long);
+void outTsv(Tmesg, int, void*);
+void outTv(Tmesg, void*);
+void outstart(Tmesg);
+void outcopy(int, uchar*);
+void outshort(int);
+void outlong(long);
+void outvlong(void*);
+void outsend(void);
int getlayer(const Flayer *l, const Text *t);
diff --git a/samterm/scroll.c b/samterm/scroll.c
@@ -12,134 +12,134 @@ extern Mouse mouse;
Rectangle
scrpos(Rectangle r, long p0, long p1, long tot)
{
- long h;
- Rectangle q;
+ long h;
+ Rectangle q;
- q = inset(r, 1);
- h = q.max.y-q.min.y;
- if(tot == 0)
- return q;
- if(tot > 1024L*1024L)
- tot>>=10, p0>>=10, p1>>=10;
- if(p0 > 0)
- q.min.y += h*p0/tot;
- if(p1 < tot)
- q.max.y -= h*(tot-p1)/tot;
- if(q.max.y < q.min.y+2){
- if(q.min.y+2 <= r.max.y)
- q.max.y = q.min.y+2;
- else
- q.min.y = q.max.y-2;
- }
- return q;
+ q = inset(r, 1);
+ h = q.max.y-q.min.y;
+ if(tot == 0)
+ return q;
+ if(tot > 1024L*1024L)
+ tot>>=10, p0>>=10, p1>>=10;
+ if(p0 > 0)
+ q.min.y += h*p0/tot;
+ if(p1 < tot)
+ q.max.y -= h*(tot-p1)/tot;
+ if(q.max.y < q.min.y+2){
+ if(q.min.y+2 <= r.max.y)
+ q.max.y = q.min.y+2;
+ else
+ q.min.y = q.max.y-2;
+ }
+ return q;
}
void
scrflip(Flayer *l, Rectangle r)
{
- if(rectclip(&r, l->scroll))
- bitblt2(l->f.b, r.min, l->f.b, r, F&~D, 0, l->bg);
+ if(rectclip(&r, l->scroll))
+ bitblt2(l->f.b, r.min, l->f.b, r, F&~D, 0, l->bg);
}
void
scrdraw(Flayer *l, long tot)
{
- Rectangle r, r1, r2;
- Bitmap *b;
- static Bitmap *x;
- int h;
+ Rectangle r, r1, r2;
+ Bitmap *b;
+ static Bitmap *x;
+ int h;
- if(l->f.b == 0)
- panic("scrdraw");
- r = l->scroll;
- r.min.x += 1; /* border between margin and bar */
- r1 = r;
- if(l->visible == All){
- if(x == 0){
- if (screensize(0, &h) == 0)
- h = 2048;
- x = balloc(Rect(0, 0, 32, h), l->f.b->ldepth);
- if(x == 0)
- panic("scrdraw balloc");
- }
- b = x;
- r1.min.x = 0;
- r1.max.x = Dx(r);
- }else
- b = l->f.b;
- bitblt2(b, r1.min, b, r1, F, 0, l->bg);
- texture(b, inset(r1, 1), darkgrey, S);
- r2 = scrpos(r1, l->origin, l->origin+l->f.nchars, tot);
- bitblt2(b, r2.min, b, r2, 0, 0, l->bg);
- if(b!=l->f.b)
- bitblt2(l->f.b, r.min, b, r1, S, 0, l->bg);
+ if(l->f.b == 0)
+ panic("scrdraw");
+ r = l->scroll;
+ r.min.x += 1; /* border between margin and bar */
+ r1 = r;
+ if(l->visible == All){
+ if(x == 0){
+ if (screensize(0, &h) == 0)
+ h = 2048;
+ x = balloc(Rect(0, 0, 32, h), l->f.b->ldepth);
+ if(x == 0)
+ panic("scrdraw balloc");
+ }
+ b = x;
+ r1.min.x = 0;
+ r1.max.x = Dx(r);
+ }else
+ b = l->f.b;
+ bitblt2(b, r1.min, b, r1, F, 0, l->bg);
+ texture(b, inset(r1, 1), darkgrey, S);
+ r2 = scrpos(r1, l->origin, l->origin+l->f.nchars, tot);
+ bitblt2(b, r2.min, b, r2, 0, 0, l->bg);
+ if(b!=l->f.b)
+ bitblt2(l->f.b, r.min, b, r1, S, 0, l->bg);
}
void
scroll(Flayer *l, int pbut, int but)
{
- int in = 0, oin;
- long tot = scrtotal(l);
- Rectangle scr, r, s, rt;
- int x, y, my, oy, h;
- long p0;
+ int in = 0, oin;
+ long tot = scrtotal(l);
+ Rectangle scr, r, s, rt;
+ int x, y, my, oy, h;
+ long p0;
- s = inset(l->scroll, 1);
- x = s.min.x+FLSCROLLWID/2;
- scr = scrpos(l->scroll, l->origin, l->origin+l->f.nchars, tot);
- r = scr;
- y = scr.min.y;
- my = mouse.xy.y;
- do{
- oin = in;
- in = abs(x-mouse.xy.x)<=FLSCROLLWID/2;
- if(oin != in)
- scrflip(l, r);
- if(in){
- oy = y;
- my = mouse.xy.y;
- if(my < s.min.y)
- my = s.min.y;
- if(my >= s.max.y)
- my = s.max.y;
- if(!eqpt(mouse.xy, Pt(x, my)))
- cursorset(Pt(x, my));
- if(but == 1){
- p0 = l->origin-frcharofpt(&l->f, Pt(s.max.x, m…
- rt = scrpos(l->scroll, p0, p0+l->f.nchars, tot…
- y = rt.min.y;
- }else if(but == 2){
- y = my;
- if(y > s.max.y-2)
- y = s.max.y-2;
- }else if(but == 3){
- p0 = l->origin+frcharofpt(&l->f, Pt(s.max.x, m…
- rt = scrpos(l->scroll, p0, p0+l->f.nchars, tot…
- y = rt.min.y;
- }
- if(y != oy){
- scrflip(l, r);
- r = raddp(scr, Pt(0, y-scr.min.y));
- scrflip(l, r);
- }
- }
- }while(button(pbut));
- if(in){
- h = s.max.y-s.min.y;
- scrflip(l, r);
- p0 = 0;
- if(but == 1)
- p0 = (long)(my-s.min.y)/l->f.fheight+1;
- else if(but == 2){
- if(tot > 1024L*1024L)
- p0 = ((tot>>10)*(y-s.min.y)/h)<<10;
- else
- p0 = tot*(y-s.min.y)/h;
- }else if(but == 3){
- p0 = l->origin+frcharofpt(&l->f, Pt(s.max.x, my));
- if(p0 > tot)
- p0 = tot;
- }
- scrorigin(l, but, p0);
- }
+ s = inset(l->scroll, 1);
+ x = s.min.x+FLSCROLLWID/2;
+ scr = scrpos(l->scroll, l->origin, l->origin+l->f.nchars, tot);
+ r = scr;
+ y = scr.min.y;
+ my = mouse.xy.y;
+ do{
+ oin = in;
+ in = abs(x-mouse.xy.x)<=FLSCROLLWID/2;
+ if(oin != in)
+ scrflip(l, r);
+ if(in){
+ oy = y;
+ my = mouse.xy.y;
+ if(my < s.min.y)
+ my = s.min.y;
+ if(my >= s.max.y)
+ my = s.max.y;
+ if(!eqpt(mouse.xy, Pt(x, my)))
+ cursorset(Pt(x, my));
+ if(but == 1){
+ p0 = l->origin-frcharofpt(&l->f, Pt(s.max.x, my));
+ rt = scrpos(l->scroll, p0, p0+l->f.nchars, tot);
+ y = rt.min.y;
+ }else if(but == 2){
+ y = my;
+ if(y > s.max.y-2)
+ y = s.max.y-2;
+ }else if(but == 3){
+ p0 = l->origin+frcharofpt(&l->f, Pt(s.max.x, my));
+ rt = scrpos(l->scroll, p0, p0+l->f.nchars, tot);
+ y = rt.min.y;
+ }
+ if(y != oy){
+ scrflip(l, r);
+ r = raddp(scr, Pt(0, y-scr.min.y));
+ scrflip(l, r);
+ }
+ }
+ }while(button(pbut));
+ if(in){
+ h = s.max.y-s.min.y;
+ scrflip(l, r);
+ p0 = 0;
+ if(but == 1)
+ p0 = (long)(my-s.min.y)/l->f.fheight+1;
+ else if(but == 2){
+ if(tot > 1024L*1024L)
+ p0 = ((tot>>10)*(y-s.min.y)/h)<<10;
+ else
+ p0 = tot*(y-s.min.y)/h;
+ }else if(but == 3){
+ p0 = l->origin+frcharofpt(&l->f, Pt(s.max.x, my));
+ if(p0 > tot)
+ p0 = tot;
+ }
+ scrorigin(l, but, p0);
+ }
}
diff --git a/samterm/unix.c b/samterm/unix.c
@@ -11,18 +11,18 @@
#include <signal.h>
#ifdef APOLLO
-#define O_NONBLOCK O_NDELAY
+#define O_NONBLOCK O_NDELAY
#endif
-#if defined(UMIPS) || defined(SUNOS)
-#define atexit(p) /* sigh */
+#if defined(UMIPS) || defined(SUNOS)
+#define atexit(p) /* sigh */
#endif
char *exname = NULL;
static char *fallbacks[] = {
- "*scrollForwardR: true",
- "*geometry: 740x780",
- NULL
+ "*scrollForwardR: true",
+ "*geometry: 740x780",
+ NULL
};
extern int nofifo;
@@ -30,55 +30,55 @@ extern int nofifo;
void
getscreen(int argc, char **argv)
{
- int fd;
- Rectangle r;
+ int fd;
+ Rectangle r;
- signal(SIGINT, SIG_IGN);
- xtbinit(0, "Sam", &argc, argv, fallbacks);
- r = inset(screen.r, 4);
- bitblt(&screen, r.min, &screen, r, 0);
+ signal(SIGINT, SIG_IGN);
+ xtbinit(0, "Sam", &argc, argv, fallbacks);
+ r = inset(screen.r, 4);
+ bitblt(&screen, r.min, &screen, r, 0);
}
int
screensize(int *w, int *h)
{
- return scrpix(w,h);
+ return scrpix(w,h);
}
void
dumperrmsg(int count, int type, int count0, int c)
{
- uchar *cp;
- int i;
-
- cp = (uchar *) rcvstring();
- fprintf(stderr, "samterm: host mesg: count %d %ux %ux %ux %s...ignored…
- count, type, count0, c, cp);
- i = 0;
- while (*cp) {
- fprintf(stderr, "%x ", *cp);
- if (i++ >= 20) {
- fprintf(stderr, "\n");
- i = 0;
- }
- cp++;
- }
+ uchar *cp;
+ int i;
+
+ cp = (uchar *) rcvstring();
+ fprintf(stderr, "samterm: host mesg: count %d %ux %ux %ux %s...ignored\n",
+ count, type, count0, c, cp);
+ i = 0;
+ while (*cp) {
+ fprintf(stderr, "%x ", *cp);
+ if (i++ >= 20) {
+ fprintf(stderr, "\n");
+ i = 0;
+ }
+ cp++;
+ }
}
void
removeextern(void)
{
- if (exname) {
- (void)unlink(exname);
- exname = 0;
- }
+ if (exname) {
+ (void)unlink(exname);
+ exname = 0;
+ }
}
/*
- * some systems do not support non-blocking i/o on named pipes
- * or do not provide working POSIX interfaces to the pipes.
- * in that case, add the name of the system to the 'ifdef' that
- * disables the code at the beginning of the function.
- * The external 'B' command will not work.
+ * some systems do not support non-blocking i/o on named pipes
+ * or do not provide working POSIX interfaces to the pipes.
+ * in that case, add the name of the system to the 'ifdef' that
+ * disables the code at the beginning of the function.
+ * The external 'B' command will not work.
*/
void
@@ -87,76 +87,76 @@ extstart(void)
if (nofifo)
return;
-#ifndef NOFIFO
- extern char *machine;
- char *user;
- char *home;
- int fd;
- int flags;
-
- user = getuser();
- home = getenv("HOME");
-
- if (home == NULL)
- {
- return;
- }
-
- exname = (char *)alloc(4 + 6 + strlen(home) + 1 + strlen(user) + 1 + s…
- sprint(exname, "%s/.sam.%s", home, machine);
-
- /* Make the named pipe. */
- if (mkfifo(exname, 0600) == -1) {
- struct stat statb;
- extern int errno;
-
- if (errno != EEXIST || stat(exname, &statb) == -1)
- return;
-
- if (!S_ISFIFO(statb.st_mode)) {
- removeextern();
- if (mkfifo(exname, 0600) == -1)
- return;
- }
- }
-
- fd = open(exname, O_RDONLY | O_NONBLOCK);
- if (fd == -1) {
- removeextern();
- return;
- }
-
- /*
- * Turn off no-delay and provide ourselves as a lingering
- * writer so as not to get end of file on read.
+#ifndef NOFIFO
+ extern char *machine;
+ char *user;
+ char *home;
+ int fd;
+ int flags;
+
+ user = getuser();
+ home = getenv("HOME");
+
+ if (home == NULL)
+ {
+ return;
+ }
+
+ exname = (char *)alloc(4 + 6 + strlen(home) + 1 + strlen(user) + 1 + strle…
+ sprint(exname, "%s/.sam.%s", home, machine);
+
+ /* Make the named pipe. */
+ if (mkfifo(exname, 0600) == -1) {
+ struct stat statb;
+ extern int errno;
+
+ if (errno != EEXIST || stat(exname, &statb) == -1)
+ return;
+
+ if (!S_ISFIFO(statb.st_mode)) {
+ removeextern();
+ if (mkfifo(exname, 0600) == -1)
+ return;
+ }
+ }
+
+ fd = open(exname, O_RDONLY | O_NONBLOCK);
+ if (fd == -1) {
+ removeextern();
+ return;
+ }
+
+ /*
+ * Turn off no-delay and provide ourselves as a lingering
+ * writer so as not to get end of file on read.
*/
- flags = fcntl(fd, F_GETFL, 0);
- if (flags == -1 || fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) == -1
- || open(exname, O_WRONLY) == -1) {
- (void)close(fd);
- removeextern();
- return;
- }
-
- estart(Eextern, fd, 8192);
- atexit(removeextern);
+ flags = fcntl(fd, F_GETFL, 0);
+ if (flags == -1 || fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) == -1
+ || open(exname, O_WRONLY) == -1) {
+ (void)close(fd);
+ removeextern();
+ return;
+ }
+
+ estart(Eextern, fd, 8192);
+ atexit(removeextern);
#endif
}
/*
- * we have to supply a dummy exit function, because some vendors can't …
- * bothered to provide atexit(). we clean up the named pipes on a norm…
- * exit, but leave them laying around on abnormal exits.
+ * we have to supply a dummy exit function, because some vendors can't be
+ * bothered to provide atexit(). we clean up the named pipes on a normal
+ * exit, but leave them laying around on abnormal exits.
*/
void
exits(char *message)
{
- if (exname) {
- unlink(exname);
- exname = 0;
- }
- if (message == 0)
- exit (0);
- else
- exit(1);
+ if (exname) {
+ unlink(exname);
+ exname = 0;
+ }
+ if (message == 0)
+ exit (0);
+ else
+ exit(1);
}
You are viewing proxied material from vernunftzentrum.de. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.