/*
 * 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