/*
 * scanner-sming.l --
 *
 *      Lexical rules for scanning the SMIng MIB module language.
 *
 * Copyright (c) 1999 Frank Strauss, Technical University of Braunschweig.
 *
 * See the file "COPYING" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * @(#) $Id: scanner-sming.l 7734 2008-02-15 07:49:14Z schoenw $
 */
 
%option noyywrap
 
%{
 
#include <config.h>
    
#ifdef BACKEND_SMING
 
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
 
#if defined(HAVE_WIN_H)
#include "win.h"
#endif
 
#include "error.h"
#include "util.h"
#include "parser-sming.h"
#include "parser-sming.tab.h"
#include "scanner-sming.h"
 
#ifdef HAVE_DMALLOC_H
#include <dmalloc.h>
#endif
 
 
 
/* we need a reentrant parser, so yylex gets arguments */
#if 0
#define YY_DECL int yylex YY_PROTO((YYSTYPE *lvalp, void *parser))
#else
#define YY_DECL int yylex(YYSTYPE *lvalp, void *parser)
#endif
 
 
 
#define thisParser (*(Parser *) parser)
 
 
 
#define MAX_NUMBER		"18446744073709551615" /* max Counter64 */
 
 
 
/*
 * This makes the usual notation when referencing attributes also
 * work with our pure parser code.
 */
#define yylval (*lvalp)
 
 
static YY_BUFFER_STATE yybuffer[MAX_LEX_DEPTH];
 
static int lexDepth = 0; 
 
 
int
smingEnterLexRecursion(file)
    FILE *file;
{
    if (lexDepth >= MAX_LEX_DEPTH) {
	return (-1);
    }
    yybuffer[lexDepth++] = YY_CURRENT_BUFFER;
    yy_switch_to_buffer(yy_create_buffer(file, YY_BUF_SIZE));
    return (lexDepth);
}
 
 
 
void
smingLeaveLexRecursion()
{    
    yy_delete_buffer(YY_CURRENT_BUFFER);
    yy_switch_to_buffer(yybuffer[--lexDepth]);
}
 
 
 
%}
 
 
 
/*
 * Lex pattern definitions.
 */
delim		([^a-zA-Z0-9-])
lineBreak       ("\n"|"\n\015"|"\015\n")
WSP		(" "|"\t")
VCHAR		([\041-\176])
HTAB		"\t"
SP		" "
 
 
/*
 * Lex state definitions.
 */
%s		Skipline
 
%%
 
 
 
 /*
  * Lex rules for comments. Do you use {lineBreak} here because it
  * introduces a trailing context which is (a) slow and (b) causes
  * REJECT to be used.
  */
 
<INITIAL>"//"({WSP}|{VCHAR})*/"\n" {
}
 
<INITIAL>"//"({WSP}|{VCHAR})*/"\n\015" {
}
 
<INITIAL>"//"({WSP}|{VCHAR})*/"\015\n" {
}
 
 /*
  * Lex rules for some special tokens.
  */
 
<INITIAL>[\{\}\(\)\;\,\-\.\|] {
    return yytext[0];
}
    
<INITIAL>".." {
    return DOT_DOT;
}
 
<INITIAL>"."/[^\.] {
    return DOT;
}
 
<INITIAL>"::" {
    return COLON_COLON;
}
 
 /*
  * Lex rules for separators.
  */
 
<INITIAL>{lineBreak} {
    thisParser.line++;
}
 
<INITIAL>{WSP} {
}
 
 /*
  * Lex rules for known keywords.
  */
 
<INITIAL>module/{delim} {
    yylval.id = yytext;
    return moduleKeyword;
}
 
<INITIAL>import/{delim} {
    yylval.id = yytext;
    return importKeyword;
}
 
<INITIAL>revision/{delim} {
    yylval.id = yytext;
    return revisionKeyword;
}
 
<INITIAL>date/{delim} {
    yylval.id = yytext;
    return dateKeyword;
}
 
<INITIAL>organization/{delim} {
    yylval.id = yytext;
    return organizationKeyword;
}
 
<INITIAL>contact/{delim} {
    yylval.id = yytext;
    return contactKeyword;
}
 
<INITIAL>description/{delim} {
    yylval.id = yytext;
    return descriptionKeyword;
}
 
<INITIAL>reference/{delim} {
    yylval.id = yytext;
    return referenceKeyword;
}
 
<INITIAL>extension/{delim} {
    yylval.id = yytext;
    return extensionKeyword;
}
 
<INITIAL>typedef/{delim} {
    yylval.id = yytext;
    return typedefKeyword;
}
 
<INITIAL>type/{delim} {
    yylval.id = yytext;
    return typeKeyword;
}
 
<INITIAL>parent/{delim} {
    yylval.id = yytext;
    return parentKeyword;
}
 
