You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
629 lines
16 KiB
629 lines
16 KiB
/*
|
|
* The SIP lexer.
|
|
*
|
|
* Copyright (c) 2010 Riverbank Computing Limited <info@riverbankcomputing.com>
|
|
*
|
|
* This file is part of SIP.
|
|
*
|
|
* This copy of SIP is licensed for use under the terms of the SIP License
|
|
* Agreement. See the file LICENSE for more details.
|
|
*
|
|
* This copy of SIP may also used under the terms of the GNU General Public
|
|
* License v2 or v3 as published by the Free Software Foundation which can be
|
|
* found in the files LICENSE-GPL2 and LICENSE-GPL3 included in this package.
|
|
*
|
|
* SIP is supplied WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
*/
|
|
|
|
%{
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#include "sip.h"
|
|
#include "parser.h"
|
|
|
|
|
|
#ifndef FLEX_SCANNER
|
|
#error "Only flex is supported at the moment"
|
|
#endif
|
|
|
|
|
|
#define YY_NO_UNISTD_H
|
|
#define YY_FATAL_ERROR(s) fatallex(s)
|
|
|
|
#define MAX_INCLUDE_DEPTH 10
|
|
#define MAX_CODE_LINE_LENGTH 1000
|
|
|
|
|
|
static struct inputFile {
|
|
int lineno; /* The line number. */
|
|
YY_BUFFER_STATE bs; /* The flex buffer state handle. */
|
|
char *name; /* The file name. */
|
|
char *cwd; /* The path part of the file name. */
|
|
parserContext pc; /* The parser context. */
|
|
} inputFileStack[MAX_INCLUDE_DEPTH];
|
|
|
|
static int currentFile = -1; /* Index of the current input file. */
|
|
static char codeLine[MAX_CODE_LINE_LENGTH + 2]; /* The current code line. */
|
|
static int codeIdx = -1; /* Index of next code character. */
|
|
|
|
static FILE *openFile(const char *);
|
|
static void fatallex(char *);
|
|
%}
|
|
|
|
%x code
|
|
%x ccomment
|
|
|
|
%%
|
|
|
|
^[ \t]*%API {return TK_API;}
|
|
^[ \t]*%DefaultEncoding {return TK_DEFENCODING;}
|
|
^[ \t]*%Plugin {return TK_PLUGIN;}
|
|
^[ \t]*%Include {return TK_INCLUDE;}
|
|
^[ \t]*%OptionalInclude {return TK_OPTINCLUDE;}
|
|
^[ \t]*%Import {return TK_IMPORT;}
|
|
^[ \t]*%Module {return TK_MODULE;}
|
|
^[ \t]*%CModule {return TK_CMODULE;}
|
|
^[ \t]*%ConsolidatedModule {return TK_CONSMODULE;}
|
|
^[ \t]*%CompositeModule {return TK_COMPOMODULE;}
|
|
^[ \t]*%Timeline {return TK_TIMELINE;}
|
|
^[ \t]*%Platforms {return TK_PLATFORMS;}
|
|
^[ \t]*%Feature {return TK_FEATURE;}
|
|
^[ \t]*%License {return TK_LICENSE;}
|
|
^[ \t]*%MappedType {return TK_MAPPEDTYPE;}
|
|
^[ \t]*%Exception {return TK_EXCEPTION;}
|
|
^[ \t]*%If {return TK_IF;}
|
|
^[ \t]*%DefaultMetatype {return TK_DEFMETATYPE;}
|
|
^[ \t]*%DefaultSupertype {return TK_DEFSUPERTYPE;}
|
|
<INITIAL>^[ \t]*%End {return TK_END;}
|
|
class {return TK_CLASS;}
|
|
struct {return TK_STRUCT;}
|
|
public {return TK_PUBLIC;}
|
|
protected {return TK_PROTECTED;}
|
|
private {return TK_PRIVATE;}
|
|
signals {return TK_SIGNALS;}
|
|
Q_SIGNALS {return TK_SIGNALS;}
|
|
Q_SIGNAL {return TK_SIGNAL_METHOD;}
|
|
slots {return TK_SLOTS;}
|
|
Q_SLOTS {return TK_SLOTS;}
|
|
Q_SLOT {return TK_SLOT_METHOD;}
|
|
char {return TK_CHAR;}
|
|
wchar_t {return TK_WCHAR_T;}
|
|
bool {return TK_BOOL;}
|
|
short {return TK_SHORT;}
|
|
int {return TK_INT;}
|
|
long {return TK_LONG;}
|
|
float {return TK_FLOAT;}
|
|
double {return TK_DOUBLE;}
|
|
void {return TK_VOID;}
|
|
virtual {return TK_VIRTUAL;}
|
|
enum {return TK_ENUM;}
|
|
signed {return TK_SIGNED;}
|
|
unsigned {return TK_UNSIGNED;}
|
|
const {return TK_CONST;}
|
|
static {return TK_STATIC;}
|
|
true {return TK_TRUE;}
|
|
false {return TK_FALSE;}
|
|
NULL {return TK_NULL;}
|
|
typedef {return TK_TYPEDEF;}
|
|
namespace {return TK_NAMESPACE;}
|
|
operator {return TK_OPERATOR;}
|
|
throw {return TK_THROW;}
|
|
explicit {return TK_EXPLICIT;}
|
|
template {return TK_TEMPLATE;}
|
|
:: {return TK_SCOPE;}
|
|
\|\| {return TK_LOGICAL_OR;}
|
|
SIP_PYOBJECT {return TK_PYOBJECT;}
|
|
SIP_PYTUPLE {return TK_PYTUPLE;}
|
|
SIP_PYLIST {return TK_PYLIST;}
|
|
SIP_PYDICT {return TK_PYDICT;}
|
|
SIP_PYCALLABLE {return TK_PYCALLABLE;}
|
|
SIP_PYSLICE {return TK_PYSLICE;}
|
|
SIP_PYTYPE {return TK_PYTYPE;}
|
|
SIP_SIGNAL {return TK_SIPSIGNAL;}
|
|
SIP_SLOT {return TK_SIPSLOT;}
|
|
SIP_ANYSLOT {return TK_SIPANYSLOT;}
|
|
SIP_RXOBJ_CON {return TK_SIPRXCON;}
|
|
SIP_RXOBJ_DIS {return TK_SIPRXDIS;}
|
|
SIP_SLOT_CON {return TK_SIPSLOTCON;}
|
|
SIP_SLOT_DIS {return TK_SIPSLOTDIS;}
|
|
SIP_QOBJECT {return TK_TQOBJECT;}
|
|
\.\.\. {return TK_ELLIPSIS;}
|
|
|
|
|
|
[ \t\r] { /* Ignore whitespace. */
|
|
;
|
|
}
|
|
|
|
\n { /* Maintain the line number. */
|
|
++inputFileStack[currentFile].lineno;
|
|
|
|
if (codeIdx == 0)
|
|
{
|
|
BEGIN code;
|
|
}
|
|
}
|
|
|
|
\/\/.* { /* Ignore C++ style comments. */
|
|
;
|
|
}
|
|
|
|
|
|
-?[0-9]+ { /* A signed decimal number. */
|
|
yylval.number = strtol(yytext,NULL,0);
|
|
return TK_NUMBER;
|
|
}
|
|
|
|
|
|
-?(([0-9]+)|([0-9]*\.[0-9]*)([eE][-+]?[0-9]+)?)[fF]? {/* A floating point number. */
|
|
yylval.real = strtod(yytext,NULL);
|
|
return TK_REAL;
|
|
}
|
|
|
|
|
|
0x[0-9a-fA-F]+ { /* An unsigned hexadecimal number. */
|
|
yylval.number = strtol(yytext,NULL,16);
|
|
return TK_NUMBER;
|
|
}
|
|
|
|
|
|
[_A-Za-z][_A-Za-z0-9]* { /* An identifier name. */
|
|
yylval.text = sipStrdup(yytext);
|
|
return TK_NAME;
|
|
}
|
|
|
|
|
|
[._A-Za-z][._/A-Za-z0-9\-]*[._A-Za-z0-9] { /* A relative pathname. */
|
|
yylval.text = sipStrdup(yytext);
|
|
return TK_PATHNAME;
|
|
}
|
|
|
|
|
|
\"[^"\n]*["\n] { /* A double-quoted string. */
|
|
char *dp, *sp;
|
|
|
|
/* Copy the string without the quotes. */
|
|
|
|
yylval.text = sipMalloc(strlen(yytext) + 1);
|
|
|
|
dp = yylval.text;
|
|
sp = yytext;
|
|
|
|
while (*sp != '\0')
|
|
{
|
|
if (*sp != '"')
|
|
*dp++ = *sp;
|
|
|
|
++sp;
|
|
}
|
|
|
|
*dp = '\0';
|
|
|
|
return TK_STRING;
|
|
}
|
|
|
|
|
|
\'[^'\n]*['\n] { /* A single-quoted character. */
|
|
if (strlen(yytext) != 3)
|
|
fatallex("Exactly one character expected between single quotes");
|
|
|
|
yylval.qchar = yytext[1];
|
|
|
|
return TK_TQCHAR;
|
|
}
|
|
|
|
|
|
\/\* { /* Ignore C-style comments. */
|
|
BEGIN ccomment;
|
|
}
|
|
<ccomment>\n {
|
|
++inputFileStack[currentFile].lineno;
|
|
}
|
|
<ccomment>\*\/ {
|
|
BEGIN INITIAL;
|
|
}
|
|
<ccomment>. {
|
|
;
|
|
}
|
|
|
|
|
|
^%Copying { /* The software license. */
|
|
codeIdx = 0;
|
|
return TK_COPYING;
|
|
}
|
|
|
|
^%ConvertFromTypeCode { /* The start of a from-type code block. */
|
|
codeIdx = 0;
|
|
return TK_FROMTYPE;
|
|
}
|
|
|
|
^%ConvertToTypeCode { /* The start of a to-type code block. */
|
|
codeIdx = 0;
|
|
return TK_TOTYPE;
|
|
}
|
|
|
|
^%ConvertToSubClassCode { /* The start of a to-sub-class code block. */
|
|
codeIdx = 0;
|
|
return TK_TOSUBCLASS;
|
|
}
|
|
|
|
^%ExportedHeaderCode { /* The start of an exported header code block. */
|
|
codeIdx = 0;
|
|
return TK_EXPHEADERCODE;
|
|
}
|
|
|
|
^%ModuleHeaderCode { /* The start of a module header code block. */
|
|
codeIdx = 0;
|
|
return TK_MODHEADERCODE;
|
|
}
|
|
|
|
^%TypeHeaderCode { /* The start of a type header code block. */
|
|
codeIdx = 0;
|
|
return TK_TYPEHEADERCODE;
|
|
}
|
|
|
|
^%PreInitialisationCode { /* The start of a pre-initialisation code block. */
|
|
codeIdx = 0;
|
|
return TK_PREINITCODE;
|
|
}
|
|
|
|
^%InitialisationCode { /* The start of an initialisation code block. */
|
|
codeIdx = 0;
|
|
return TK_INITCODE;
|
|
}
|
|
|
|
^%PostInitialisationCode { /* The start of a post-initialisation code block. */
|
|
codeIdx = 0;
|
|
return TK_POSTINITCODE;
|
|
}
|
|
|
|
^%UnitCode { /* The start of a unit code block. */
|
|
codeIdx = 0;
|
|
return TK_UNITCODE;
|
|
}
|
|
|
|
^%ModuleCode { /* The start of a module code block. */
|
|
codeIdx = 0;
|
|
return TK_MODCODE;
|
|
}
|
|
|
|
^%TypeCode { /* The start of a type code block. */
|
|
codeIdx = 0;
|
|
return TK_TYPECODE;
|
|
}
|
|
|
|
^%MethodCode { /* The start of a C++ method code block. */
|
|
codeIdx = 0;
|
|
return TK_METHODCODE;
|
|
}
|
|
|
|
^%VirtualCatcherCode { /* The start of a C++ virtual code block. */
|
|
codeIdx = 0;
|
|
return TK_VIRTUALCATCHERCODE;
|
|
}
|
|
|
|
^%GCTraverseCode { /* The start of a traverse code block. */
|
|
codeIdx = 0;
|
|
return TK_TRAVERSECODE;
|
|
}
|
|
|
|
^%GCClearCode { /* The start of a clear code block. */
|
|
codeIdx = 0;
|
|
return TK_CLEARCODE;
|
|
}
|
|
|
|
^%BIGetBufferCode { /* The start of a get buffer code block. */
|
|
codeIdx = 0;
|
|
return TK_GETBUFFERCODE;
|
|
}
|
|
|
|
^%BIReleaseBufferCode { /* The start of a release buffer code block. */
|
|
codeIdx = 0;
|
|
return TK_RELEASEBUFFERCODE;
|
|
}
|
|
|
|
^%BIGetReadBufferCode { /* The start of a read buffer code block. */
|
|
codeIdx = 0;
|
|
return TK_READBUFFERCODE;
|
|
}
|
|
|
|
^%BIGetWriteBufferCode { /* The start of a write buffer code block. */
|
|
codeIdx = 0;
|
|
return TK_WRITEBUFFERCODE;
|
|
}
|
|
|
|
^%BIGetSegCountCode { /* The start of a segment count code block. */
|
|
codeIdx = 0;
|
|
return TK_SEGCOUNTCODE;
|
|
}
|
|
|
|
^%BIGetCharBufferCode { /* The start of a char buffer code block. */
|
|
codeIdx = 0;
|
|
return TK_CHARBUFFERCODE;
|
|
}
|
|
|
|
^%PickleCode { /* The start of a pickle code block. */
|
|
codeIdx = 0;
|
|
return TK_PICKLECODE;
|
|
}
|
|
|
|
^%PrePythonCode { /* The start of a pre-Python code block. */
|
|
codeIdx = 0;
|
|
return TK_PREPYCODE;
|
|
}
|
|
|
|
^%RaiseCode { /* The start of a raise exception code block. */
|
|
codeIdx = 0;
|
|
return TK_RAISECODE;
|
|
}
|
|
|
|
^%Docstring { /* The start of a docstring block. */
|
|
codeIdx = 0;
|
|
return TK_DOCSTRING;
|
|
}
|
|
|
|
^%Doc { /* The start of a documentation block. */
|
|
codeIdx = 0;
|
|
return TK_DOC;
|
|
}
|
|
|
|
^%ExportedDoc { /* The start of an exported documentation block. */
|
|
codeIdx = 0;
|
|
return TK_EXPORTEDDOC;
|
|
}
|
|
|
|
^%Makefile { /* The start of a Makefile code block. */
|
|
codeIdx = 0;
|
|
return TK_MAKEFILE;
|
|
}
|
|
|
|
^%AccessCode { /* The start of an access code block. */
|
|
codeIdx = 0;
|
|
return TK_ACCESSCODE;
|
|
}
|
|
|
|
^%GetCode { /* The start of a get code block. */
|
|
codeIdx = 0;
|
|
return TK_GETCODE;
|
|
}
|
|
|
|
^%SetCode { /* The start of a set code block. */
|
|
codeIdx = 0;
|
|
return TK_SETCODE;
|
|
}
|
|
|
|
<code>^%End { /* The end of a code block. */
|
|
BEGIN INITIAL;
|
|
codeIdx = -1;
|
|
return TK_END;
|
|
}
|
|
|
|
<code>\n { /* The end of a code line . */
|
|
struct inputFile *ifp;
|
|
|
|
codeLine[codeIdx] = '\n';
|
|
codeLine[codeIdx + 1] = '\0';
|
|
codeIdx = 0;
|
|
|
|
ifp = &inputFileStack[currentFile];
|
|
|
|
yylval.codeb = sipMalloc(sizeof (codeBlock));
|
|
|
|
yylval.codeb -> frag = sipStrdup(codeLine);
|
|
yylval.codeb -> linenr = ifp -> lineno++;
|
|
yylval.codeb -> filename = sipStrdup(ifp -> name);
|
|
yylval.codeb -> next = NULL;
|
|
|
|
return TK_CODELINE;
|
|
}
|
|
|
|
<code>. { /* The contents of a code line. */
|
|
if (codeIdx == MAX_CODE_LINE_LENGTH)
|
|
fatallex("Line is too long");
|
|
|
|
codeLine[codeIdx++] = yytext[0];
|
|
}
|
|
|
|
. { /* Anything else is returned as is. */
|
|
return yytext[0];
|
|
}
|
|
|
|
%%
|
|
|
|
/*
|
|
* Hook into EOF handling. Return 0 if there is more to process.
|
|
*/
|
|
|
|
int yywrap()
|
|
{
|
|
char *cwd;
|
|
struct inputFile *ifp;
|
|
|
|
if ((cwd = inputFileStack[currentFile].cwd) != NULL)
|
|
free(cwd);
|
|
|
|
ifp = &inputFileStack[currentFile--];
|
|
|
|
/* Tell the parser if this is the end of a file. */
|
|
|
|
parserEOF(ifp -> name, &ifp -> pc);
|
|
|
|
/* Tidy up this file. */
|
|
|
|
fclose(yyin);
|
|
free(ifp -> name);
|
|
|
|
/* See if this was the original file. */
|
|
|
|
if (currentFile < 0)
|
|
return 1;
|
|
|
|
yy_delete_buffer(YY_CURRENT_BUFFER);
|
|
yy_switch_to_buffer(ifp -> bs);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Set up an input file to be read by the lexer, opening it if necessary. TRUE
|
|
* is returned if the file has not already been read.
|
|
*/
|
|
int setInputFile(FILE *open_fp, parserContext *pc, int optional)
|
|
{
|
|
static stringList *all = NULL;
|
|
char *cwd, *fullname = NULL;
|
|
FILE *fp = open_fp;
|
|
|
|
if (currentFile >= MAX_INCLUDE_DEPTH - 1)
|
|
fatal("Too many nested %%Include, %%OptionalInclude or %%Import statements\n");
|
|
|
|
if (fp != NULL || (fp = openFile(pc->filename)) != NULL)
|
|
fullname = sipStrdup(pc->filename);
|
|
else
|
|
{
|
|
char *cwd;
|
|
|
|
/* Try the directory that contains the current file. */
|
|
if (currentFile >= 0 && (cwd = inputFileStack[currentFile].cwd) != NULL)
|
|
{
|
|
fullname = concat(cwd, "/", pc->filename, NULL);
|
|
|
|
if ((fp = openFile(fullname)) == NULL)
|
|
{
|
|
free(fullname);
|
|
fullname = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Try the include path if we haven't found anything yet. */
|
|
if (fullname == NULL)
|
|
{
|
|
stringList *sl;
|
|
|
|
fullname = NULL;
|
|
|
|
for (sl = includeDirList; sl != NULL; sl = sl -> next)
|
|
{
|
|
if (fullname != NULL)
|
|
free(fullname);
|
|
|
|
fullname = concat(sl->s, "/", pc->filename, NULL);
|
|
|
|
if ((fp = openFile(fullname)) != NULL)
|
|
break;
|
|
}
|
|
|
|
if (fp == NULL)
|
|
{
|
|
if (optional)
|
|
return FALSE;
|
|
|
|
fatal("Unable to find file \"%s\"\n", pc->filename);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If we have just opened the file, make sure that we haven't already read
|
|
* it. While it should never happen with normal modules (if the user
|
|
* doesn't specify recursive %Imports or %Includes) it is likely to happen
|
|
* with consolidated modules.
|
|
*/
|
|
if (open_fp == NULL)
|
|
{
|
|
stringList *sl;
|
|
|
|
for (sl = all; sl != NULL; sl = sl->next)
|
|
if (strcmp(sl->s, fullname) == 0)
|
|
{
|
|
fclose(fp);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/* Remember the filename. */
|
|
appendString(&all, sipStrdup(fullname));
|
|
|
|
yyin = fp;
|
|
|
|
++currentFile;
|
|
|
|
/* Remember the directory containing the new file and make it "current". */
|
|
if ((cwd = strchr(fullname, '/')) != NULL)
|
|
{
|
|
cwd = sipStrdup(fullname);
|
|
*strrchr(cwd,'/') = '\0';
|
|
}
|
|
|
|
inputFileStack[currentFile].lineno = 1;
|
|
inputFileStack[currentFile].name = fullname;
|
|
inputFileStack[currentFile].pc = *pc;
|
|
inputFileStack[currentFile].cwd = cwd;
|
|
|
|
if (currentFile > 0)
|
|
{
|
|
inputFileStack[currentFile].bs = YY_CURRENT_BUFFER;
|
|
yy_switch_to_buffer(yy_create_buffer(yyin,YY_BUF_SIZE));
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
* Open a file for reading or return NULL if it doesn't exist. Any other error
|
|
* is fatal.
|
|
*/
|
|
static FILE *openFile(const char *name)
|
|
{
|
|
FILE *fp;
|
|
|
|
if ((fp = fopen(name,"r")) == NULL && errno != ENOENT)
|
|
fatal("Error in opening file %s\n",name);
|
|
|
|
return fp;
|
|
}
|
|
|
|
|
|
/*
|
|
* Handle fatal yacc errors.
|
|
*/
|
|
void yyerror(char *s)
|
|
{
|
|
if (currentFile < 0)
|
|
fatal("%s\n", s);
|
|
|
|
fatal("%s:%d: %s\n",
|
|
inputFileStack[currentFile].name,
|
|
inputFileStack[currentFile].lineno,
|
|
s);
|
|
}
|
|
|
|
|
|
/*
|
|
* Handle warnings while parsing.
|
|
*/
|
|
void yywarning(char *s)
|
|
{
|
|
warning("%s:%d: %s\n",
|
|
inputFileStack[currentFile].name,
|
|
inputFileStack[currentFile].lineno,
|
|
s);
|
|
}
|
|
|
|
|
|
/*
|
|
* Handle fatal lex errors.
|
|
*/
|
|
static void fatallex(char *s)
|
|
{
|
|
fatal("%s:%d: Lexical analyser error: %s\n",
|
|
inputFileStack[currentFile].name,
|
|
inputFileStack[currentFile].lineno,
|
|
s);
|
|
}
|