home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dev / ucb_logoppc / source / logodata.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-25  |  12.8 KB  |  589 lines
  1. /*
  2.  *      logodata.c      logo data management module             dvb
  3.  *
  4.  *    Copyright (C) 1993 by the Regents of the University of California
  5.  *
  6.  *      This program is free software; you can redistribute it and/or modify
  7.  *      it under the terms of the GNU General Public License as published by
  8.  *      the Free Software Foundation; either version 2 of the License, or
  9.  *      (at your option) any later version.
  10.  *  
  11.  *      This program is distributed in the hope that it will be useful,
  12.  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  *      GNU General Public License for more details.
  15.  *  
  16.  *      You should have received a copy of the GNU General Public License
  17.  *      along with this program; if not, write to the Free Software
  18.  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  */
  21.  
  22. #include "logo.h"
  23. #include "globals.h"
  24. #include <stdarg.h>
  25. #ifdef ibm
  26. #if !defined(__ZTC__) && !defined(_MSC_VER)
  27. #include <alloc.h>
  28. #endif
  29. #endif
  30.  
  31. char special_chars[] = " \t\n(\?\?\?\?\?\?\?+~)[]-*/=<>\"\\:;|\?";
  32.  
  33. #ifdef ecma
  34.  
  35. #include <ctype.h>
  36.  
  37. #define upper_p(ch)    (isupper((ch) & 0377))
  38. #define lower_p(ch)    (islower((ch) & 0377))
  39.  
  40. char ecma_array[128];
  41.  
  42. int ecma_size = sizeof(special_chars);
  43.  
  44. char ecma_set(int ch) {
  45.     ch &= 0377;
  46.     if (ch >= 128) return(ch);
  47.     return(ecma_array[ch]);
  48. }
  49.  
  50. char ecma_clear(int ch) {
  51.     ch &= 0377;
  52.     if (ch < ecma_begin || ch >= ecma_begin+sizeof(special_chars)) return(ch);
  53.     if (ch >= 007 && ch <= 015) return(ch);
  54.     return(special_chars[ch - ecma_begin]);
  55. }
  56.  
  57. int ecma_get(int ch) {
  58.     ch &= 0377;
  59.     return ((ch >= ecma_begin && ch < ecma_begin+sizeof(special_chars))
  60.         && (ch < 007 || ch > 015));
  61. }
  62.  
  63. #else
  64.  
  65. #define upper_p(c)     (c >= 'A' && c <= 'Z')
  66. #define lower_p(c)     (c >= 'a' && c <= 'z')
  67.  
  68. #endif
  69.  
  70. char *strnzcpy(char *s1, char *s2, int n) {
  71.     strncpy(s1, s2, n);
  72.     s1[n] = '\0';
  73.     return(s1);
  74. }
  75.  
  76. char *word_strnzcpy(char *s1, NODE *kludge, int n) {  /* KLUDGE! */
  77.     char *temp = s1;
  78.  
  79.     while (kludge != NIL) {
  80.     strncpy(s1, getstrptr(car(kludge)), getstrlen(car(kludge)));
  81.     s1 += getstrlen(car(kludge));
  82.     kludge = cdr(kludge);
  83.     }
  84.     temp[n] = '\0';
  85.     return(temp);
  86. }
  87.  
  88. char *noparity_strnzcpy(char *s1, char *s2, int n) {
  89.     int i;
  90.  
  91.     for (i = 0; i < n; i++)
  92.     s1[i] = clearparity(s2[i]);
  93.     s1[n] = '\0';
  94.     return(s1);
  95. }
  96.  
  97. char *mend_strnzcpy(char *s1, char *s2, int n) {
  98.     int i, vbar = 0;
  99.  
  100.     for (i = 0; i < n; ) {
  101.     while (*s2 == '|') {
  102.         vbar = !vbar;
  103.         s2++;
  104.     }
  105.     if (vbar) {
  106.         if (strchr(special_chars,(int)*s2))
  107.         s1[i++] = setparity(*s2++);
  108.         else
  109.         s1[i++] = *s2++;
  110.     } else {
  111.         while (*s2 == ';' || (*s2 == '~' && *(s2 + 1) == '\n')) {
  112.         while (*s2 == '~' && *(s2 + 1) == '\n') s2 += 2;
  113.         if (*s2 == ';')
  114.             do {
  115.             s2++;
  116.             } while (*s2 != '\0' && *s2 != '~' && *(s2 + 1) != '\n');
  117.         }
  118.         if (*s2 != '|') s1[i++] = *s2++;
  119.     }
  120.     }
  121.     s1[n] = '\0';
  122.     return(s1);
  123. }
  124.  
  125. char *mend_nosemi(char *s1, char *s2, int n) {
  126.     int i, vbar = 0;
  127.  
  128.     for (i = 0; i < n; ) {
  129.     while (*s2 == '|') {
  130.         vbar = !vbar;
  131.         s2++;
  132.     }
  133.     if (vbar) {
  134.         if (strchr(special_chars,(int)*s2))
  135.         s1[i++] = setparity(*s2++);
  136.         else
  137.         s1[i++] = *s2++;
  138.     } else {
  139.         while ((*s2 == '~' && *(s2 + 1) == '\n')) {
  140.         while (*s2 == '~' && *(s2 + 1) == '\n') s2 += 2;
  141.         }
  142.         if (*s2 != '|') s1[i++] = *s2++;
  143.     }
  144.     }
  145.     s1[n] = '\0';
  146.     return(s1);
  147. }
  148.  
  149. char *quote_strnzcpy(char *s1, char *s2, int n) {
  150.     s1[0] = '"';
  151.     strncpy(s1 + 1, s2, n - 1);
  152.     s1[n] = '\0';
  153.     return(s1);
  154. }
  155.  
  156. char *colon_strnzcpy(char *s1, char *s2, int n) {
  157.     s1[0] = ':';
  158.     strncpy(s1 + 1, s2, n - 1);
  159.     s1[n] = '\0';
  160.     return(s1);
  161. }
  162.  
  163. #define uncapital(c)    ((c) - 'A' + 'a')
  164.  
  165. char *low_strnzcpy(char *s1, char *s2, int n) {
  166.     char *temp = s1;
  167.     int i;
  168.  
  169.     for (i = 0; i < n; i++) {
  170.     if (upper_p(*s2))
  171.         *s1++ = uncapital(*s2++);
  172.     else
  173.         *s1++ = *s2++;
  174.     }
  175.     *s1 = '\0';
  176.     return(temp);
  177. }
  178.  
  179. #define capital(c)    ((c) - 'a' + 'A')
  180.  
  181. char *cap_strnzcpy(char *s1, char *s2, int n) {
  182.     char *temp = s1;
  183.     int i;
  184.  
  185.     for (i = 0; i < n; i++) {
  186.     if (lower_p(*s2))
  187.         *s1++ = capital(*s2++);
  188.     else
  189.         *s1++ = *s2++;
  190.     }
  191.     *s1 = '\0';
  192.     return(temp);
  193. }
  194.  
  195. char *noparitylow_strnzcpy(char *s1, char *s2, int n) {
  196.     int i;
  197.     char c, *temp = s1;
  198.  
  199.     for (i = 0; i < n; i++) {
  200.     c = clearparity(*s2++);
  201.     if (upper_p(c))
  202.         *s1++ = uncapital(c);
  203.     else
  204.         *s1++ = c;
  205.     }
  206.     *s1 = '\0';
  207.     return(temp);
  208. }
  209.  
  210. int low_strncmp(char *s1, char *s2, int n) {
  211.     int i;
  212.  
  213.     for (i = 0; i < n; i++) {
  214.     if (*s1 != *s2) {
  215.         if (upper_p(*s2)) {
  216.         if (upper_p(*s1)) {
  217.             if (uncapital(*s1) != uncapital(*s2))
  218.             return(uncapital(*s1) - uncapital(*s2));
  219.         } else {
  220.             if (*s1 != uncapital(*s2))
  221.             return(*s1 - uncapital(*s2));
  222.         }
  223.         } else if (upper_p(*s1)) {
  224.         if (uncapital(*s1) != *s2)
  225.             return(uncapital(*s1) - *s2);
  226.         } else return(*s1 - *s2);
  227.     }
  228.     s1++, s2++;
  229.     }
  230.     return(0);
  231. }
  232.  
  233. int noparity_strncmp(char *s1, char *s2, int n) {
  234.     int i;
  235.  
  236.     for (i = 0; i < n; i++) {
  237.     if (clearparity(*s1) != clearparity(*s2))
  238.         return(clearparity(*s1) - clearparity(*s2));
  239.     s1++, s2++;
  240.     }
  241.     return(0);
  242. }
  243.  
  244. int noparitylow_strncmp(char *s1, char *s2, int n) {
  245.     int i;
  246.     char c1, c2;
  247.  
  248.     for (i = 0; i < n; i++) {
  249.     c1 = clearparity(*s1);
  250.     c2 = clearparity(*s2);
  251.     if (c1 != c2) {
  252.         if (upper_p(c2)) {
  253.         if (upper_p(c1)) {
  254.             if (uncapital(c1) != uncapital(c2))
  255.             return(uncapital(c1) - uncapital(c2));
  256.         } else {
  257.             if (c1 != uncapital(c2))
  258.             return(c1 - uncapital(c2));
  259.         }
  260.         } else if (upper_p(c1)) {
  261.         if (uncapital(c1) != c2)
  262.             return(uncapital(c1) - c2);
  263.         } else return(c1 - c2);
  264.     }
  265.     s1++, s2++;
  266.     }
  267.     return(0);
  268. }
  269.  
  270. NODE *make_strnode(char *strptr, struct string_block *strhead, int len,
  271.            NODETYPES typ, char *(*copy_routine)())
  272. {
  273.     NODE *strnode;
  274.  
  275.     if (len == 0 && Null_Word != NIL) return(Null_Word);
  276.     strnode = newnode(typ);
  277.     if (strhead == NULL) {
  278.     strhead = (struct string_block *) malloc((size_t)len + sizeof(FIXNUM) + 1);
  279.     if (strhead == NULL) {
  280.         err_logo(OUT_OF_MEM, NIL);
  281.         return UNBOUND;
  282.     }
  283.     (*copy_routine) (strhead->str_str, strptr, len);
  284.     strptr = strhead->str_str;
  285.     setstrrefcnt(strhead, 0);
  286.     }
  287.     setstrlen(strnode, len);
  288.     setstrptr(strnode, strptr);
  289.     setstrhead(strnode, strhead);
  290.     incstrrefcnt(strhead);
  291.     return(strnode);
  292. }
  293.  
  294. void make_runparse(NODE *ndi) {
  295.     NODE *rp_list;
  296.  
  297.     rp_list = runparse(ndi);
  298.     setobject(ndi, rp_list);
  299.     settype(ndi, RUN_PARSE);
  300. }
  301.  
  302. NODE *make_quote(NODE *qnd) {
  303.     NODE *nd;
  304.  
  305.     nd = cons(qnd, NIL);
  306.     settype(nd, QUOTE);
  307.     return(nd);
  308. }
  309.  
  310. NODE *maybe_quote(NODE *nd) {
  311.     if (nd == UNBOUND || aggregate(nd) || numberp(nd)) return(nd);
  312.     return(make_quote(nd));
  313. }
  314.  
  315. NODE *make_caseobj(NODE *cstrnd, NODE *obj) {
  316.     NODE *nd;
  317.  
  318.     nd = cons(cstrnd, obj);
  319.     settype(nd, CASEOBJ);
  320.     return(nd);
  321. }
  322.  
  323. NODE *make_colon(NODE *cnd) {
  324.     NODE *nd;
  325.  
  326.     nd = cons(cnd, NIL);
  327.     settype(nd, COLON);
  328.     return(nd);
  329. }
  330.  
  331. NODE *make_intnode(FIXNUM i) {
  332.     NODE *nd = newnode(INT);
  333.  
  334.     setint(nd, i);
  335.     return(nd);
  336. }
  337.  
  338. NODE *make_floatnode(FLONUM f) {
  339.     NODE *nd = newnode(FLOATT);
  340.  
  341.     setfloat(nd, f);
  342.     return(nd);
  343. }
  344.  
  345. NODE *cnv_node_to_numnode(NODE *ndi) {
  346.     NODE *val;
  347.     int dr;
  348.     char s2[MAX_NUMBER], *s = s2;
  349.  
  350.     if (is_number(ndi))
  351.     return(ndi);
  352.     ndi = cnv_node_to_strnode(ndi);
  353.     if (ndi == UNBOUND) return(UNBOUND);
  354.     if (((getstrlen(ndi)) < MAX_NUMBER) && (dr = numberp(ndi))) {
  355.     if (backslashed(ndi))
  356.         noparity_strnzcpy(s, getstrptr(ndi), getstrlen(ndi));
  357.     else
  358.         strnzcpy(s, getstrptr(ndi), getstrlen(ndi));
  359.     if (*s == '+') ++s;
  360.     if (s2[getstrlen(ndi)-1] == '.') s2[getstrlen(ndi)-1] = 0;
  361.     if (dr - 1 || getstrlen(ndi) > 9) {
  362.         val = newnode(FLOATT);
  363.         setfloat(val, atof(s));
  364.     } else {
  365.         val = newnode(INT);
  366.         setint(val, atol(s));
  367.     }
  368.     return(val);
  369.     } else {
  370.     return(UNBOUND);
  371.     }
  372. }
  373.  
  374. NODE *cnv_node_to_strnode(NODE *nd) {
  375.     char s[MAX_NUMBER];
  376.  
  377.     if (nd == UNBOUND || aggregate(nd)) {
  378.     return(UNBOUND);
  379.     }
  380.     switch(nodetype(nd)) {
  381.     case STRING:
  382.     case BACKSLASH_STRING:
  383.     case VBAR_STRING:
  384.         return(nd);
  385.     case CASEOBJ:
  386.         return strnode__caseobj(nd);
  387.     case QUOTE:
  388.         nd = cnv_node_to_strnode(node__quote(nd));
  389.         nd = make_strnode(getstrptr(nd), (struct string_block *)NULL,
  390.                   getstrlen(nd) + 1, nodetype(nd), quote_strnzcpy);
  391.         return(nd);
  392.     case COLON:
  393.         nd = cnv_node_to_strnode(node__colon(nd));
  394.         nd = make_strnode(getstrptr(nd), (struct string_block *)NULL,
  395.                   getstrlen(nd) + 1, nodetype(nd), colon_strnzcpy);
  396.         return(nd);
  397.     case INT:
  398.         sprintf(s, "%ld", getint(nd));
  399.         return(make_strnode(s, (struct string_block *)NULL,
  400.                 (int)strlen(s), STRING, strnzcpy));
  401.     case FLOATT:
  402.         sprintf(s, "%0.15g", getfloat(nd));
  403.         return(make_strnode(s, (struct string_block *)NULL,
  404.                 (int)strlen(s), STRING, strnzcpy));
  405.     }
  406.     /*NOTREACHED*/
  407. }
  408.  
  409. NODE *make_static_strnode(char *strptr) {
  410.     NODE *strnode = newnode(STRING);
  411.  
  412.     setstrptr(strnode, strptr);
  413.     setstrhead(strnode, NULL);
  414.     setstrlen(strnode, (int)strlen(strptr));
  415.     return(strnode);
  416. }
  417.  
  418. NODE *cons_list(int dummy, ...) {
  419.     va_list ap;
  420.     NODE *nptr, *outline = NIL, *lastnode = NIL, *val;
  421.  
  422.      va_start(ap, dummy);
  423.      while ( (nptr = va_arg(ap, NODE *)) != END_OF_LIST) {
  424.     val = cons(nptr, NIL);
  425.     if (outline == NIL) {
  426.         outline = val;
  427.         lastnode = outline;
  428.     } else {
  429.         setcdr(lastnode, val);
  430.         lastnode = val;
  431.     }
  432.      }
  433.     va_end(ap);
  434.     return(outline);
  435. }
  436.  
  437. NODE *make_array(int len) {
  438.     NODE *node;
  439.     NODE **data;
  440.  
  441.     node = newnode(ARRAY);
  442.     setarrorg(node,1);
  443.     setarrdim(node,len);
  444.     data = (NODE **)malloc((size_t)len * sizeof(NODE *));
  445.     if (data == NULL) {
  446.         err_logo(OUT_OF_MEM, NIL);
  447.     return UNBOUND;
  448.     }
  449.     setarrptr(node,data);
  450.     while (--len >= 0) *data++ = NIL;
  451.     return(node);
  452. }
  453.  
  454. NODE *llowercase(NODE *args) {
  455.     NODE *arg;
  456.  
  457.     arg = string_arg(args);
  458.     if (NOT_THROWING) {
  459.     return make_strnode(getstrptr(arg), (struct string_block *)NULL,
  460.                 getstrlen(arg), nodetype(arg), low_strnzcpy);
  461.     }
  462.     return UNBOUND;
  463. }
  464.  
  465. NODE *luppercase(NODE *args) {
  466.     NODE *arg;
  467.  
  468.     arg = string_arg(args);
  469.     if (NOT_THROWING) {
  470.     return make_strnode(getstrptr(arg), (struct string_block *)NULL,
  471.                 getstrlen(arg), nodetype(arg), cap_strnzcpy);
  472.     }
  473.     return UNBOUND;
  474. }
  475.  
  476. /* property list stuff */
  477.  
  478. NODE *getprop(NODE *plist, NODE *name, BOOLEAN before)
  479. {
  480.     NODE *prev = NIL;
  481.     BOOLEAN caseig = FALSE;
  482.  
  483.     if (compare_node(valnode__caseobj(Caseignoredp), True, TRUE) == 0)
  484.     caseig = TRUE;
  485.     while (plist != NIL) {
  486.     if (compare_node(name,car(plist),caseig) == 0) {
  487.         return(before ? prev : plist);
  488.     }
  489.     prev = plist;
  490.     plist = cddr(plist);
  491.     }
  492.     return(NIL);
  493. }
  494.  
  495. NODE *lgprop(NODE *args) {
  496.     NODE *plname, *pname, *plist, *val = NIL;
  497.  
  498.     plname = string_arg(args);
  499.     pname = string_arg(cdr(args));
  500.     if (NOT_THROWING) {
  501.     plname = intern(plname);
  502.     plist = plist__caseobj(plname);
  503.     if (plist != NIL)
  504.         val = getprop(plist, pname, FALSE);
  505.     if (val != NIL)
  506.         return cadr(val);
  507.     }
  508.     return NIL;
  509. }
  510.  
  511. NODE *lpprop(NODE *args) {
  512.     NODE *plname, *pname, *newval, *plist, *val = NIL;
  513.  
  514.     plname = string_arg(args);
  515.     pname = string_arg(cdr(args));
  516.     newval = car(cddr(args));
  517.     if (NOT_THROWING) {
  518.     plname = intern(plname);
  519.     if (flag__caseobj(plname, PLIST_TRACED)) {
  520.         ndprintf(writestream, "Pprop %s %s %s", maybe_quote(plname),
  521.              maybe_quote(pname), maybe_quote(newval));
  522.         if (ufun != NIL)
  523.         ndprintf(writestream, " in %s\n%s", ufun, this_line);
  524.         new_line(writestream);
  525.     }
  526.     plist = plist__caseobj(plname);
  527.     if (plist != NIL)
  528.         val = getprop(plist, pname, FALSE);
  529.     if (val != NIL)
  530.         setcar(cdr(val), newval);
  531.     else
  532.         setplist__caseobj(plname, cons(pname, cons(newval, plist)));
  533.     }
  534.     return(UNBOUND);
  535. }
  536.  
  537. NODE *lremprop(NODE *args) {
  538.     NODE *plname, *pname, *plist, *val = NIL;
  539.     BOOLEAN caseig = FALSE;
  540.  
  541.     if (compare_node(valnode__caseobj(Caseignoredp), True, TRUE) == 0)
  542.     caseig = TRUE;
  543.     plname = string_arg(args);
  544.     pname = string_arg(cdr(args));
  545.     if (NOT_THROWING) {
  546.     plname = intern(plname);
  547.     plist = plist__caseobj(plname);
  548.     if (plist != NIL) {
  549.         if (compare_node(car(plist), pname, caseig) == 0)
  550.         setplist__caseobj(plname, cddr(plist));
  551.         else {
  552.         val = getprop(plist, pname, TRUE);
  553.         if (val != NIL)
  554.             setcdr(cdr(val), cddr(cddr(val)));
  555.         }
  556.     }
  557.     }
  558.     return(UNBOUND);
  559. }
  560.  
  561. NODE *copy_list(NODE *arg) {
  562.     NODE *tnode, *lastnode = NIL, *val = NIL;
  563.  
  564.     while (arg != NIL) {
  565.     tnode = cons(car(arg), NIL);
  566.     arg = cdr(arg);
  567.     if (val == NIL) {
  568.         lastnode = val = tnode;
  569.     } else {
  570.         setcdr(lastnode, tnode);
  571.         lastnode = tnode;
  572.     }
  573.     }
  574.     return(val);
  575. }
  576.  
  577. NODE *lplist(NODE *args) {
  578.     NODE *plname, *plist, *val = NIL;
  579.  
  580.     plname = string_arg(args);
  581.     if (NOT_THROWING) {
  582.     plname = intern(plname);
  583.     plist = plist__caseobj(plname);
  584.     if (plist != NIL)
  585.         val = copy_list(plist);
  586.     }
  587.     return(val);
  588. }
  589.