← Back to branch summary

~ubuntu-branches/ubuntu/saucy/ng/saucy

« back to all changes in this revision

Viewing changes to basic.c

  • Committer: Bazaar Package Importer
  • Author(s): Masayuki Hatta (mhatta)
  • Date: 2008-07-17 08:10:34 UTC
  • mfrom: (4.1.2 hardy)
  • Revision ID: james.westby@ubuntu.com-20080717081034-s7iitiihm9hl4jjg
Tags: 1.5~beta1-3
Bumped to Standards-Version: 3.8.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
basic.c
1
 
/* $Id: basic.c,v 1.1.1.1.2.1 2001/07/23 18:15:51 amura Exp $ */
 
1
/* $Id: basic.c,v 1.6.2.1 2003/03/08 01:22:35 amura Exp $ */
2
2
/*
3
3
 *              Basic cursor motion commands.
4
4
 *
11
11
 
12
12
/*
13
13
 * $Log: basic.c,v $
14
 
 * Revision 1.1.1.1.2.1  2001/07/23 18:15:51  amura
 
14
 * Revision 1.6.2.1  2003/03/08 01:22:35  amura
 
15
 * NOTAB is always enabled
 
16
 *
 
17
 * Revision 1.6  2001/05/25 15:36:51  amura
15
18
 * now buffers have only one mark (before windows have one mark)
16
19
 *
 
20
 * Revision 1.5  2001/04/28 18:54:26  amura
 
21
 * support line-number-mode (based on MATSUURA's patch )
 
22
 *
 
23
 * Revision 1.4  2001/02/18 17:07:23  amura
 
24
 * append AUTOSAVE feature (but NOW not work)
 
25
 *
 
26
 * Revision 1.3  2001/01/05 14:06:59  amura
 
27
 * first implementation of Hojo Kanji support
 
28
 *
 
29
 * Revision 1.2  2000/12/14 18:06:23  amura
 
30
 * filename length become flexible
 
31
 *
17
32
 * Revision 1.1.1.1  2000/06/27 01:47:55  amura
18
33
 * import to CVS
19
34
 *
52
67
{
53
68
        register LINE   *lp;
54
69
#ifdef  KANJI   /* 90.01.29  by S.Yoshida */
55
 
        register int    kanji2nd = FALSE;       /* Now on a KANJI 2nd byte. */
 
70
        register int    kanji2nd = 0;   /* Now on a KANJI 2nd byte. */
56
71
#endif  /* KANJI */
57
72
 
58
73
        if (n < 0) return forwchar(f, -n);
69
84
                } else {
70
85
#ifdef  KANJI   /* 90.01.29  by S.Yoshida */
71
86
                        if (kanji2nd) {
72
 
                                kanji2nd = FALSE;
 
87
                                kanji2nd--;
73
88
                        } else if (ISKANJI(lgetc(curwp->w_dotp,
74
89
                                                 curwp->w_doto - 1))) {
75
 
                                kanji2nd = TRUE;
 
90
#ifdef  HOJO_KANJI
 
91
                                if (ISHOJO(lgetc(curwp->w_dotp,
 
92
                                                 curwp->w_doto - 2)))
 
93
                                        kanji2nd = 2;
 
94
                                else
 
95
#endif  /* HOJO_KANJI */
 
96
                                kanji2nd = 1;
76
97
                        }
77
98
#endif  /* KANJI */
78
99
                        curwp->w_doto--;
80
101
        }