<INITIAL>identity/{delim} {
    yylval.id = yytext;
    return identityKeyword;
}
 
<INITIAL>class/{delim} {
    yylval.id = yytext;
    return classKeyword;
}
 
<INITIAL>extends/{delim} {
    yylval.id = yytext;
    return extendsKeyword;
}
 
<INITIAL>attribute/{delim} {
    yylval.id = yytext;
    return attributeKeyword;
}
 
<INITIAL>unique/{delim} {
    yylval.id = yytext;
    return uniqueKeyword;
}
 
<INITIAL>event/{delim} {
    yylval.id = yytext;
    return eventKeyword;
}
 
<INITIAL>format/{delim} {
    yylval.id = yytext;
    return formatKeyword;
}
 
<INITIAL>units/{delim} {
    yylval.id = yytext;
    return unitsKeyword;
}
 
<INITIAL>status/{delim} {
    yylval.id = yytext;
    return statusKeyword;
}
 
<INITIAL>access/{delim} {
    yylval.id = yytext;
    return accessKeyword;
}
 
<INITIAL>default/{delim} {
    yylval.id = yytext;
    return defaultKeyword;
}
 
<INITIAL>abnf/{delim} {
    yylval.id = yytext;
    return abnfKeyword;
}
 
 
 /*
  *Base types keywords
  */
<INITIAL>OctetString/{delim} {
    yylval.id = yytext;
    return OctetStringKeyword;
}
 
<INITIAL>Pointer/{delim} {
    yylval.id = yytext;
    return PointerKeyword;
}
 
<INITIAL>ObjectIdentifier/{delim} {
    yylval.id = yytext;
    return ObjectIdentifierKeyword;
}
 
<INITIAL>Integer32/{delim} {
    yylval.id = yytext;
    return Integer32Keyword;
}
 
<INITIAL>Integer64/{delim} {
    yylval.id = yytext;
    return Integer64Keyword;
}
 
<INITIAL>Unsigned32/{delim} {
    yylval.id = yytext;
    return Unsigned32Keyword;
}
 
<INITIAL>Unsigned64/{delim} {
    yylval.id = yytext;
    return Unsigned64Keyword;
}
 
<INITIAL>Float32/{delim} {
    yylval.id = yytext;
    return Float32Keyword;
}
 
<INITIAL>Float64/{delim} {
    yylval.id = yytext;
    return Float64Keyword;
}
 
<INITIAL>Float128/{delim} {
    yylval.id = yytext;
    return Float128Keyword;
}
 
<INITIAL>Bits/{delim} {
    yylval.id = yytext;
    return BitsKeyword;
}
 
<INITIAL>Enumeration/{delim} {
    yylval.id = yytext;
    return EnumerationKeyword;
}
 
 /*
  *Status keywords
  */
 
<INITIAL>current/{delim} {
    yylval.id = yytext;
    return currentKeyword;
}
 
<INITIAL>deprecated/{delim} {
    yylval.id = yytext;
    return deprecatedKeyword;
}
 
<INITIAL>obsolete/{delim} {
    yylval.id = yytext;
    return obsoleteKeyword;
}
 
 /*
  *Access keywords
  */
 
<INITIAL>eventonly/{delim} {
    yylval.id = yytext;
    return eventonlyKeyword;
}
 
<INITIAL>readonly/{delim} {
    yylval.id = yytext;
    return readonlyKeyword;
}
 
<INITIAL>readwrite/{delim} {
    yylval.id = yytext;
    return readwriteKeyword;
}
 
 /*
  *Special floating point values' keywords
  */
 
<INITIAL>neginf/{delim} {
    yylval.id = yytext;
    return neginfKeyword;
}
 
<INITIAL>posinf/{delim} {
    yylval.id = yytext;
    return posinfKeyword;
}
 
<INITIAL>snan/{delim} {
    yylval.id = yytext;
    return snanKeyword;
}
 
<INITIAL>qnan/{delim} {
    yylval.id = yytext;
    return qnanKeyword;
}
 
 
 
 /*
  * Lex rules for identifiers.
  */
 
 /* e.g. module names: REF: draft,p.12-13 */
<INITIAL>[A-Z](-?[a-zA-Z0-9_]+)*-? {
    if (yytext[yyleng-1] == '-') {
	smiPrintError(parser, ERR_ID_ENDS_IN_HYPHEN, yytext);
    }
    if (yyleng > 64) {
	smiPrintError(parser, ERR_UCIDENTIFIER_64, yytext);
    }
    if (strchr(yytext, '_')) {
        smiPrintError(parser, ERR_UNDERSCORE_IN_IDENTIFIER, yytext);
    }
    yylval.text = smiStrdup(yytext);
    return ucIdentifier;
}
 
 /* same for lowercase names */
