Return to languages.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / dbx

Annotation of 42BSD/ucb/dbx/languages.c, revision 1.1.1.1

1.1       root        1: /* Copyright (c) 1982 Regents of the University of California */
                      2: 
                      3: static char sccsid[] = "@(#)languages.c 1.3 5/18/83";
                      4: 
                      5: /*
                      6:  * Language management.
                      7:  */
                      8: 
                      9: #include "defs.h"
                     10: #include "languages.h"
                     11: #include "c.h"
                     12: #include "pascal.h"
                     13: #include "asm.h"
                     14: 
                     15: #ifndef public
                     16: typedef struct Language *Language;
                     17: 
                     18: typedef enum {
                     19:     L_PRINTDECL, L_PRINTVAL, L_TYPEMATCH, L_BUILDAREF, L_EVALAREF
                     20: } LanguageOp;
                     21: 
                     22: typedef LanguageOperation();
                     23: #endif
                     24: 
                     25: struct Language {
                     26:     String name;
                     27:     String suffix;
                     28:     LanguageOperation *op[10];
                     29:     Language next;
                     30: };
                     31: 
                     32: private Language head;
                     33: 
                     34: /*
                     35:  * Initialize language information.
                     36:  *
                     37:  * The last language initialized will be the default one
                     38:  * for otherwise indistinguised symbols.
                     39:  */
                     40: 
                     41: public language_init()
                     42: {
                     43:     c_init();
                     44:     fortran_init();
                     45:     pascal_init();
                     46:     asm_init();
                     47: }
                     48: 
                     49: public Language findlanguage(suffix)
                     50: String suffix;
                     51: {
                     52:     Language lang;
                     53: 
                     54:     lang = head;
                     55:     if (suffix != nil) {
                     56:        while (lang != nil and not streq(lang->suffix, suffix)) {
                     57:            lang = lang->next;
                     58:        }
                     59:        if (lang == nil) {
                     60:            lang = head;
                     61:        }
                     62:     }
                     63:     return lang;
                     64: }
                     65: 
                     66: public String language_name(lang)
                     67: Language lang;
                     68: {
                     69:     return (lang == nil) ? "(nil)" : lang->name;
                     70: }
                     71: 
                     72: public Language language_define(name, suffix)
                     73: String name;
                     74: String suffix;
                     75: {
                     76:     Language p;
                     77: 
                     78:     p = new(Language);
                     79:     p->name = name;
                     80:     p->suffix = suffix;
                     81:     p->next = head;
                     82:     head = p;
                     83:     return p;
                     84: }
                     85: 
                     86: public language_setop(lang, op, operation)
                     87: Language lang;
                     88: LanguageOp op;
                     89: LanguageOperation *operation;
                     90: {
                     91:     checkref(lang);
                     92:     assert(ord(op) <= ord(L_EVALAREF));
                     93:     lang->op[ord(op)] = operation;
                     94: }
                     95: 
                     96: public LanguageOperation *language_op(lang, op)
                     97: Language lang;
                     98: LanguageOp op;
                     99: {
                    100:     LanguageOperation *o;
                    101: 
                    102:     checkref(lang);
                    103:     o = lang->op[ord(op)];
                    104:     checkref(o);
                    105:     return o;
                    106: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.