tutil.c - plan9port - [fork] Plan 9 from user space
 (HTM) git clone git://src.adamsgaard.dk/plan9port
 (DIR) Log
 (DIR) Files
 (DIR) Refs
 (DIR) README
 (DIR) LICENSE
       ---
       tutil.c (2060B)
       ---
            1 #include <u.h>
            2 #include <libc.h>
            3 #include <draw.h>
            4 #include <thread.h>
            5 #include <cursor.h>
            6 #include <mouse.h>
            7 #include <keyboard.h>
            8 #include <frame.h>
            9 #include <fcall.h>
           10 #include "dat.h"
           11 #include "fns.h"
           12 
           13 void
           14 cvttorunes(char *p, int n, Rune *r, int *nb, int *nr, int *nulls)
           15 {
           16         uchar *q;
           17         Rune *s;
           18         int j, w;
           19 
           20         /*
           21          * Always guaranteed that n bytes may be interpreted
           22          * without worrying about partial runes.  This may mean
           23          * reading up to UTFmax-1 more bytes than n; the caller
           24          * knows this.  If n is a firm limit, the caller should
           25          * set p[n] = 0.
           26          */
           27         q = (uchar*)p;
           28         s = r;
           29         for(j=0; j<n; j+=w){
           30                 if(*q < Runeself){
           31                         w = 1;
           32                         *s = *q++;
           33                 }else{
           34                         w = chartorune(s, (char*)q);
           35                         q += w;
           36                 }
           37                 if(*s)
           38                         s++;
           39                 else if(nulls)
           40                                 *nulls = TRUE;
           41         }
           42         *nb = (char*)q-p;
           43         *nr = s-r;
           44 }
           45 
           46 void
           47 error(char *s)
           48 {
           49         fprint(2, "rio: %s: %r\n", s);
           50         if(errorshouldabort)
           51                 abort();
           52         threadexitsall("error");
           53 }
           54 
           55 void*
           56 erealloc(void *p, uint n)
           57 {
           58         p = realloc(p, n);
           59         if(p == nil)
           60                 error("realloc failed");
           61         return p;
           62 }
           63 
           64 void*
           65 emalloc(uint n)
           66 {
           67         void *p;
           68 
           69         p = malloc(n);
           70         if(p == nil)
           71                 error("malloc failed");
           72         memset(p, 0, n);
           73         return p;
           74 }
           75 
           76 char*
           77 estrdup(char *s)
           78 {
           79         char *p;
           80 
           81         p = malloc(strlen(s)+1);
           82         if(p == nil)
           83                 error("strdup failed");
           84         strcpy(p, s);
           85         return p;
           86 }
           87 
           88 int
           89 isalnum(Rune c)
           90 {
           91         /*
           92          * Hard to get absolutely right.  Use what we know about ASCII
           93          * and assume anything above the Latin control characters is
           94          * potentially an alphanumeric.
           95          */
           96         if(c <= ' ')
           97                 return FALSE;
           98         if(0x7F<=c && c<=0xA0)
           99                 return FALSE;
          100         if(utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c))
          101                 return FALSE;
          102         return TRUE;
          103 }
          104 
          105 Rune*
          106 strrune(Rune *s, Rune c)
          107 {
          108         Rune c1;
          109 
          110         if(c == 0) {
          111                 while(*s++)
          112                         ;
          113                 return s-1;
          114         }
          115 
          116         while(c1 = *s++)
          117                 if(c1 == c)
          118                         return s-1;
          119         return nil;
          120 }
          121 
          122 int
          123 min(int a, int b)
          124 {
          125         if(a < b)
          126                 return a;
          127         return b;
          128 }
          129 
          130 int
          131 max(int a, int b)
          132 {
          133         if(a > b)
          134                 return a;
          135         return b;
          136 }
          137 
          138 char*
          139 runetobyte(Rune *r, int n, int *ip)
          140 {
          141         char *s;
          142         int m;
          143 
          144         s = emalloc(n*UTFmax+1);
          145         m = snprint(s, n*UTFmax+1, "%.*S", n, r);
          146         *ip = m;
          147         return s;
          148 }