<INITIAL>[a-z](-?[a-zA-Z0-9_]+)*-? {
    if (yytext[yyleng-1] == '-') {
	smiPrintError(parser, ERR_ID_ENDS_IN_HYPHEN, yytext);
    }
    if (yyleng > 64) {
	smiPrintError(parser, ERR_LCIDENTIFIER_64, yytext);
    }
    if (strchr(yytext, '_')) {
        smiPrintError(parser, ERR_UNDERSCORE_IN_IDENTIFIER, yytext);
    }
    yylval.text = smiStrdup(yytext);
    return lcIdentifier;
}
 
 /*
  * Lex rules for numbers.
  *
  * NOTE: `-' is a separate token. Hence, there are no negative numbers.
  */
 
<INITIAL>0+/[0-9] {
    smiPrintError(parser, ERR_LEADING_ZEROS);
}
 
<INITIAL>([1-9][0-9]*|0)/[^0-9] {
    if ((yyleng > sizeof(MAX_NUMBER)-1) ||
	((yyleng == sizeof(MAX_NUMBER)-1) &&
	 (strcmp(yytext, MAX_NUMBER) > 0))) {
	smiPrintError(parser, ERR_NUMBER_TOO_LARGE, yytext);
    }
    yylval.text = yytext;
    return decimalNumber;
}
 
<INITIAL>0x[0-9a-fA-F]+/[^0-9a-fA-F] {
    if (yyleng % 2) {
	smiPrintError(parser, ERR_HEX_STRING_MUL2, yytext);
    }
    yylval.text = yytext;
    return hexadecimalNumber;
}
 /*
  * Lex rules for floating point values.
  */
 
<INITIAL>([0-9]*\.[0-9]+([eE][+-]?[0-9]+)?)/[^0-9] {
    yylval.text = yytext;
    return floatValue;
}
 
 /*
  * Lex rules for OID's.
  */
  
<INITIAL>([0-9A-Za-z]-?)+\.([0-9A-Za-z]-?)+\.([0-9A-Za-z]-?)+(\.([0-9A-Za-z]-?)+)*/([^0-9A-Za-z]) {
    yylval.text = yytext;
    return OID;
}
 
 
 /*
  * Lex rules for textSegments.
  */
 
<INITIAL>\"([^\"]|(\\\"))*\" {
    char *s, *d;		/* the source and destination pointer */
    int column = 0;		/* the current column */
    int newlineflag = 0;	/* we have just passed a newline */
    int cutoffcolumn = 0;	/* cut off white space up to this column */
				/* (computed by caculating the indentation */
				/* of the first column) */
 
    yytext[yyleng-1] = '\0';
    for (d = yytext, s = yytext+1; s[0]; s++, d++) {
 
	if ((s[0] == '\n' && s[1] == '\r')	/* newline sequence */
	    || (s[0] == '\r' && s[1] == '\n')) {
	    thisParser.line += 1;
	    d[0] = '\n';
	    s++;
	    newlineflag = 1;
	    column = 0;
	    if (cutoffcolumn < 0) cutoffcolumn = 0;
	} else if (s[0] == '\n') {		/* simple newline */
	    thisParser.line += 1;
	    d[0] = '\n';
	    newlineflag = 1;
	    column = 0;
	    if (cutoffcolumn < 0) cutoffcolumn = 0;
	} else {
	    if (newlineflag && isspace((int)(unsigned char)s[0])) {	/* space after newline */
		if (cutoffcolumn <= 0) {
		    cutoffcolumn -= (s[0] == '\t') ? (8-((column-1) % 8)) : 1;
		}
		column += (s[0] == '\t') ? (8-((column-1) % 8)) : 1;
		if (cutoffcolumn <= 0 || column <= cutoffcolumn) {
		    d--;
		} else {
		    d[0] = s[0];
		    newlineflag = 0;
		}
	    } else {				/* everything else */
		if (! isascii(s[0])) {
		    smiPrintError(parser, ERR_ILLEGAL_CHAR_IN_STRING,
				  s[0], (unsigned char) s[0]);
		}
		d[0] = s[0];
		newlineflag = 0;
		if (cutoffcolumn < 0) {
		    cutoffcolumn *= -1;
		}
	    }
	}
    }
    d[0] = '\0';
 
    yylval.text = yytext;
    return textSegment;
}
 
 /*
  * Skip the remainder of the line
  */
<Skipline>.*{lineBreak} {
    thisParser.line++;
    BEGIN(INITIAL);
}
 
 /*
  * Everything else...
  */
 
. {
    smiPrintError(parser, ERR_LEX_UNEXPECTED_CHAR);
    BEGIN(Skipline);
}
 
%%
 
#endif