81
102
#ifdef  KANJI   /* 90.01.29  by S.Yoshida */
82
103
        if (kanji2nd) {                 /* When stop at KANJI 2nd byte. */
83
 
                if (curwp->w_doto == 0) { /* This is illegal, but... */
 
104
                if (
 
105
#ifdef  HOJO_KANJI
 
106
                    (kanji2nd==2 && curwp->w_doto == 1) ||
 
107
#endif
 
108
                    curwp->w_doto == 0) { /* This is illegal, but... */
84
109
                        if ((lp=lback(curwp->w_dotp)) == curbp->b_linep) {
85
110
                                if (!(f & FFRAND))
86
111
                                        ewprintf("Beginning of buffer");
90
115
                        curwp->w_doto  = llength(lp);
91
116
                        curwp->w_flag |= WFMOVE;
92
117
                } else {                /* Go back KANJI 1st byte.      */
93
 
                        curwp->w_doto--;
 
118
                        curwp->w_doto -= kanji2nd;
94
119
                }
95
120
        }
96
121
#endif  /* KANJI */
124
149
register int n;
125
150
{
126
151
#ifdef  KANJI   /* 90.01.29  by S.Yoshida */
127
 
        register int    kanji2nd = FALSE;       /* Now on a KANJI 2nd byte. */
 
152
        register int    kanji2nd = 0;           /* Now on a KANJI 2nd byte. */
128
153
        register int    oldn = n;
129
154
#endif  /* KANJI */
130
155
        if (n < 0) return backchar(f, -n);
142
167
                } else {
143
168
#ifdef  KANJI   /* 90.01.29  by S.Yoshida */
144
169
                        if (kanji2nd) {
145
 
                                kanji2nd = FALSE;
 
170
                                kanji2nd--;
 
171
#ifdef  HOJO_KANJI
 
172
                        } else if (ISHOJO(lgetc(curwp->w_dotp,
 
173
                                                curwp->w_doto))) {
 
174
                                kanji2nd = 2;
 
175
#endif  /* HOJO_KANJI */
146
176
                        } else if (ISKANJI(lgetc(curwp->w_dotp,
147
177
                                                 curwp->w_doto))) {
148
 
                                kanji2nd = TRUE;
 
178
                                kanji2nd = 1;
149
179
                        }
150
180
#endif  /* KANJI */
151
181
                        curwp->w_doto++;
154
184
#ifdef  KANJI   /* 90.01.29  by S.Yoshida */
155
185
        if (kanji2nd) {                 /* When stop at KANJI 2nd byte. */
156
186
                if (oldn == 1) {        /* Special case. Go to next char. */
157
 
                        curwp->w_doto++;
 
187
                        curwp->w_doto += kanji2nd;
158
188
                } else {                /* Go back KANJI 1st byte.      */
159
189
                        curwp->w_doto--;
 
190
#ifdef  HOJO_KANJI
 
191
                        if (ISHOJO(lgetc(curwp->w_dotp, curwp->w_doto)))
 
192
                                curwp->w_doto--;
 
193
#endif
160
194
                }
161
195
        }
162
196
#endif  /* KANJI */
201
235
nextline(f, n)
202
236
{
203
237
        register int    s;
204
 
        char    buf[NFILEN];
 
238
        char    buf[NINPUT];
205
239
 
206
240
        if ((f & FFARG) == 0) {
207
 
                if ((s = ereply("next-line-add-newlines : ", buf, NFILEN)) != TRUE)
 
241
                if ((s = ereply("next-line-add-newlines : ", buf, sizeof(buf))) != TRUE)
208
242
                        return (s);
209
243
                if (ISDIGIT(buf[0]) || buf[0] == '-')
210
244
                        n = atoi(buf) > 0;
217
251
}
218
252
#endif  /* NEXTLINE */
219
253
 
 
254
 
 
255
#ifdef  ADDFUNC
 
256
int line_number_mode = FALSE;
 
257
 
 
258
linenumbermode(f, n)
 
259
{
 
260
    register int s;
 
261
    register WINDOW *wp;
 
262
    char        buf[NINPUT];
 
263
 
 
264
    if ((f & FFARG) == 0) {
 
265
        if ((s = ereply("line-number-mode : ", buf, sizeof(buf))) != TRUE)
 
266
            return (s);
 
267
        if (ISDIGIT(buf[0]) || buf[0] == '-')
 
268
            n = (atoi(buf) > 0);
 
269
        else if (buf[0] == 't' || buf[0] == 'T')
 
270
            n = TRUE;
 
271
        else
 
272
            n = FALSE;
 
273
        }
 
274
    line_number_mode = n;
 
275
    for (wp=wheadp; wp!=NULL; wp=wp->w_wndp)
 
276
        wp->w_flag |= WFMODE;
 
277
    return (TRUE);
 
278
}
 
279
#endif
 
280
 
220
281
/*
221
282
 * Move forward by full lines.
222
283
 * If the number of lines to move is less
261
322
                warnreadonly();            /* do only displaying warning.  */
262
323
            } else {
263
324
#endif  /* READONLY */
 
325
#ifdef  AUTOSAVE        /* 96.12.25 by M.Suzuki */
 
326
                curbp->b_flag |= BFACHG;
 
327
#endif  /* AUTOSAVE */
264
328
                if(!(curbp->b_flag&BFCHG)) {    /* first change */
265
329
                        curbp->b_flag |= BFCHG;
266
330
                        curwp->w_flag |= WFMODE;
287
351
                curwp->w_doto  = getgoal(dlp);
288
352
        }
289
353
#ifdef ADDFUNC          /* amura */
 
354
        if (line_number_mode)
 
355
            curwp->w_flag |= WFHARD;
290
356
# ifdef BUGFIX
291
357
        return n>0 ? FALSE : TRUE;
292
358
# else
320
386
        curwp->w_doto  = getgoal(dlp);
321
387
        curwp->w_flag |= WFMOVE;
322
388
#ifdef ADDFUNC          /* amura */
 
389
        if (line_number_mode)
 
390
            curwp->w_flag |= WFHARD;
323
391
        return n >= 0 ? FALSE : TRUE;
324
392
#else
325
393
        return TRUE;
364
432
        while (dbo != llength(dlp)) {
365
433
                c = lgetc(dlp, dbo);
366
434
                newcol = col;
367
 
                if (c == '\t'
368
 
#ifdef  NOTAB
369
 
                                && !(curbp->b_flag & BFNOTAB)
370
 
#endif
371
 
                        )
 
435
#ifdef  HOJO_KANJI
 
436
                if (ISHOJO(c) && !kanji2nd) {
 
437
                        dbo++;
 
438
                        continue;
 
439
                }
 
440
#endif  /* HOJO_KANJI */
 
441
                if (c == '\t' && !(curbp->b_flag & BFNOTAB))
372
442
#ifdef VARIABLE_TAB
373
443
                    newcol = (newcol/tab + 1)*tab -1;
374
444
#else
377
447
                else if (ISCTRL(c) != FALSE)
378
448
                        ++newcol;
379
449
#ifdef HANKANA  /* 92.11.21  by S.Sasaki */
380
 
                else if ( (c & 0xff) == SS2 && !kanji2nd )
381
 
                        --newcol; 
 
450
                else if (ISHANKANA(c) && !kanji2nd)
 
451
                        --newcol;
382
452
#endif  /* HANKANA */
383
453
                ++newcol;
384
454
                if (newcol > curgoal)
576
646
        register LINE   *odotp;
577
647
        register int    odoto;
578
648
        BUFFER          *bp = curwp->w_bufp;
579
 
  
 
649
 
580
650
        if (bp->b_markp == NULL) {
581
651
                ewprintf("No mark in this buffer");
582
652
                return FALSE;
604
674
{
605
675
        register LINE   *clp;
606
676
        register int    s;
607
 
        char            buf[32];
 
677
        char            buf[NINPUT];
608
678
 
609
679
        if (!(f & FFARG)) {
610
680
                if ((s=ereply("Goto line: ", buf, sizeof(buf))) != TRUE)