syntax.c

   1 /*
   2  * Copyright (C) 2010 Diego Hernan Borghetti.
   3  * Eco
   4  */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <ctype.h>
  10
  11 #include "debug.h"
  12 #include "list.h"
  13 #include "term.h"
  14 #include "screen.h"
  15 #include "syntax.h"
  16
  17
  18 /* our syntax data base. */
  19 static E_List syntaxs= { NULL, NULL };
  20
  21 static E_Syntax_Word *e_syntax_word_search(E_Syntax *sy, char *word, int nch)
  22 {
  23         E_Syntax_Word *p;
  24
  25         p= (E_Syntax_Word *)sy->dirs.first;
  26         while (p) {
  27                 if (p->nch == nch) {
  28                         if (!strncmp(p->word, word, nch))
  29                                 return(p);
  30                 }
  31                 p= p->next;
  32         }
  33
  34         return(NULL);
  35 }
  36
  37 static E_Syntax_Char *e_syntax_char_search(E_Syntax *sy, char ch)
  38 {
  39         E_Syntax_Char *p;
  40
  41         p= (E_Syntax_Char *)sy->chars.first;
  42         while (p) {
  43                 if (p->ch == ch)
  44                         return(p);
  45                 p= p->next;
  46         }
  47         return(NULL);
  48 }
  49
  50 E_Syntax *e_syntax_search(char *ext)
  51 {
  52         E_Syntax *p;
  53
  54         p= (E_Syntax *)syntaxs.first;
  55         while (p) {
  56                 if ((*p->check_type)(ext) == 0)
  57                         return(p);
  58                 p= p->next;
  59         }
  60         return(NULL);
  61 }
  62
  63 void e_syntax_add(E_Syntax *sy)
  64 {
  65         if (sy) {
  66                 E_LIST_ADD(&syntaxs, sy);
  67         }
  68 }
  69
  70 void e_syntax_rem(E_Syntax *sy)
  71 {
  72         if (sy) {
  73                 E_LIST_REM(&syntaxs, sy);
  74         }
  75 }
  76
  77 E_Syntax *e_syntax_new(void)
  78 {
  79         E_Syntax *sy;
  80
  81         sy= (E_Syntax *)malloc(sizeof(E_Syntax));
  82         sy->next= NULL;
  83         sy->prev= NULL;
  84         sy->name= NULL;
  85         sy->check_type= NULL;
  86         sy->dirs.first= NULL;
  87         sy->dirs.last= NULL;
  88         sy->chars.first= NULL;
  89         sy->chars.last= NULL;
  90         return(sy);
  91 }
  92
  93 void e_syntax_free(E_Syntax *sy)
  94 {
  95         E_Syntax_Word *p;
  96
  97         while (sy->dirs.first) {
  98                 p= (E_Syntax_Word *)sy->dirs.first;
  99                 sy->dirs.first= sy->dirs.first->next;
 100                 free((void *)p->word);
 101                 free((void *)p);
 102         }
 103
 104         if (sy->name)
 105                 free((void *)sy->name);
 106
 107         free((void *)sy);
 108 }
 109
 110 void e_syntax_word_add(E_Syntax *sy, char *word, char fg, char bg)
 111 {
 112         E_Syntax_Word *wr;
 113
 114         wr= e_syntax_word_search(sy, word, strlen(word));
 115         if (wr)
 116                 return;
 117
 118         wr= (E_Syntax_Word *)malloc(sizeof(E_Syntax_Word));
 119         wr->next= NULL;
 120         wr->prev= NULL;
 121         wr->word= strdup(word);
 122         wr->nch= strlen(wr->word);
 123         wr->fgcol= fg;
 124         wr->bgcol= bg;
 125         E_LIST_ADD(&sy->dirs, wr);
 126 }
 127
 128 void e_syntax_char_add(E_Syntax *sy, char ch, char fg, char bg)
 129 {
 130         E_Syntax_Char *cha;
 131
 132         cha= e_syntax_char_search(sy, ch);
 133         if (cha)
 134                 return;
 135
 136         cha= (E_Syntax_Char *)malloc(sizeof(E_Syntax_Char));
 137         cha->next= NULL;
 138         cha->prev= NULL;
 139         cha->ch= ch;
 140         cha->fgcol= fg;
 141         cha->bgcol= bg;
 142         E_LIST_ADD(&sy->chars, cha);
 143 }
 144
 145 static inline int check_token_start(int nch)
 146 {
 147         return(isalpha(nch));
 148 }
 149
 150 static inline int check_token_end(int nch)
 151 {
 152         return(!isalpha(nch));
 153 }
 154
 155 static int e_syntax_word(char *line, int idx, int *istart, int nch)
 156 {
 157         int i, tot, first;
 158
 159         first= 0;
 160
 161         /* Search the start of the word. */
 162         for (i= idx; i < nch; i++) {
 163                 if (check_token_start(line[i])) {
 164                         first= 1;
 165                         break;
 166                 }
 167         }
 168
 169         if (!first)
 170                 return(-1);
 171
 172         *istart= i;
 173         tot= 0;
 174
 175         e_debug_printf("Syntax word [");
 176         for (i= *istart; i < nch; i++) {
 177                 if (check_token_end(line[i]))
 178                         break;
 179                 tot++;
 180         }
 181         if (tot)
 182                 return(tot);
 183         return(-1);
 184 }
 185
 186 static void e_syntax_color(E_Syntax_Word *wr, E_ScreenLine *ln, int i, int nch)
 187 {
 188         int e;
 189
 190         for (e= i; e < (i+nch); e++) {
 191                 ln->fcol[e]= wr->fgcol;
 192                 ln->bcol[e]= wr->bgcol;
 193         }
 194 }
 195
 196 void e_syntax_apply(E_Syntax *sy, E_ScreenLine *ln, int ncol)
 197 {
 198         E_Syntax_Word *wr;
 199         E_Syntax_Char *ch;
 200         int i, nch, istart;
 201
 202         i= 0;
 203
 204         /* First round, check for words. */
 205 do_word:
 206         nch= e_syntax_word(ln->text, i, &istart, ncol);
 207         if (nch == -1) {
 208                 goto do_char;
 209                 return;
 210         }
 211
 212         wr= e_syntax_word_search(sy, &(ln->text[istart]), nch);
 213         if (wr)
 214                 e_syntax_color(wr, ln, istart, nch);
 215
 216         if (i+nch < ncol) {
 217                 i += nch;
 218                 goto do_word;
 219         }
 220
 221         /* Second round, check for characters. */
 222 do_char:
 223         for (i= 0; i < ncol; i++) {
 224                 ch= e_syntax_char_search(sy, ln->text[i]);
 225                 if (ch) {
 226                         ln->fcol[i]= ch->fgcol;
 227                         ln->bcol[i]= ch->bgcol;
 228                 }
 229         }
 230 }