Annotation of 43BSDReno/usr.sbin/named/tools/nslookup/commands.l, revision 1.1

1.1     ! root        1: %{
        !             2: 
        !             3: /*-
        !             4:  * Copyright (c) 1985 The Regents of the University of California.
        !             5:  * All rights reserved.
        !             6:  *
        !             7:  * Redistribution and use in source and binary forms are permitted provided
        !             8:  * that: (1) source distributions retain this entire copyright notice and
        !             9:  * comment, and (2) distributions including binaries display the following
        !            10:  * acknowledgement:  ``This product includes software developed by the
        !            11:  * University of California, Berkeley and its contributors'' in the
        !            12:  * documentation or other materials provided with the distribution and in
        !            13:  * all advertising materials mentioning features or use of this software.
        !            14:  * Neither the name of the University nor the names of its contributors may
        !            15:  * be used to endorse or promote products derived from this software without
        !            16:  * specific prior written permission.
        !            17:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
        !            18:  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
        !            19:  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        !            20:  */
        !            21: 
        !            22: #ifndef lint
        !            23: static char sccsid[] = "@(#)commands.l 5.13 (Berkeley) 7/24/90";
        !            24: #endif /* not lint */
        !            25: 
        !            26: /*
        !            27:  *******************************************************************************
        !            28:  *
        !            29:  *  commands.l
        !            30:  *
        !            31:  *     Andrew Cherenson        CS298-26  Fall 1985
        !            32:  *
        !            33:  *     Lex input file for the nslookup program command interpreter.
        !            34:  *     When a sequence is recognized, the associated action
        !            35:  *     routine is called. The action routine may need to
        !            36:  *     parse the string for additional information.
        !            37:  *
        !            38:  *  Recognized commands: (identifiers are shown in uppercase)
        !            39:  *
        !            40:  *     server NAME     - set default server to NAME, using default server
        !            41:  *     lserver NAME    - set default server to NAME, using initial server
        !            42:  *     finger [NAME]   - finger the optional NAME
        !            43:  *     exit            - exit the program
        !            44:  *     root            - set default server to the root
        !            45:  *     ls NAME         - list the domain NAME
        !            46:  *     view FILE       - sorts and view the file with more
        !            47:  *     set OPTION      - set an option
        !            48:  *     help            - print help information
        !            49:  *     ?               - print help information
        !            50:  *     NAME            - print info about the host/domain NAME
        !            51:  *                       using default server.
        !            52:  *     NAME1 NAME2     - as above, but use NAME2 as server
        !            53:  *
        !            54:  *
        !            55:  *   yylex Results:
        !            56:  *     0               upon end-of-file.
        !            57:  *     1               after each command.
        !            58:  *
        !            59:  *******************************************************************************
        !            60:  */
        !            61: 
        !            62: #include "res.h"
        !            63: extern char rootServerName[];
        !            64: 
        !            65: %}
        !            66: WS     [ \t]
        !            67: FLET   [A-Za-z0-9.*\\]
        !            68: LET    [A-Za-z0-9.*]
        !            69: NAME   [A-Za-z0-9.*=_/-]
        !            70: %%
        !            71: ^{WS}*server{WS}+{LET}{NAME}*{WS}*$    {
        !            72:                                            /*
        !            73:                                             * 0 == use current server to find
        !            74:                                             *      the new one.
        !            75:                                             * 1 == use original server to find
        !            76:                                             *      the new one.
        !            77:                                             */
        !            78:                                            SetDefaultServer(yytext, 0);
        !            79:                                            return(1);
        !            80:                                        }
        !            81: ^{WS}*lserver{WS}+{LET}{NAME}*{WS}*$   {
        !            82:                                            SetDefaultServer(yytext, 1);
        !            83:                                            return(1);
        !            84:                                        }
        !            85: ^{WS}*exit{WS}*$                       {
        !            86:                                            return(0);
        !            87:                                        }
        !            88: ^{WS}*root{WS}*$                       {
        !            89:                                            SetDefaultServer(rootServerName, 1);
        !            90:                                            return(1);
        !            91:                                        }
        !            92: ^{WS}*finger({WS}+{LET}{NAME}*)?{WS}+>>?{WS}*{NAME}+{WS}*$     {
        !            93:                                            /*
        !            94:                                             * 2nd arg.
        !            95:                                             *  0 == output to stdout
        !            96:                                             *  1 == output to file
        !            97:                                             */
        !            98:                                            Finger(yytext, 1);
        !            99:                                            return(1);
        !           100:                                        }
        !           101: ^{WS}*finger({WS}+{LET}{NAME}*)?{WS}*$ {
        !           102:                                            Finger(yytext, 0);
        !           103:                                            return(1);
        !           104:                                        }
        !           105: ^{WS}*view{WS}+{NAME}+{WS}*$   {
        !           106:                                            ViewList(yytext);
        !           107:                                            return(1);
        !           108:                                        }
        !           109: ^{WS}*ls{WS}+(("-a"|"-d"|"-h"|"-m"|"-s"){WS}+)?{LET}{NAME}*{WS}+>>?{WS}+{NAME}+{WS}*$  {
        !           110:                                            /*
        !           111:                                             * 2nd arg.
        !           112:                                             *  0 == output to stdout
        !           113:                                             *  1 == output to file
        !           114:                                             */
        !           115:                                            ListHosts(yytext, 1);
        !           116:                                            return(1);
        !           117:                                        }
        !           118: ^{WS}*ls{WS}+(("-a"|"-d"|"-h"|"-m"|"-s"){WS}+)?{LET}{NAME}*{WS}*$      {
        !           119:                                            ListHosts(yytext, 0);
        !           120:                                            return(1);
        !           121:                                        }
        !           122: ^{WS}*ls{WS}+-t{WS}+({LET}{NAME}*{WS}+)?{LET}{NAME}*{WS}+>>?{WS}+{NAME}+{WS}*$ {
        !           123:                                            /*
        !           124:                                             * 2nd arg.
        !           125:                                             *  0 == output to stdout
        !           126:                                             *  1 == output to file
        !           127:                                             */
        !           128:                                            ListHostsByType(yytext, 1);
        !           129:                                            return(1);
        !           130:                                        }
        !           131: ^{WS}*ls{WS}+-t{WS}+({LET}{NAME}*{WS}+)?{LET}{NAME}*{WS}*$ {
        !           132:                                            ListHostsByType(yytext, 0);
        !           133:                                            return(1);
        !           134:                                        }
        !           135: ^{WS}*set{WS}+{NAME}+{WS}*$            {
        !           136:                                            SetOption(yytext);
        !           137:                                            return(1);
        !           138:                                        }
        !           139: ^{WS}*help{WS}*$                       {
        !           140:                                            extern void PrintHelp();
        !           141: 
        !           142:                                            PrintHelp();
        !           143:                                            return(1);
        !           144:                                        }
        !           145: ^{WS}*"?"{WS}*$                                {
        !           146:                                            PrintHelp();
        !           147:                                            return(1);
        !           148:                                        }
        !           149: ^{WS}*{FLET}{NAME}*{WS}+>>?{WS}*{NAME}+{WS}*$  {
        !           150:                                            /*
        !           151:                                             * 0 == output to stdout
        !           152:                                             * 1 == output to file
        !           153:                                             */
        !           154:                                            LookupHost(yytext, 1);
        !           155:                                            return(1);
        !           156:                                        }
        !           157: ^{WS}*{FLET}{NAME}*{WS}*$              {
        !           158:                                            LookupHost(yytext, 0);
        !           159:                                            return(1);
        !           160:                                        }
        !           161: ^{WS}*{FLET}{NAME}*{WS}+{LET}{NAME}*{WS}+>>?{WS}*{NAME}+{WS}*$ {
        !           162:                                            /*
        !           163:                                             * 0 == output to stdout
        !           164:                                             * 1 == output to file
        !           165:                                             */
        !           166:                                            LookupHostWithServer(yytext, 1);
        !           167:                                            return(1);
        !           168:                                        }
        !           169: ^{WS}*{FLET}{NAME}*{WS}+{LET}{NAME}*{WS}*$     {
        !           170:                                            LookupHostWithServer(yytext, 0);
        !           171:                                            return(1);
        !           172:                                        }
        !           173: ^{WS}*\n                               {
        !           174:                                            return(1);
        !           175:                                        }
        !           176: ^.*\n                                  {
        !           177:                                            printf("Unrecognized command: %s",
        !           178:                                                        yytext);
        !           179:                                            return(1);
        !           180:                                        }
        !           181: \n                                     { ; }
        !           182: %%

unix.superglobalmegacorp.com

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