Annotation of freem/src/routine.c, revision 1.3
1.1 snw 1: /*
1.3 ! snw 2: * $Id$
1.1 snw 3: * Routine buffer management
4: *
5: *
1.2 snw 6: * Author: Serena Willis <snw@coherent-logic.com>
1.1 snw 7: * Copyright (C) 1998 MUG Deutschland
1.3 ! snw 8: * Copyright (C) 2023, 2025 Coherent Logic Development LLC
1.1 snw 9: *
10: *
11: * This file is part of FreeM.
12: *
13: * FreeM is free software: you can redistribute it and/or modify
14: * it under the terms of the GNU Affero Public License as published by
15: * the Free Software Foundation, either version 3 of the License, or
16: * (at your option) any later version.
17: *
18: * FreeM is distributed in the hope that it will be useful,
19: * but WITHOUT ANY WARRANTY; without even the implied warranty of
20: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21: * GNU Affero Public License for more details.
22: *
23: * You should have received a copy of the GNU Affero Public License
24: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
25: *
1.3 ! snw 26: * $Log$
! 27: *
! 28: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
! 29: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 30: **/
31:
32: #include <string.h>
33: #include <errno.h>
34: #include <sys/types.h>
35:
36: #if !defined(__OpenBSD__) && !defined(__FreeBSD__)
37: # include <sys/timeb.h>
38: #endif
39:
40: #include <sys/ioctl.h>
41: #include <unistd.h>
42: #include <stdlib.h>
43: #include <ctype.h>
44:
45: #ifdef AMIGA68K
46: #include <sys/fcntl.h>
47: #endif
48:
49: #include "mpsdef.h"
50:
51: #include <time.h>
52:
53: #ifdef USE_SYS_TIME_H
54: #include <sys/time.h>
55: #endif
56:
57: #include "events.h"
58:
59: short rtn_get_offset(char *buf)
60: {
61: char *rp;
62: char *rc;
63: char *p;
64: char otag[256];
65: char ortn[256];
66: char oline[256];
67:
68: register int i = 0;
69: register int j = 0;
70: register int k = 0;
71:
72: int os = 0;
73:
74: stcpy (ortn, rou_name);
75:
76: rp = rouptr;
77: rc = roucur;
78:
79: stcnv_m2c (ortn);
80:
81: while (rp < rc) {
82:
83: i = 0;
84: for (p = rp + 1; p < rc && *p != EOL && *p != '\0'; p++) {
85: if (i < 256) {
86: oline[i++] = *p;
87: }
88: }
89: oline[i] = '\0';
90:
91: if (isalpha (oline[0]) || oline[0] == '%') {
92:
93: os = 0;
94: k = 0;
95:
96: for (j = 0; j < strlen (oline); j++) {
97:
98: switch (oline[j]) {
99:
100: case ' ':
101: case '(':
102: case ';':
103: case EOL:
104: otag[k] = '\0';
105:
106: break;
107:
108: default:
109: otag[k++] = oline[j];
110: }
111:
112: if (oline[j] == ' ' || oline[j] == '(' || oline[j] == ';' || oline[j] == EOL) break;
113: }
114: }
115: else {
116: os++;
117: }
118:
119: rp = p + 1;
120: }
121:
122: if (os) {
123: sprintf (buf, "%s+%d^%s\201", otag, os, ortn);
124: }
125: else {
126: sprintf (buf, "%s^%s\201", otag, ortn);
127: }
128:
129:
130: return TRUE;
131: }
132:
133: char *rtn_resolve(char *rou, char *tag, char *buf)
134: {
135: char superclass[255];
136:
137: if (rtn_has_tag (rou, tag)) {
138: strcpy (buf, rou);
139: return buf;
140: }
141: else {
142: if (rtn_get_superclass (rou, superclass)) {
143: return rtn_resolve (superclass, tag, buf);
144: }
145: else {
146: buf = NULL;
147: return NULL;
148: }
149: }
150:
151: }
152:
153: short rtn_get_superclass(char *rou, char *buf)
154: {
155: FILE *fp;
156: char pth[PATHLEN];
157: char line[255];
158: char *s;
159: short rtn_exists;
160: short after_parens;
161: short found_super;
162: char *p;
163: register char ch;
164:
165: if (strcmp (rou, "%OBJECT") == 0) {
166: buf = NULL;
167: return FALSE;
168: }
169:
170: rtn_exists = rtn_get_path (rou, pth);
171:
172: if (rtn_exists == FALSE) {
173: buf = NULL;
174: return FALSE;
175: }
176:
177: fp = fopen (pth, "r");
178: if (fp == NULL) {
179: buf = NULL;
180: return FALSE;
181: }
182:
183: s = fgets (line, 255, fp);
184:
185: fclose (fp);
186:
187: if (s == NULL) {
188: buf = NULL;
189: return FALSE;
190: }
191:
192: if ((!isalpha (line[0])) && (line[0] != '%')) {
193: buf = NULL;
194: return FALSE;
195: }
196:
197: p = line;
198: after_parens = FALSE;
199: found_super = FALSE;
200:
201: while ((ch = *p++) != '\0') {
202:
203: if (ch == ')') after_parens = TRUE;
204:
205: if (ch == ':' && after_parens == TRUE) {
206: strcpy (buf, p);
207: found_super = TRUE;
208: break;
209: }
210:
211: }
212:
213: if (!found_super) {
214: sprintf (buf, "%%OBJECT");
215: return TRUE;
216: }
217:
218: p = buf;
219: for (;;) {
220: ch = *p;
221:
222: if (ch == SP || ch == TAB || ch == ';' || ch == '\0' || ch == '\r' || ch == '\n') {
223: *p = '\0';
224: break;
225: }
226:
227: p++;
228: }
229:
230: return TRUE;
231: }
232:
233: short rtn_get_path(char *rou, char *buf)
234: {
235: FILE *fp;
236: char pth[PATHLEN];
237:
238: if (rou[0] == '%') {
239: stcpy (pth, rou0plib);
240: stcnv_m2c (pth);
241: }
242: else {
243: stcpy (pth, rou0path);
244: stcnv_m2c (pth);
245: }
246:
247: snprintf (buf, PATHLEN, "%s/%s.m", pth, rou);
248:
249: if ((fp = fopen (buf, "r")) != NULL) {
250: (void) fclose (fp);
251:
252: return TRUE;
253: }
254: else {
255: return FALSE;
256: }
257:
258: }
259:
260: short rtn_has_tag(char *rou, char *tag)
261: {
262: m_entry *entries;
263: m_entry *e;
264:
265: entries = rtn_get_entries (rou);
266:
267: for (e = entries; e != NULL; e = e->next) {
268: if (strcmp (tag, e->tag) == 0) {
269: rtn_free_entries (entries);
270: return TRUE;
271: }
272: }
273:
274: rtn_free_entries (entries);
275: return FALSE;
276: }
277:
278: void rtn_free_entries(m_entry *head)
279: {
280: m_entry *tmp;
281:
282: while (head != NULL) {
283: tmp = head;
284: head = head->next;
285: free (tmp);
286: }
287:
288: head = NULL;
289: }
290:
291: m_entry *rtn_get_entries(char *rou)
292: {
293: FILE *fp;
294: char rou_path[PATHLEN];
295: m_entry *head = NULL;
296: m_entry *t;
297: register char ch;
298: register int i = 0;
299: register int j = 0;
300: char cur_line[255];
301: char cur_label[255];
302: int has_args = 0;
303: char *paren_pos;
304: char *curarg;
305:
306: if (rtn_get_path (rou, rou_path) == FALSE) {
307: return (m_entry *) NULL;
308: }
309:
310: fp = fopen (rou_path, "r");
311:
312: while (fgets (cur_line, 255, fp) != NULL) {
313:
314: if (isalpha (cur_line[0]) || cur_line[0] == '%') {
315: has_args = 0;
316: j = 0;
317:
318: for (i = 0; i < strlen (cur_line); i++) {
319: ch = cur_line[i];
320:
321: switch (ch) {
322:
323: case ')':
324: cur_label[j++] = ')';
325:
326: case SP:
327: case TAB:
328: case EOL:
329: cur_label[j] = '\0';
330: j = 0;
331: if (strlen (cur_label)) {
332: t = (m_entry *) malloc (sizeof (m_entry));
333: NULLPTRCHK(t,"rtn_get_entries");
334:
335: paren_pos = strchr (cur_label, '(');
336: if (paren_pos == NULL) {
337: /* not a formallist */
338: t->tag = (char *) malloc (sizeof (char) * (strlen (cur_label) + 1));
339: NULLPTRCHK(t->tag,"rtn_get_entries");
340:
341: strcpy (t->tag, cur_label);
342: }
343: else {
344: /* a formallist */
345: char *toktmp;
346:
347: toktmp = strdup (cur_label);
348: NULLPTRCHK(toktmp,"rtn_get_entries");
349:
350: (void) strtok (toktmp, "(");
351:
352: t->tag = malloc (sizeof (char) * (strlen (toktmp) + 1));
353: NULLPTRCHK(t->tag,"rtn_get_entries");
354:
355: strcpy (t->tag, toktmp);
356:
357: free (toktmp);
358: }
359:
360: t->next = head;
361: head = t;
362: }
363: break;
364:
365: case '(':
366: has_args++;
367: default:
368: cur_label[j++] = ch;
369: }
370:
371: if (ch == SP || ch == TAB || ch == EOL) break;
372: }
373: }
374: }
375:
376: fclose (fp);
377: return head;
378:
379: }
380:
381: void zload (char *rou) /* load routine in buffer */
382: {
383: FILE *infile;
384: short linelen;
385: char pgm[256];
386: char tmp1[256];
387:
388: register long int i;
389: register long int j;
390: register long int ch;
391:
392: char *savptr; /* save routine pointer */
393: long timex;
394: short altern = 0;
395:
396: /* Routines are stored in routine buffers. If a routine is called
397: * we first look whether it's already loaded. If not, we look for
398: * the least recently used buffer and load it there. Besides
399: * dramatically improved performance there is little effect on
400: * the user. Sometimes you see an effect: if the program is changed
401: * by some other user or by yourself using the 'ced' editor you
402: * may get the old version for some time with DO, GOTO or ZLOAD.
403: * A ZREMOVE makes sure the routine is loaded from disk.
404: */
405: if (*rou == EOL || *rou == 0) { /* routine name empty */
406:
407: pgms[0][0] = EOL;
408: rouend = rouins = rouptr = buff;
409: roucur = buff + (NO_OF_RBUF * PSIZE0 + 1);
410:
411: *rouptr = EOL;
412: *(rouptr + 1) = EOL;
413: *(rouptr + 2) = EOL;
414:
415: dosave[0] = 0;
416:
417: return;
418:
419: }
420:
421: savptr = rouptr;
422:
423: /* what time is it ? */
424: timex = time (0L);
425:
426: /* FreeM: it takes a lickin' and keeps on tickin' */
427:
428: /* let's have a look whether we already have the stuff */
429: for (i = 0; i < NO_OF_RBUF; i++) {
430:
431: if (pgms[i][0] == 0) {
432: altern = i;
433: break;
434: } /* buffer empty */
435:
436: j = 0;
437:
438: while (rou[j] == pgms[i][j]) {
439:
440: if (rou[j++] == EOL) {
441:
442: rouptr = buff + (i * PSIZE0);
443: ages[i] = time (0L);
444: rouend = ends[i];
445: rouins = rouend - 1;
446:
447: return;
448:
449: }
450:
451: }
452:
453: if (ages[i] <= timex) timex = ages[altern = i];
454:
455: }
456:
457: /* clear DO-label stored under FOR */
458: dosave[0] = 0;
459: j = 0;
460: ch = EOL; /* init for multiple path search */
461: tmp1[0] = EOL;
462:
463:
464: nextpath: /* entry point for retry */
465:
466: i = 0;
467:
468: if (rou[0] == '%') { /* %_routines are in special directory */
469:
470: if (mcmnd >= 'a') { /* DO GOTO JOB */
471:
472: if (rou0plib[j] != EOL) {
473: while ((ch = pgm[i++] = rou0plib[j++]) != ':' && ch != EOL);
474: }
475:
476: }
477: else if (rou1plib[j] != EOL) {
478: while ((ch = pgm[i++] = rou1plib[j++]) != ':' && ch != EOL);
479: }
480:
481: }
482: else {
483:
484: if (mcmnd >= 'a') { /* DO GOTO JOB */
485:
486: if (rou0path[j] != EOL) {
487: while ((ch = pgm[i++] = rou0path[j++]) != ':' && ch != EOL);
488: }
489:
490: }
491: else if (rou1path[j] != EOL) {
492: while ((ch = pgm[i++] = rou1path[j++]) != ':' && ch != EOL);
493: }
494:
495: }
496:
497: if (i > 0) {
498:
499: if (i == 1 || (i == 2 && pgm[0] == '.')) {
500: i = 0;
501: }
502: else {
503: pgm[i - 1] = '/';
504: }
505:
506: }
507:
508: pgm[i] = EOL;
509:
510: stcpy (tmp1, pgm); /* directory where we search for the routine */
511: stcpy (&pgm[i], rou);
512:
513: rouptr = buff + (altern * PSIZE0);
514:
515: stcat (pgm, rou_ext);
516:
517: pgm[stlen (pgm)] = NUL; /* append routine extension */
518:
519: if ((infile = fopen (pgm, "r")) == NULL) {
520:
521: rouptr = savptr;
522:
523: if (ch != EOL) goto nextpath; /* try next access path */
524:
525: stcpy (varerr, rou);
526:
527: merr_raise (NOPGM);
528:
529: return;
530:
531: }
532:
533: again:
534:
535: linelen = 0;
536: savptr = rouend = rouptr;
537:
538: for (i = 1; i < (PSIZE0 - 1); i++) {
539:
540: *++rouend = ch = getc (infile);
541:
542: if (ch == LF || ch == EOF) {
543:
544: *rouend++ = EOL;
545: i++;
546: *savptr = i - linelen - 2;
547:
548: savptr = rouend;
549: linelen = i;
550:
551: if (ch == EOF) {
552:
553: fclose (infile);
554:
555: *rouend-- = EOL;
556: rouins = rouend - 1;
557: ends[altern] = rouend;
558: ages[altern] = time (0L);
559:
560: stcpy (pgms[altern], rou);
561: stcpy (path[altern], tmp1);
562:
563: rbuf_flags[altern].dialect = standard;
564: if (standard == D_FREEM) {
565: rbuf_flags[altern].standard = FALSE;
566: }
567: else {
568: rbuf_flags[altern].standard = TRUE;
569: }
570:
571: return;
572: }
573: }
574: }
575:
576: rouptr = savptr;
577:
578: if (autorsize) {
579:
580: while ((ch = getc (infile)) != EOF) {
581:
582: i++;
583:
584: if (ch == LF) i++;
585:
586: } /* how big? */
587:
588: i = ((i + 3) & ~01777) + 02000; /* round for full kB; */
589:
590: if (newrsize (i, NO_OF_RBUF) == 0) { /* try to get more routine space. */
591:
592: altern = 0;
593: ch = EOL;
594:
595: fseek (infile, 0L, 0);
596:
597: goto again;
598:
599: }
600:
601: }
602:
603: fclose (infile);
604:
605: goto pgmov;
606:
607: pgmov:
608:
609: /* program overflow error */
610: rouptr = rouins = rouend = savptr;
611: (*savptr++) = EOL;
612: *savptr = EOL;
613:
614: for (i = 0; i < NO_OF_RBUF; i++) {
615: ages[i] = 0;
616: pgms[i][0] = 0;
617: }
618:
619: pgms[i][0] = EOL;
620: rou_name[0] = EOL;
621: merr_raise (PGMOV);
622:
623: return;
624:
625: } /* end of zload() */
626:
627: void zsave (char *rou) /* save routine on disk */
628: {
629: register int i;
630: register int j;
631: register int ch;
632: char tmp[256];
633:
634: stcpy (tmp, rou); /* save name without path */
635:
636: /* look whether we know where the routine came from */
637:
638: if (zsavestrategy) { /* VIEW 133: remember ZLOAD directory on ZSAVE */
639:
640: for (i = 0; i < NO_OF_RBUF; i++) {
641:
642: if (pgms[i][0] == 0) break; /* buffer empty */
643:
644: j = 0;
645:
646: while (rou[j] == pgms[i][j]) {
647:
648: if (rou[j++] == EOL) {
649:
650: stcpy (rou, path[i]);
651: stcat (rou, tmp);
652:
653: j = 0;
654: ch = 1; /* init for multiple path search */
655:
656: goto try;
657:
658: }
659:
660: }
661:
662: }
663:
664: }
665:
666: /* not found */
667: j = 0;
668: ch = EOL; /* init for multiple path search */
669:
670:
671: nextpath: /* entry point for retry */
672:
673: if (tmp[0] == '%') {
674:
675: if (rou1plib[0] != EOL) {
676:
677: i = 0;
678:
679: while ((ch = rou[i++] = rou1plib[j++]) != ':' && ch != EOL);
680:
681: if (i == 1 || (i == 2 && rou[0] == '.')) {
682: i = 0;
683: }
684: else {
685: rou[i - 1] = '/';
686: }
687:
688: stcpy (&rou[i], tmp);
689:
690: }
691:
692: }
693: else {
694:
695: if (rou1path[0] != EOL) {
696:
697: i = 0;
698:
699: while ((ch = rou[i++] = rou1path[j++]) != ':' && ch != EOL);
700:
701: if (i == 1 || (i == 2 && rou[0] == '.')) {
702: i = 0;
703: }
704: else {
705: rou[i - 1] = '/';
706: }
707:
708: stcpy (&rou[i], tmp);
709:
710: }
711:
712: }
713:
714:
715: try:
716:
717: stcat (rou, rou_ext);
718: rou[stlen (rou)] = NUL; /* append routine extention */
719:
720: if (rouend <= rouptr) {
721: unlink (rou);
722: rou_name[0] = EOL;
723: }
724: else {
725: FILE *outfile;
726: char *i0;
727:
728: for (;;) {
729:
730: errno = 0;
731:
732: if ((outfile = fopen (rou, "w")) != NULL) break;
733:
734: if (errno == EINTR) continue; /* interrupt */
735:
736: if (errno == EMFILE || errno == ENFILE) {
737: close_all_globals ();
738: continue;
739: } /* free file_des */
740:
741: if (ch != EOL) goto nextpath; /* try next access path */
742:
743: merr_raise (PROTECT);
744: return;
745:
746: }
747:
748: i0 = rouptr;
749:
750: while (++i0 < (rouend - 1)) {
751:
752: if ((ch = (*(i0))) == EOL) {
753: ch = LF;
754: i0++;
755: }
756:
757: putc (ch, outfile);
758:
759: }
760:
761: if (ch != LF) putc (LF, outfile);
762:
763: fclose (outfile);
764:
765: }
766:
767: return;
768:
769: } /* end of zsave() */
770:
771: /* insert 'line' in routine at 'position' */
772: void zi (char *line, char *position)
773: {
774: short offset;
775: short label;
776: short i;
777: short i0;
778: short ch;
779: char *reg;
780: char *end;
781: char line0[256];
782:
783: if (rouend - rouptr + stlen (line) + 1 > PSIZE0) { /* sufficient space ??? */
784:
785: reg = buff;
786:
787: if (getrmore () == 0L) return; /* PGMOV */
788:
789: position += buff - reg;
790:
791: }
792:
793: label = TRUE;
794: i = 0;
795: i0 = 0;
796:
797: while ((ch = line[i]) != EOL) {
798:
799: if (label) {
800:
801: if (ch == SP) ch = TAB;
802:
803: if (ch == TAB) {
804: label = FALSE;
805: }
806: else if (ch == '(') {
807:
808: line0[i0++] = ch;
809: i++;
810:
811: while (((ch = line[i]) >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9') || ch == '%' || ch == ',') {
812: line0[i0++] = ch;
813: i++;
814: }
815:
816: if (ch != ')') {
817: merr_raise (ISYNTX);
818: return;
819: }
820:
821: line0[i0++] = ch;
822: i++;
823:
824: if ((ch = line[i]) != SP && ch != TAB) {
825: merr_raise (ISYNTX);
826: return;
827: }
828:
829: continue;
830:
831: }
832: else if ((ch < 'a' || ch > 'z') && (ch < 'A' || ch > 'Z') && (ch < '0' || ch > '9') && (ch != '%' || i)) {
833: merr_raise (ISYNTX);
834: return;
835: }
836:
837: line0[i0++] = ch;
838: i++;
839:
840: continue;
841:
842: }
843:
844: if (ch < SP || (ch >= DEL && (eightbit == FALSE))) {
845: merr_raise (ISYNTX);
846: return;
847: }
848:
849: line0[i0++] = ch;
850: i++;
851:
852: }
853:
854: if (label) {
855: merr_raise (ISYNTX);
856: return;
857: }
858:
859: line0[i0] = EOL;
860: offset = i0;
861:
862: if (offset > 0) {
863:
864: offset += 2;
865: end = rouend;
866: rouend += offset;
867:
868: if (roucur > position || roucur > end) roucur += offset;
869:
870: reg = rouend;
871:
872: while (position <= end) {
873: (*reg--) = (*end--);
874: }
875:
876: (*(position++)) = (UNSIGN (offset) - 2);
877:
878: reg = line0;
879:
880: while (((*(position++)) = (*(reg++))) != EOL);
881:
882: *(rouend + 1) = EOL;
883: *(rouend + 2) = EOL;
884:
885: for (i = 0; i < NO_OF_RBUF; i++) {
886:
887: if (rouptr == (buff + (i * PSIZE0))) {
888: ends[i] = rouend;
889: break;
890: }
891:
892: }
893:
894: }
895:
896: rouins = position;
897:
898: return;
899: } /* end of zi() */
900:
901: /*
902: * getraddress(char *a, short lvl):
903: *
904: * returns the 'canonical' address of the line at the specified DO/FOR/XEC level
905: *
906: * char *a (out param): pointer to the address of the line
907: * short lvl: process this level
908: *
909: */
910: void getraddress (char *a, short lvl)
911: {
912:
913: char *rcur; /* cursor into routine */
914: short f;
915: char tmp3[256];
916: char *j0;
917: char *j1;
918: short rlvl; /* lower level, where to find routine name */
919: register int i;
920: register int j;
921:
922: f = mcmnd;
923: mcmnd = 'd'; /* make load use standard-path */
924: rlvl = lvl;
925:
926: if (nestn[rlvl] == 0 && rlvl < nstx) rlvl++;
927:
928: if (nestn[rlvl]) zload (nestn[rlvl]);
929:
930: mcmnd = f;
931:
932: /* command on stack: 2 == DO_BLOCK; other: make uppercase */
933: i = nestc[lvl];
934:
935: if (i != '$') i = ((i == 2) ? 'd' : i - 32);
936:
937: a[0] = '(';
938: a[1] = i;
939: a[2] = ')';
940: a[3] = EOL; /* command */
941:
942: rcur = nestr[lvl] + rouptr; /* restore rcur */
943: j0 = (rouptr - 1);
944: j = 0;
945: tmp3[0] = EOL;
946:
947: j0++;
948:
949: if (rcur < rouend) {
950:
951: while (j0 < (rcur - 1)) {
952:
953: j1 = j0++;
954: j++;
955:
956: if ((*j0 != TAB) && (*j0 != SP)) {
957:
958: j = 0;
959:
960: while ((tmp3[j] = (*(j0++))) > SP) {
961:
962: if (tmp3[j] == '(') tmp3[j] = EOL;
963:
964: j++;
965:
966: }
967:
968: tmp3[j] = EOL;
969: j = 0;
970:
971: }
972:
973: j0 = j1;
974: j0 += (UNSIGN (*j1)) + 2;
975:
976: }
977:
978: }
979:
980: stcat (a, tmp3);
981:
982: if (j > 0) {
983:
984: i = stlen (a);
985: a[i++] = '+';
986:
987: intstr (&a[i], j);
988:
989: }
990:
991: if (nestn[rlvl]) {
992:
993: stcat (a, "^\201");
994: stcat (a, nestn[rlvl]);
995:
996: }
997: else if (rou_name[0] != EOL) {
998:
999: stcat (a, "^\201");
1000: stcat (a, rou_name);
1001:
1002: }
1003:
1004: f = mcmnd;
1005: mcmnd = 'd'; /* make load use standard-path */
1006:
1007: zload (rou_name);
1008:
1009: mcmnd = f;
1010:
1011: return;
1012:
1013: } /* end getraddress() */
1014:
1015: /* parse lineref and return pos.in routine */
1016: /* result: [pointer to] pointer to line */
1017: void lineref (char **adrr)
1018: {
1019: long offset;
1020: long j;
1021: char *reg;
1022: char *beg;
1023:
1024: while (*codptr == '@') { /* handle indirection */
1025:
1026: codptr++;
1027:
1028: expr (ARGIND);
1029:
1030: if (merr () > 0) return;
1031:
1032: stcat (argptr, codptr);
1033: stcpy (code, argptr);
1034:
1035: codptr = code;
1036:
1037: }
1038:
1039: offset = 0;
1040: beg = rouptr;
1041:
1042: if (*codptr == '+') {
1043:
1044: codptr++;
1045:
1046: expr (STRING);
1047:
1048: if (merr () > 0) return;
1049:
1050: if ((offset = intexpr (argptr)) <= 0) {
1051: *adrr = 0;
1052: return;
1053: }
1054:
1055: offset--;
1056:
1057: }
1058: else {
1059:
1060: expr (LABEL);
1061:
1062: if (merr () > 0) return;
1063:
1064: reg = beg;
1065:
1066: while (beg < rouend) {
1067:
1068: reg++;
1069:
1070: if ((*reg) != TAB && (*reg) != SP) {
1071:
1072: j = 0;
1073:
1074: while ((*reg) == varnam[j]) {
1075: reg++;
1076: j++;
1077: }
1078:
1079: if (((*reg) == TAB || (*reg) == SP || (*reg) == '(') && varnam[j] == EOL) break;
1080:
1081: }
1082:
1083: reg = (beg = beg + UNSIGN (*beg) + 2);
1084:
1085: }
1086:
1087: stcpy (varerr, varnam);
1088:
1089: varnam[0] = EOL;
1090: codptr++;
1091:
1092: if (*codptr == '+') {
1093:
1094: codptr++;
1095:
1096: expr (STRING);
1097:
1098: if (merr () > 0) return;
1099:
1100: offset = intexpr (argptr);
1101:
1102: }
1103:
1104: }
1105:
1106: if (offset < 0) {
1107:
1108: reg = rouptr;
1109:
1110: while (reg < beg) {
1111: reg += UNSIGN (*reg) + 2;
1112: offset++;
1113: }
1114:
1115: if (offset < 0) {
1116: *adrr = 0;
1117: return;
1118: }
1119:
1120: beg = rouptr;
1121:
1122: }
1123:
1124: while (offset-- > 0 && beg <= rouend) beg += UNSIGN (*beg) + 2;
1125:
1126: *adrr = beg;
1127:
1128: return;
1129: } /* end of lineref() */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to routine.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src