summaryrefslogtreecommitdiff
path: root/colm/loadcolm.cc
diff options
context:
space:
mode:
Diffstat (limited to 'colm/loadcolm.cc')
-rw-r--r--colm/loadcolm.cc1919
1 files changed, 1919 insertions, 0 deletions
diff --git a/colm/loadcolm.cc b/colm/loadcolm.cc
new file mode 100644
index 00000000..e0c4b3cf
--- /dev/null
+++ b/colm/loadcolm.cc
@@ -0,0 +1,1919 @@
+/*
+ * Copyright 2006-2012 Adrian Thurston <thurston@complang.org>
+ */
+
+/* This file is part of Colm.
+ *
+ * Colm is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Colm is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Colm; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <iostream>
+#include <errno.h>
+
+#include "parser.h"
+#include "config.h"
+#include "avltree.h"
+#include "parsedata.h"
+#include "parser.h"
+#include "global.h"
+#include "input.h"
+#include "loadcolm.h"
+#include "if2.h"
+#include "colm/colm.h"
+
+extern RuntimeData main_runtimeData;
+
+InputLoc::InputLoc( ColmLocation *pcloc )
+{
+ if ( pcloc != 0 ) {
+ fileName = pcloc->name;
+ line = pcloc->line;
+ col = pcloc->column;
+ }
+ else {
+ fileName = 0;
+ line = -1;
+ col = -1;
+ }
+}
+
+
+String unescape( const String &s )
+{
+ String out( String::Fresh(), s.length() );
+ char *d = out.data;
+
+ for ( int i = 0; i < s.length(); ) {
+ if ( s[i] == '\\' ) {
+ switch ( s[i+1] ) {
+ case '0': *d++ = '\0'; break;
+ case 'a': *d++ = '\a'; break;
+ case 'b': *d++ = '\b'; break;
+ case 't': *d++ = '\t'; break;
+ case 'n': *d++ = '\n'; break;
+ case 'v': *d++ = '\v'; break;
+ case 'f': *d++ = '\f'; break;
+ case 'r': *d++ = '\r'; break;
+ default: *d++ = s[i+1]; break;
+ }
+ i += 2;
+ }
+ else {
+ *d++ = s[i];
+ i += 1;
+ }
+ }
+ out.chop( d - out.data );
+ return out;
+}
+
+
+struct LoadColm
+:
+ public BaseParser
+{
+ LoadColm( Compiler *pd, const char *inputFileName )
+ :
+ BaseParser( pd ),
+ inputFileName( inputFileName )
+ {}
+
+ const char *inputFileName;
+
+ Literal *walkLexRangeLit( lex_range_lit lexRangeLit )
+ {
+ Literal *literal = 0;
+ if ( lexRangeLit.Lit() != 0 ) {
+ String lit = lexRangeLit.Lit().text().c_str();
+ literal = Literal::cons( lexRangeLit.Lit().loc(), lit, Literal::LitString );
+ }
+ else if ( lexRangeLit.Number() != 0 ) {
+ String num = lexRangeLit.Number().text().c_str();
+ literal = Literal::cons( lexRangeLit.Number().loc(), num, Literal::Number );
+ }
+ return literal;
+ }
+
+ LexFactor *walkLexFactor( lex_factor LexFactorTree )
+ {
+ LexFactor *factor = 0;
+ if ( LexFactorTree.Literal() != 0 ) {
+ String litString = LexFactorTree.Literal().text().c_str();
+ Literal *literal = Literal::cons( LexFactorTree.Literal().loc(),
+ litString, Literal::LitString );
+ factor = LexFactor::cons( literal );
+ }
+ else if ( LexFactorTree.Id() != 0 ) {
+ String id = LexFactorTree.Id().text().c_str();
+ factor = lexRlFactorName( id, LexFactorTree.Id().loc() );
+ }
+ else if ( LexFactorTree.Expr() != 0 ) {
+ lex_expr LexExpr = LexFactorTree.Expr();
+ LexExpression *expr = walkLexExpr( LexExpr );
+ LexJoin *join = LexJoin::cons( expr );
+ factor = LexFactor::cons( join );
+ }
+ else if ( LexFactorTree.Low() != 0 ) {
+ Literal *low = walkLexRangeLit( LexFactorTree.Low() );
+ Literal *high = walkLexRangeLit( LexFactorTree.High() );
+
+ Range *range = Range::cons( low, high );
+ factor = LexFactor::cons( range );
+ }
+ else if ( LexFactorTree.PosData() != 0 ) {
+ ReOrBlock *block = walkRegOrData( LexFactorTree.PosData() );
+ factor = LexFactor::cons( ReItem::cons( block, ReItem::OrBlock ) );
+ }
+ else if ( LexFactorTree.NegData() != 0 ) {
+ ReOrBlock *block = walkRegOrData( LexFactorTree.NegData() );
+ factor = LexFactor::cons( ReItem::cons( block, ReItem::NegOrBlock ) );
+ }
+ else if ( LexFactorTree.Number() != 0 ) {
+ String number = LexFactorTree.Number().text().c_str();
+ factor = LexFactor::cons( Literal::cons( LexFactorTree.Number().loc(),
+ number, Literal::Number ) );
+ }
+ else if ( LexFactorTree.Hex() != 0 ) {
+ String number = LexFactorTree.Hex().text().c_str();
+ factor = LexFactor::cons( Literal::cons( LexFactorTree.Hex().loc(),
+ number, Literal::Number ) );
+ }
+ return factor;
+ }
+
+ LexFactorAug *walkLexFactorAug( lex_factor_rep LexFactorRepTree )
+ {
+ LexFactorRep *factorRep = walkLexFactorRep( LexFactorRepTree );
+ return LexFactorAug::cons( factorRep );
+ }
+
+ LangExpr *walkCodeExpr( code_expr codeExpr )
+ {
+ LangExpr *expr = 0;
+ if ( codeExpr.Expr() != 0 ) {
+ LangExpr *left = walkCodeExpr( codeExpr.Expr() );
+ LangExpr *right = walkCodeRelational( codeExpr.Relational() );
+
+ char type = -1;
+ InputLoc loc;
+ if ( codeExpr.BarBar() != 0 ) {
+ type = OP_LogicalOr;
+ loc = codeExpr.BarBar().loc();
+ }
+ else if ( codeExpr.AmpAmp() != 0 ) {
+ type = OP_LogicalAnd;
+ loc = codeExpr.AmpAmp().loc();
+ }
+
+ expr = LangExpr::cons( loc, left, type, right );
+ }
+ else {
+ expr = walkCodeRelational( codeExpr.Relational() );
+ }
+ return expr;
+ }
+
+ LangStmt *walkStatement( statement Statement )
+ {
+ LangStmt *stmt = 0;
+ if ( Statement.Print() != 0 ) {
+ print_stmt printStmt = Statement.Print();
+ stmt = walkPrintStmt( printStmt );
+ }
+ else if ( Statement.Expr() != 0 ) {
+ expr_stmt exprStmt = Statement.Expr();
+ stmt = walkExprStmt( exprStmt );
+ }
+ else if ( Statement.VarDef() != 0 ) {
+ ObjectField *objField = walkVarDef( Statement.VarDef() );
+ LangExpr *expr = walkOptDefInit( Statement.OptDefInit() );
+ stmt = varDef( objField, expr, LangStmt::AssignType );
+ }
+ else if ( Statement.ForDecl() != 0 ) {
+ pushScope();
+
+ String forDecl = Statement.ForDecl().text().c_str();
+ TypeRef *typeRef = walkTypeRef( Statement.TypeRef() );
+ StmtList *stmtList = walkBlockOrSingle( Statement.BlockOrSingle() );
+
+ LangTerm *langTerm = walkIterCall( Statement.IterCall() );
+
+ stmt = forScope( Statement.ForDecl().loc(), forDecl, typeRef, langTerm, stmtList );
+
+ popScope();
+ }
+ else if ( Statement.IfExpr() != 0 ) {
+ pushScope();
+
+ LangExpr *expr = walkCodeExpr( Statement.IfExpr() );
+ StmtList *stmtList = walkBlockOrSingle( Statement.BlockOrSingle() );
+
+ popScope();
+
+ LangStmt *elsifList = walkElsifList( Statement.ElsifList() );
+ stmt = LangStmt::cons( LangStmt::IfType, expr, stmtList, elsifList );
+
+ }
+ else if ( Statement.WhileExpr() != 0 ) {
+ pushScope();
+ LangExpr *expr = walkCodeExpr( Statement.WhileExpr() );
+ StmtList *stmtList = walkBlockOrSingle( Statement.BlockOrSingle() );
+ stmt = LangStmt::cons( LangStmt::WhileType, expr, stmtList );
+ popScope();
+ }
+ else if ( Statement.LhsVarRef() != 0 ) {
+ LangVarRef *varRef = walkVarRef( Statement.LhsVarRef() );
+ LangExpr *expr = walkCodeExpr( Statement.CodeExpr() );
+ stmt = LangStmt::cons( varRef->loc, LangStmt::AssignType, varRef, expr );
+ }
+ else if ( Statement.YieldVarRef() != 0 ) {
+ LangVarRef *varRef = walkVarRef( Statement.YieldVarRef() );
+ stmt = LangStmt::cons( LangStmt::YieldType, varRef );
+ }
+ else if ( Statement.ReturnExpr() != 0 ) {
+ LangExpr *expr = walkCodeExpr( Statement.ReturnExpr() );
+ stmt = LangStmt::cons( Statement.loc(), LangStmt::ReturnType, expr );
+ }
+ else if ( Statement.Break() != 0 ) {
+ stmt = LangStmt::cons( LangStmt::BreakType );
+ }
+ else if ( Statement.Reject() != 0 ) {
+ stmt = LangStmt::cons( Statement.Reject().loc(), LangStmt::RejectType );
+ }
+ return stmt;
+ }
+
+ StmtList *walkLangStmtList( lang_stmt_list langStmtList )
+ {
+ StmtList *retList = new StmtList;
+ _repeat_statement stmtList = langStmtList.StmtList();
+
+ /* Walk the list of items. */
+ while ( !stmtList.end() ) {
+ statement Statement = stmtList.value();
+ LangStmt *stmt = walkStatement( Statement );
+ if ( stmt != 0 )
+ retList->append( stmt );
+ stmtList = stmtList.next();
+ }
+
+ if ( langStmtList.OptRequire().Require() != 0 ) {
+ pushScope();
+ require_pattern require = langStmtList.OptRequire().Require();
+
+ LangVarRef *varRef = walkVarRef( require.VarRef() );
+ PatternItemList *list = walkPattern( require.Pattern() );
+ LangExpr *expr = match( langStmtList.OptRequire().Require().R().loc(), varRef, list );
+
+ StmtList *reqList = walkLangStmtList( langStmtList.OptRequire().LangStmtList() );
+
+ LangStmt *stmt = LangStmt::cons( LangStmt::IfType, expr, reqList, 0 );
+
+ popScope();
+
+ retList->append( stmt );
+ }
+
+ return retList;
+ }
+
+ LexExpression *walkLexExpr( lex_expr LexExprTree )
+ {
+ if ( LexExprTree.Expr() != 0 ) {
+ LexExpression *leftExpr = walkLexExpr( LexExprTree.Expr() );
+ LexTerm *term = walkLexTerm( LexExprTree.Term() );
+
+ LexExpression *expr = 0;
+ if ( LexExprTree.Bar() != 0 )
+ expr = LexExpression::cons( leftExpr, term, LexExpression::OrType );
+ else if ( LexExprTree.Amp() != 0 )
+ expr = LexExpression::cons( leftExpr, term, LexExpression::IntersectType );
+ else if ( LexExprTree.Dash() != 0 )
+ expr = LexExpression::cons( leftExpr, term, LexExpression::SubtractType );
+ else if ( LexExprTree.DashDash() != 0 )
+ expr = LexExpression::cons( leftExpr, term, LexExpression::StrongSubtractType );
+ return expr;
+ }
+ else {
+ lex_term LexTermTree = LexExprTree.Term();
+ LexTerm *term = walkLexTerm( LexTermTree );
+ LexExpression *expr = LexExpression::cons( term );
+ return expr;
+ }
+ }
+
+
+ void walkTokenDef( token_def TokenDef )
+ {
+ String name = TokenDef.Id().text().c_str();
+
+ bool niLeft = walkOptNoIgnore( TokenDef.NiLeft() );
+ bool niRight = walkOptNoIgnore( TokenDef.NiRight() );
+
+ ObjectDef *objectDef = walkVarDefList( TokenDef.VarDefList() );
+ objectDef->name = name;
+
+ LexJoin *join = 0;
+ if ( TokenDef.OptExpr().Expr() != 0 ) {
+ LexExpression *expr = walkLexExpr( TokenDef.OptExpr().Expr() );
+ join = LexJoin::cons( expr );
+ }
+
+ CodeBlock *translate = walkOptTranslate( TokenDef.OptTranslate() );
+
+ defineToken( TokenDef.Id().loc(), name, join, objectDef, translate, false, niLeft, niRight );
+ }
+
+ String walkOptId( opt_id optId )
+ {
+ String name = 0;
+ if ( optId.Id() != 0 )
+ name = optId.Id().text().c_str();
+ return name;
+ }
+
+ ObjectDef *walkVarDefList( _repeat_var_def varDefList )
+ {
+ ObjectDef *objectDef = ObjectDef::cons( ObjectDef::UserType,
+ String(), pd->nextObjectId++ );
+
+ while ( !varDefList.end() ) {
+ ObjectField *varDef = walkVarDef( varDefList.value() );
+ objVarDef( objectDef, varDef );
+ varDefList = varDefList.next();
+ }
+
+ return objectDef;
+ }
+
+ void walkPreEof( pre_eof PreEof )
+ {
+ ObjectDef *localFrame = blockOpen();
+ StmtList *stmtList = walkLangStmtList( PreEof.LangStmtList() );
+ preEof( PreEof.PreEof().loc(), stmtList, localFrame );
+ blockClose();
+ }
+
+ void walkIgnoreDef( ignore_def IgnoreDef )
+ {
+ String name = walkOptId( IgnoreDef.OptId() );
+ ObjectDef *objectDef = ObjectDef::cons( ObjectDef::UserType, name, pd->nextObjectId++ );
+
+ LexJoin *join = 0;
+ if ( IgnoreDef.OptExpr().Expr() != 0 ) {
+ LexExpression *expr = walkLexExpr( IgnoreDef.OptExpr().Expr() );
+ join = LexJoin::cons( expr );
+ }
+
+ defineToken( IgnoreDef.I().loc(), name, join, objectDef, 0, true, false, false );
+ }
+
+ LangExpr *walkCodeMultiplicitive( code_multiplicitive mult )
+ {
+ LangExpr *expr = 0;
+ if ( mult.Multiplicitive() != 0 ) {
+ LangExpr *left = walkCodeMultiplicitive( mult.Multiplicitive() );
+ LangExpr *right = walkCodeUnary( mult.Unary() );
+
+ if ( mult.Star() != 0 ) {
+ expr = LangExpr::cons( mult.Star().loc(), left, '*', right );
+ }
+ else if ( mult.Fslash() != 0 ) {
+ expr = LangExpr::cons( mult.Fslash().loc(), left, '/', right );
+ }
+ }
+ else {
+ expr = walkCodeUnary( mult.Unary() );
+ }
+ return expr;
+ }
+
+ PatternItemList *walkPatternElTypeOrLit( pattern_el_lel typeOrLit )
+ {
+ NamespaceQual *nspaceQual = walkRegionQual( typeOrLit.RegionQual() );
+ RepeatType repeatType = walkOptRepeat( typeOrLit.OptRepeat() );
+
+ PatternItemList *list = 0;
+ if ( typeOrLit.Id() != 0 ) {
+ String id = typeOrLit.Id().text().c_str();
+ list = patternElNamed( typeOrLit.Id().loc(), nspaceQual, id, repeatType );
+ }
+ else if ( typeOrLit.Lit() != 0 ) {
+ String lit = typeOrLit.Lit().text().c_str();
+ list = patternElType( typeOrLit.Lit().loc(), nspaceQual, lit, repeatType );
+ }
+ return list;
+ }
+
+ LangVarRef *walkOptLabel( opt_label optLabel )
+ {
+ LangVarRef *varRef = 0;
+ if ( optLabel.Id() != 0 ) {
+ String id = optLabel.Id().text().c_str();
+ varRef = LangVarRef::cons( optLabel.Id().loc(), id );
+ }
+ return varRef;
+ }
+
+ PatternItemList *walkPatternEl( pattern_el PatternEl )
+ {
+ PatternItemList *list = 0;
+ if ( PatternEl.LitpatElList() != 0 ) {
+ list = walkLitpatElList( PatternEl.LitpatElList(), PatternEl.Term().Nl() );
+ }
+ else if ( PatternEl.TildeData() != 0 ) {
+ String patternData = PatternEl.TildeData().text().c_str();
+ patternData += '\n';
+ PatternItem *patternItem = PatternItem::cons( PatternEl.TildeData().loc(),
+ patternData, PatternItem::InputText );
+ list = PatternItemList::cons( patternItem );
+ }
+ else if ( PatternEl.OptLabel() != 0 ) {
+ LangVarRef *varRef = walkOptLabel( PatternEl.OptLabel() );
+ PatternItemList *typeOrLitList = walkPatternElTypeOrLit( PatternEl.TypeOrLit() );
+ list = patternEl( varRef, typeOrLitList );
+ }
+ return list;
+ }
+
+ PatternItemList *walkLitpatEl( litpat_el litpatEl )
+ {
+ PatternItemList *list = 0;
+ if ( litpatEl.ConsData() != 0 ) {
+ String consData = unescape( litpatEl.ConsData().text().c_str() );
+ PatternItem *patternItem = PatternItem::cons( litpatEl.ConsData().loc(),
+ consData, PatternItem::InputText );
+ list = PatternItemList::cons( patternItem );
+ }
+ else if ( litpatEl.PatternElList() != 0 ) {
+ list = walkPatternElList( litpatEl.PatternElList() );
+ }
+ return list;
+ }
+
+ PatternItemList *walkLitpatElList( _repeat_litpat_el litpatElList, CONS_NL Nl )
+ {
+ PatternItemList *list = new PatternItemList;
+ while ( !litpatElList.end() ) {
+ PatternItemList *tail = walkLitpatEl( litpatElList.value() );
+ list = patListConcat( list, tail );
+ litpatElList = litpatElList.next();
+ }
+
+ if ( Nl != 0 ) {
+ String nl = unescape( Nl.text().c_str() );
+ PatternItem *patternItem = PatternItem::cons( Nl.loc(), nl, PatternItem::InputText );
+ PatternItemList *term = PatternItemList::cons( patternItem );
+ list = patListConcat( list, term );
+ }
+
+ return list;
+ }
+
+ PatternItemList *walkPatternElList( _repeat_pattern_el patternElList )
+ {
+ PatternItemList *list = new PatternItemList;
+ while ( !patternElList.end() ) {
+ PatternItemList *tail = walkPatternEl( patternElList.value() );
+ list = patListConcat( list, tail );
+ patternElList = patternElList.next();
+ }
+ return list;
+ }
+
+ PatternItemList *walkPattternTopEl( pattern_top_el patternTopEl )
+ {
+ PatternItemList *list = 0;
+ if ( patternTopEl.LitpatElList() != 0 ) {
+ list = walkLitpatElList( patternTopEl.LitpatElList(), patternTopEl.Term().Nl() );
+ }
+ else if ( patternTopEl.TildeData() != 0 ) {
+ String patternData = patternTopEl.TildeData().text().c_str();
+ patternData += '\n';
+ PatternItem *patternItem = PatternItem::cons( patternTopEl.TildeData().loc(),
+ patternData, PatternItem::InputText );
+ list = PatternItemList::cons( patternItem );
+ }
+ else if ( patternTopEl.PatternElList() != 0 ) {
+ list = walkPatternElList( patternTopEl.PatternElList() );
+ }
+ return list;
+ }
+
+ PatternItemList *walkPatternList( pattern_list patternList )
+ {
+ PatternItemList *list = 0;
+ if ( patternList.PatternList() ) {
+ PatternItemList *left = walkPatternList( patternList.PatternList() );
+ PatternItemList *right = walkPattternTopEl( patternList.PatternTopEl() );
+ list = patListConcat( left, right );
+ }
+ else {
+ list = walkPattternTopEl( patternList.PatternTopEl() );
+ }
+ return list;
+ }
+
+ PatternItemList *walkPattern( pattern Pattern )
+ {
+ return walkPatternList( Pattern.PatternList() );
+ }
+
+ LangExpr *walkOptDefInit( opt_def_init optDefInit )
+ {
+ LangExpr *expr = 0;
+ if ( optDefInit.CodeExpr() != 0 )
+ expr = walkCodeExpr( optDefInit.CodeExpr() );
+ return expr;
+ }
+
+ LangStmt *walkExportDef( export_def exportDef )
+ {
+ ObjectField *objField = walkVarDef( exportDef.VarDef() );
+ LangExpr *expr = walkOptDefInit( exportDef.OptDefInit() );
+
+ return exportStmt( objField, LangStmt::AssignType, expr );
+ }
+
+ LangStmt *walkGlobalDef( global_def GlobalDef )
+ {
+ ObjectField *objField = walkVarDef( GlobalDef.VarDef() );
+ LangExpr *expr = walkOptDefInit( GlobalDef.OptDefInit() );
+
+ return globalDef( objField, expr, LangStmt::AssignType );
+ }
+
+ void walkAliasDef( alias_def aliasDef )
+ {
+ String id = aliasDef.Id().text().c_str();
+ TypeRef *typeRef = walkTypeRef( aliasDef.TypeRef() );
+ alias( aliasDef.Id().loc(), id, typeRef );
+ }
+
+ CodeBlock *walkOptTranslate( opt_translate optTranslate )
+ {
+ CodeBlock *block = 0;
+ if ( optTranslate.LangStmtList() != 0 ) {
+ ObjectDef *localFrame = blockOpen();
+ StmtList *stmtList = walkLangStmtList( optTranslate.LangStmtList() );
+ block = CodeBlock::cons( stmtList, localFrame );
+ block->context = contextStack.top();
+ blockClose();
+ }
+ return block;
+ }
+
+ PredDecl *walkPredToken( pred_token predToken )
+ {
+ NamespaceQual *nspaceQual = walkRegionQual( predToken.RegionQual() );
+ PredDecl *predDecl = 0;
+ if ( predToken.Id() != 0 ) {
+ String id = predToken.Id().text().c_str();
+ predDecl = predTokenName( predToken.Id().loc(), nspaceQual, id );
+ }
+ else if ( predToken.Lit() != 0 ) {
+ String lit = predToken.Lit().text().c_str();
+ predDecl = predTokenLit( predToken.Lit().loc(), lit, nspaceQual );
+ }
+ return predDecl;
+ }
+
+ PredDeclList *walkPredTokenList( pred_token_list predTokenList )
+ {
+ PredDeclList *list = 0;
+ if ( predTokenList.PredTokenList() != 0 ) {
+ list = walkPredTokenList( predTokenList.PredTokenList() );
+ PredDecl *predDecl = walkPredToken( predTokenList.PredToken() );
+ list->append( predDecl );
+ }
+ else {
+ PredDecl *predDecl = walkPredToken( predTokenList.PredToken() );
+ list = new PredDeclList;
+ list->append( predDecl );
+ }
+ return list;
+ }
+
+ PredType walkPredType( pred_type predType )
+ {
+ PredType pt;
+ if ( predType.Left() != 0 )
+ pt = PredLeft;
+ else if ( predType.Right() != 0 )
+ pt = PredRight;
+ else if ( predType.NonAssoc() != 0 )
+ pt = PredNonassoc;
+ return pt;
+ }
+
+ void walkPrecedenceDef( precedence_def precedenceDef )
+ {
+ PredType predType = walkPredType( precedenceDef.PredType() );
+ PredDeclList *predDeclList = walkPredTokenList( precedenceDef.PredTokenList() );
+ precedenceStmt( predType, predDeclList );
+ }
+
+ StmtList *walkInclude( include Include )
+ {
+ String lit = Include.File().text().c_str();
+ String file;
+ bool unused;
+ prepareLitString( file, unused, lit, Include.File().loc() );
+
+ const char *argv[2];
+ argv[0] = file.data;
+ argv[1] = 0;
+
+ ColmProgram *program = colmNewProgram( &main_runtimeData, 0 );
+ colmRunProgram( program, 1, argv );
+
+ /* Extract the parse tree. */
+ start Start = ColmTree( program );
+ str Error = ColmError( program );
+
+ if ( Start == 0 ) {
+ gblErrorCount += 1;
+ InputLoc loc = Error.loc();
+ error(loc) << file.data << ": parse error: " << Error.text() << std::endl;
+ return 0;
+ }
+
+ StmtList *stmtList = walkRootItemList( Start.RootItemList() );
+ colmDeleteProgram( program );
+ return stmtList;
+ }
+
+
+ NamespaceQual *walkRegionQual( region_qual regionQual )
+ {
+ NamespaceQual *qual;
+ if ( regionQual.RegionQual() != 0 ) {
+ qual = walkRegionQual( regionQual.RegionQual() );
+ qual->qualNames.append( String( regionQual.Id().text().c_str() ) );
+ }
+ else {
+ qual = NamespaceQual::cons( namespaceStack.top() );
+ }
+ return qual;
+ }
+
+ RepeatType walkOptRepeat( opt_repeat OptRepeat )
+ {
+ RepeatType repeatType = RepeatNone;
+ if ( OptRepeat.Star() != 0 )
+ repeatType = RepeatRepeat;
+ else if ( OptRepeat.Plus() != 0 )
+ repeatType = RepeatList;
+ else if ( OptRepeat.Question() != 0 )
+ repeatType = RepeatOpt;
+ return repeatType;
+ }
+
+ TypeRef *walkTypeRef( type_ref typeRef )
+ {
+ TypeRef *tr = 0;
+
+ if ( typeRef.DirectId() != 0 ) {
+ NamespaceQual *nspaceQual = walkRegionQual( typeRef.RegionQual() );
+ String id = typeRef.DirectId().text().c_str();
+ RepeatType repeatType = walkOptRepeat( typeRef.OptRepeat() );
+ tr = TypeRef::cons( typeRef.DirectId().loc(), nspaceQual, id, repeatType );
+ }
+ else if ( typeRef.PtrId() != 0 ) {
+ NamespaceQual *nspaceQual = walkRegionQual( typeRef.RegionQual() );
+ String id = typeRef.PtrId().text().c_str();
+ RepeatType repeatType = walkOptRepeat( typeRef.OptRepeat() );
+ TypeRef *inner = TypeRef::cons( typeRef.PtrId().loc(), nspaceQual, id, repeatType );
+ tr = TypeRef::cons( typeRef.PtrId().loc(), TypeRef::Ptr, inner );
+ }
+ else if ( typeRef.MapKeyType() != 0 ) {
+ TypeRef *key = walkTypeRef( typeRef.MapKeyType() );
+ TypeRef *value = walkTypeRef( typeRef.MapValueType() );
+ tr = TypeRef::cons( typeRef.loc(), TypeRef::Map, 0, key, value );
+ }
+ else if ( typeRef.ListType() != 0 ) {
+ TypeRef *type = walkTypeRef( typeRef.ListType() );
+ tr = TypeRef::cons( typeRef.loc(), TypeRef::List, 0, type, 0 );
+ }
+ else if ( typeRef.VectorType() != 0 ) {
+ TypeRef *type = walkTypeRef( typeRef.VectorType() );
+ tr = TypeRef::cons( typeRef.loc(), TypeRef::Vector, 0, type, 0 );
+ }
+ else if ( typeRef.ParserType() != 0 ) {
+ TypeRef *type = walkTypeRef( typeRef.ParserType() );
+ tr = TypeRef::cons( typeRef.loc(), TypeRef::Parser, 0, type, 0 );
+ }
+ return tr;
+ }
+
+ StmtList *walkBlockOrSingle( block_or_single blockOrSingle )
+ {
+ StmtList *stmtList = 0;
+ if ( blockOrSingle.Statement() != 0 ) {
+ stmtList = new StmtList;
+ LangStmt *stmt = walkStatement( blockOrSingle.Statement() );
+ stmtList->append( stmt );
+ }
+ else if ( blockOrSingle.LangStmtList() != 0 ) {
+ stmtList = walkLangStmtList( blockOrSingle.LangStmtList() );
+ }
+
+ return stmtList;
+ }
+
+ void walkProdEl( ProdElList *list, prod_el El )
+ {
+ ObjectField *captureField = 0;
+ if ( El.OptName().Name() != 0 ) {
+ String fieldName = El.OptName().Name().text().c_str();
+ captureField = ObjectField::cons( El.OptName().Name().loc(), 0, fieldName );
+ }
+
+ RepeatType repeatType = walkOptRepeat( El.OptRepeat() );
+ NamespaceQual *nspaceQual = walkRegionQual( El.RegionQual() );
+
+ if ( El.Id() != 0 ) {
+ String typeName = El.Id().text().c_str();
+ ProdEl *prodEl = prodElName( El.Id().loc(), typeName,
+ nspaceQual,
+ captureField, repeatType, false );
+ appendProdEl( list, prodEl );
+ }
+ else if ( El.Lit() != 0 ) {
+ String lit = El.Lit().text().c_str();
+ ProdEl *prodEl = prodElLiteral( El.Lit().loc(), lit,
+ nspaceQual,
+ captureField, repeatType, false );
+ appendProdEl( list, prodEl );
+
+ }
+ }
+
+ void walkProdElList( ProdElList *list, prod_el_list ProdElList )
+ {
+ if ( ProdElList.ProdElList() != 0 ) {
+ prod_el_list RightProdElList = ProdElList.ProdElList();
+ walkProdElList( list, RightProdElList );
+ }
+
+ if ( ProdElList.ProdEl() != 0 )
+ walkProdEl( list, ProdElList.ProdEl() );
+ }
+
+ CodeBlock *walkOptReduce( opt_reduce optReduce )
+ {
+ CodeBlock *block = 0;
+ if ( optReduce.LangStmtList() != 0 ) {
+ ObjectDef *localFrame = blockOpen();
+ StmtList *stmtList = walkLangStmtList( optReduce.LangStmtList() );
+
+ block = CodeBlock::cons( stmtList, localFrame );
+ block->context = contextStack.top();
+
+ blockClose();
+ }
+ return block;
+ }
+
+ void walkProdudction( LelDefList *lelDefList, prod Prod )
+ {
+ ProdElList *list = new ProdElList;
+
+ walkProdElList( list, Prod.ProdElList() );
+ CodeBlock *codeBlock = walkOptReduce( Prod.OptReduce() );
+
+ bool commit = Prod.OptCommit().Commit() != 0;
+
+ Production *prod = BaseParser::production( Prod.Open().loc() , list, commit, codeBlock, 0 );
+ prodAppend( lelDefList, prod );
+ }
+
+ void walkProdList( LelDefList *lelDefList, prod_list ProdList )
+ {
+ if ( ProdList.ProdList() != 0 )
+ walkProdList( lelDefList, ProdList.ProdList() );
+
+ walkProdudction( lelDefList, ProdList.Prod() );
+ }
+
+ ReOrItem *walkRegOrChar( reg_or_char regOrChar )
+ {
+ ReOrItem *orItem = 0;
+ if ( regOrChar.Char() != 0 ) {
+ String c = unescape( regOrChar.Char().text().c_str() );
+ orItem = ReOrItem::cons( regOrChar.Char().loc(), c );
+ }
+ else {
+ String low = unescape( regOrChar.Low().text().c_str() );
+ String high = unescape( regOrChar.High().text().c_str() );
+ orItem = ReOrItem::cons( regOrChar.Low().loc(), low[0], high[0] );
+ }
+ return orItem;
+ }
+
+ ReOrBlock *walkRegOrData( reg_or_data regOrData )
+ {
+ ReOrBlock *block = 0;
+ if ( regOrData.Data() != 0 ) {
+ ReOrBlock *left = walkRegOrData( regOrData.Data() );
+ ReOrItem *right = walkRegOrChar( regOrData.Char() );
+ block = lexRegularExprData( left, right );
+ }
+ else {
+ block = ReOrBlock::cons();
+ }
+ return block;
+ }
+
+
+ LexFactorNeg *walkLexFactorNeg( lex_factor_neg &LexFactorNegTree )
+ {
+ if ( LexFactorNegTree.Caret() != 0 ) {
+ lex_factor_neg Rec = LexFactorNegTree.FactorNeg();
+ LexFactorNeg *recNeg = walkLexFactorNeg( Rec );
+ LexFactorNeg *factorNeg = LexFactorNeg::cons( recNeg,
+ LexFactorNeg::CharNegateType );
+ return factorNeg;
+ }
+ else {
+ lex_factor LexFactorTree = LexFactorNegTree.Factor();
+ LexFactor *factor = walkLexFactor( LexFactorTree );
+ LexFactorNeg *factorNeg = LexFactorNeg::cons( factor );
+ return factorNeg;
+ }
+ }
+
+ LexFactorRep *walkLexFactorRep( lex_factor_rep LexFactorRepTree )
+ {
+ LexFactorRep *factorRep = 0;
+ if ( LexFactorRepTree.Star() != 0 ) {
+ lex_factor_rep Rec = LexFactorRepTree.FactorRep();
+ LexFactorRep *recRep = walkLexFactorRep( Rec );
+ factorRep = LexFactorRep::cons( LexFactorRepTree.Star().loc(),
+ recRep, 0, 0, LexFactorRep::StarType );
+ }
+ else if ( LexFactorRepTree.StarStar() != 0 ) {
+ lex_factor_rep Rec = LexFactorRepTree.FactorRep();
+ LexFactorRep *recRep = walkLexFactorRep( Rec );
+ factorRep = LexFactorRep::cons( LexFactorRepTree.StarStar().loc(),
+ recRep, 0, 0, LexFactorRep::StarStarType );
+ }
+ else if ( LexFactorRepTree.Plus() != 0 ) {
+ lex_factor_rep Rec = LexFactorRepTree.FactorRep();
+ LexFactorRep *recRep = walkLexFactorRep( Rec );
+ factorRep = LexFactorRep::cons( LexFactorRepTree.Plus().loc(),
+ recRep, 0, 0, LexFactorRep::PlusType );
+ }
+ else if ( LexFactorRepTree.Question() != 0 ) {
+ lex_factor_rep Rec = LexFactorRepTree.FactorRep();
+ LexFactorRep *recRep = walkLexFactorRep( Rec );
+ factorRep = LexFactorRep::cons( LexFactorRepTree.Question().loc(),
+ recRep, 0, 0, LexFactorRep::OptionalType );
+ }
+ else if ( LexFactorRepTree.Exact() != 0 ) {
+ LexFactorRep *recRep = walkLexFactorRep( LexFactorRepTree.FactorRep() );
+ int low = atoi( LexFactorRepTree.Exact().text().c_str() );
+ factorRep = LexFactorRep::cons( LexFactorRepTree.Exact().loc(),
+ recRep, low, 0, LexFactorRep::ExactType );
+ }
+ else if ( LexFactorRepTree.Max() != 0 ) {
+ LexFactorRep *recRep = walkLexFactorRep( LexFactorRepTree.FactorRep() );
+ int high = atoi( LexFactorRepTree.Max().text().c_str() );
+ factorRep = LexFactorRep::cons( LexFactorRepTree.Max().loc(),
+ recRep, 0, high, LexFactorRep::MaxType );
+ }
+ else if ( LexFactorRepTree.Min() != 0 ) {
+ LexFactorRep *recRep = walkLexFactorRep( LexFactorRepTree.FactorRep() );
+ int low = atoi( LexFactorRepTree.Min().text().c_str() );
+ factorRep = LexFactorRep::cons( LexFactorRepTree.Min().loc(),
+ recRep, low, 0, LexFactorRep::MinType );
+ }
+ else if ( LexFactorRepTree.Low() != 0 ) {
+ LexFactorRep *recRep = walkLexFactorRep( LexFactorRepTree.FactorRep() );
+ int low = atoi( LexFactorRepTree.Low().text().c_str() );
+ int high = atoi( LexFactorRepTree.High().text().c_str() );
+ factorRep = LexFactorRep::cons( LexFactorRepTree.Low().loc(),
+ recRep, low, high, LexFactorRep::RangeType );
+ }
+ else {
+ lex_factor_neg LexFactorNegTree = LexFactorRepTree.FactorNeg();
+ LexFactorNeg *factorNeg = walkLexFactorNeg( LexFactorNegTree );
+ factorRep = LexFactorRep::cons( factorNeg );
+ }
+
+ return factorRep;
+ }
+
+ LexTerm *walkLexTerm( lex_term LexTermTree )
+ {
+ LexTerm *term = 0;
+ if ( LexTermTree.Term() != 0 ) {
+ LexTerm *leftTerm = walkLexTerm( LexTermTree.Term() );
+ LexFactorAug *factorAug = walkLexFactorAug( LexTermTree.FactorRep() );
+
+ if ( LexTermTree.OptDot() != 0 ) {
+ term = LexTerm::cons( leftTerm, factorAug, LexTerm::ConcatType );
+ }
+ else if ( LexTermTree.ColonGt() != 0 ) {
+ term = LexTerm::cons( leftTerm, factorAug, LexTerm::RightStartType );
+ }
+ else if ( LexTermTree.ColonGtGt() != 0 ) {
+ term = LexTerm::cons( leftTerm, factorAug, LexTerm::RightFinishType );
+ }
+ else if ( LexTermTree.LtColon() != 0 ) {
+ term = LexTerm::cons( leftTerm, factorAug, LexTerm::LeftType );
+ }
+ }
+ else {
+ lex_factor_rep LexFactorRepTree = LexTermTree.FactorRep();
+ LexFactorAug *factorAug = walkLexFactorAug( LexFactorRepTree );
+ term = LexTerm::cons( factorAug );
+ }
+ return term;
+ }
+
+ void walkRlDef( rl_def rlDef )
+ {
+ String id = rlDef.Id().text().c_str();
+
+ lex_expr LexExpr = rlDef.Expr();
+ LexExpression *expr = walkLexExpr( LexExpr );
+ LexJoin *join = LexJoin::cons( expr );
+
+ addRegularDef( rlDef.Id().loc(), namespaceStack.top(), id, join );
+ }
+
+ void walkLexRegion( region_def regionDef )
+ {
+ pushRegionSet( regionDef.loc() );
+ walkRootItemList( regionDef.RootItemList() );
+ popRegionSet();
+ }
+
+ void walkCflDef( cfl_def cflDef )
+ {
+ String name = cflDef.DefId().text().c_str();
+ ObjectDef *objectDef = walkVarDefList( cflDef.VarDefList() );
+ objectDef->name = name;
+
+ LelDefList *defList = new LelDefList;
+ walkProdList( defList, cflDef.ProdList() );
+
+ bool reduceFirst = cflDef.OptReduceFirst().ReduceFirst() != 0;
+
+ NtDef *ntDef = NtDef::cons( name, namespaceStack.top(),
+ contextStack.top(), reduceFirst );
+
+ BaseParser::cflDef( ntDef, objectDef, defList );
+ }
+
+ ExprVect *walkCodeExprList( _repeat_code_expr codeExprList )
+ {
+ ExprVect *exprVect = new ExprVect;
+ while ( !codeExprList.end() ) {
+ code_expr codeExpr = codeExprList.value();
+ LangExpr *expr = walkCodeExpr( codeExpr );
+ exprVect->append( expr );
+ codeExprList = codeExprList.next();
+ }
+ return exprVect;
+ }
+
+ LangStmt *walkPrintStmt( print_stmt &printStmt )
+ {
+ _repeat_code_expr codeExprList = printStmt.CodeExprList();
+ ExprVect *exprVect = walkCodeExprList( codeExprList );
+
+ LangStmt::Type type;
+ if ( printStmt.Tree() != 0 )
+ type = LangStmt::PrintType;
+ else if ( printStmt.PrintStream() != 0 )
+ type = LangStmt::PrintStreamType;
+ else if ( printStmt.Xml() != 0 )
+ type = LangStmt::PrintXMLType;
+ else if ( printStmt.XmlAc() != 0 )
+ type = LangStmt::PrintXMLACType;
+
+ return LangStmt::cons( printStmt.O().loc(), type, exprVect );
+ }
+
+ QualItemVect *walkQual( qual &Qual )
+ {
+ QualItemVect *qualItemVect;
+ qual RecQual = Qual.Qual();
+ if ( RecQual != 0 ) {
+ qualItemVect = walkQual( RecQual );
+ String id = Qual.Id().text().c_str();
+ QualItem::Type type = Qual.Dot() != 0 ? QualItem::Dot : QualItem::Arrow;
+ qualItemVect->append( QualItem( Qual.Id().loc(), id, type ) );
+ }
+ else {
+ qualItemVect = new QualItemVect;
+ }
+ return qualItemVect;
+ }
+
+ LangVarRef *walkVarRef( var_ref varRef )
+ {
+ qual Qual = varRef.Qual();
+ QualItemVect *qualItemVect = walkQual( Qual );
+ String id = varRef.Id().text().c_str();
+ LangVarRef *langVarRef = LangVarRef::cons( varRef.Id().loc(), qualItemVect, id );
+ return langVarRef;
+ }
+
+ ObjectField *walkOptCapture( opt_capture optCapture )
+ {
+ ObjectField *objField = 0;
+ if ( optCapture.Id() != 0 ) {
+ String id = optCapture.Id().text().c_str();
+ objField = ObjectField::cons( optCapture.Id().loc(), 0, id );
+ }
+ return objField;
+ }
+
+ /*
+ * Constructor
+ */
+
+ ConsItemList *walkLitConsEl( lit_cons_el litConsEl )
+ {
+ ConsItemList *list = 0;
+ if ( litConsEl.ConsData() != 0 ) {
+ String consData = unescape( litConsEl.ConsData().text().c_str() );
+ ConsItem *consItem = ConsItem::cons( litConsEl.ConsData().loc(),
+ ConsItem::InputText, consData );
+ list = ConsItemList::cons( consItem );
+ }
+ else if ( litConsEl.ConsElList() != 0 ) {
+ list = walkConsElList( litConsEl.ConsElList() );
+ }
+ return list;
+ }
+
+ ConsItemList *walkLitConsElList( _repeat_lit_cons_el litConsElList, CONS_NL Nl )
+ {
+ ConsItemList *list = new ConsItemList;
+ while ( !litConsElList.end() ) {
+ ConsItemList *extension = walkLitConsEl( litConsElList.value() );
+ list = consListConcat( list, extension );
+ litConsElList = litConsElList.next();
+ }
+
+ if ( Nl != 0 ) {
+ String consData = unescape( Nl.text().c_str() );
+ ConsItem *consItem = ConsItem::cons( Nl.loc(), ConsItem::InputText, consData );
+ ConsItemList *term = ConsItemList::cons( consItem );
+ list = consListConcat( list, term );
+ }
+
+ return list;
+ }
+
+ ConsItemList *walkConsEl( cons_el consEl )
+ {
+ ConsItemList *list = 0;
+ if ( consEl.Lit() != 0 ) {
+ NamespaceQual *nspaceQual = walkRegionQual( consEl.RegionQual() );
+ String lit = consEl.Lit().text().c_str();
+ list = consElLiteral( consEl.Lit().loc(), lit, nspaceQual );
+ }
+ else if ( consEl.TildeData() != 0 ) {
+ String consData = consEl.TildeData().text().c_str();
+ consData += '\n';
+ ConsItem *consItem = ConsItem::cons( consEl.TildeData().loc(),
+ ConsItem::InputText, consData );
+ list = ConsItemList::cons( consItem );
+ }
+ else if ( consEl.CodeExpr() != 0 ) {
+ LangExpr *consExpr = walkCodeExpr( consEl.CodeExpr() );
+ ConsItem *consItem = ConsItem::cons( consExpr->loc, ConsItem::ExprType, consExpr );
+ list = ConsItemList::cons( consItem );
+ }
+ else if ( consEl.LitConsElList() != 0 ) {
+ list = walkLitConsElList( consEl.LitConsElList(), consEl.Term().Nl() );
+ }
+ return list;
+ }
+
+ ConsItemList *walkConsElList( _repeat_cons_el consElList )
+ {
+ ConsItemList *list = new ConsItemList;
+ while ( !consElList.end() ) {
+ ConsItemList *extension = walkConsEl( consElList.value() );
+ list = consListConcat( list, extension );
+ consElList = consElList.next();
+ }
+ return list;
+ }
+
+ ConsItemList *walkConsTopEl( cons_top_el consTopEl )
+ {
+ ConsItemList *list = 0;
+ if ( consTopEl.LitConsElList() != 0 )
+ list = walkLitConsElList( consTopEl.LitConsElList(), consTopEl.Term().Nl() );
+ else if ( consTopEl.TildeData() != 0 ) {
+ String consData = consTopEl.TildeData().text().c_str();
+ consData += '\n';
+ ConsItem *consItem = ConsItem::cons( consTopEl.TildeData().loc(),
+ ConsItem::InputText, consData );
+ list = ConsItemList::cons( consItem );
+ }
+ else if ( consTopEl.ConsElList() != 0 ) {
+ list = walkConsElList( consTopEl.ConsElList() );
+ }
+ return list;
+ }
+
+ ConsItemList *walkConsList( cons_list consList )
+ {
+ ConsItemList *list = walkConsTopEl( consList.ConsTopEl() );
+
+ if ( consList.ConsList() != 0 ) {
+ ConsItemList *extension = walkConsList( consList.ConsList() );
+ consListConcat( list, extension );
+ }
+
+ return list;
+ }
+
+ ConsItemList *walkConstructor( constructor Constructor )
+ {
+ ConsItemList *list = walkConsList( Constructor.ConsList() );
+ return list;
+ }
+
+ /*
+ * String
+ */
+
+ ConsItemList *walkLitStringEl( lit_string_el litStringEl )
+ {
+ ConsItemList *list = 0;
+ if ( litStringEl.ConsData() != 0 ) {
+ String consData = unescape( litStringEl.ConsData().text().c_str() );
+ ConsItem *stringItem = ConsItem::cons( litStringEl.ConsData().loc(),
+ ConsItem::InputText, consData );
+ list = ConsItemList::cons( stringItem );
+ }
+ else if ( litStringEl.StringElList() != 0 ) {
+ list = walkStringElList( litStringEl.StringElList() );
+ }
+ return list;
+ }
+
+ ConsItemList *walkLitStringElList( _repeat_lit_string_el litStringElList, CONS_NL Nl )
+ {
+ ConsItemList *list = new ConsItemList;
+ while ( !litStringElList.end() ) {
+ ConsItemList *extension = walkLitStringEl( litStringElList.value() );
+ list = consListConcat( list, extension );
+ litStringElList = litStringElList.next();
+ }
+
+ if ( Nl != 0 ) {
+ String consData = unescape( Nl.text().c_str() );
+ ConsItem *consItem = ConsItem::cons( Nl.loc(), ConsItem::InputText, consData );
+ ConsItemList *term = ConsItemList::cons( consItem );
+ list = consListConcat( list, term );
+ }
+ return list;
+ }
+
+ ConsItemList *walkStringEl( string_el stringEl )
+ {
+ ConsItemList *list = 0;
+ if ( stringEl.LitStringElList() != 0 ) {
+ list = walkLitStringElList( stringEl.LitStringElList(), stringEl.Term().Nl() );
+ }
+ else if ( stringEl.TildeData() != 0 ) {
+ String consData = stringEl.TildeData().text().c_str();
+ consData += '\n';
+ ConsItem *consItem = ConsItem::cons( stringEl.TildeData().loc(),
+ ConsItem::InputText, consData );
+ list = ConsItemList::cons( consItem );
+ }
+ else if ( stringEl.CodeExpr() != 0 ) {
+ LangExpr *consExpr = walkCodeExpr( stringEl.CodeExpr() );
+ ConsItem *consItem = ConsItem::cons( consExpr->loc, ConsItem::ExprType, consExpr );
+ list = ConsItemList::cons( consItem );
+ }
+ return list;
+ }
+
+ ConsItemList *walkStringElList( _repeat_string_el stringElList )
+ {
+ ConsItemList *list = new ConsItemList;
+ while ( !stringElList.end() ) {
+ ConsItemList *extension = walkStringEl( stringElList.value() );
+ list = consListConcat( list, extension );
+ stringElList = stringElList.next();
+ }
+ return list;
+ }
+
+ ConsItemList *walkStringTopEl( string_top_el stringTopEl )
+ {
+ ConsItemList *list = 0;
+ if ( stringTopEl.LitStringElList() != 0 )
+ list = walkLitStringElList( stringTopEl.LitStringElList(), stringTopEl.Term().Nl() );
+ else if ( stringTopEl.TildeData() != 0 ) {
+ String consData = stringTopEl.TildeData().text().c_str();
+ consData += '\n';
+ ConsItem *consItem = ConsItem::cons( stringTopEl.TildeData().loc(),
+ ConsItem::InputText, consData );
+ list = ConsItemList::cons( consItem );
+ }
+ else if ( stringTopEl.StringElList() != 0 ) {
+ list = walkStringElList( stringTopEl.StringElList() );
+ }
+ return list;
+ }
+
+ ConsItemList *walkStringList( string_list stringList )
+ {
+ ConsItemList *list = walkStringTopEl( stringList.StringTopEl() );
+
+ if ( stringList.StringList() != 0 ) {
+ ConsItemList *extension = walkStringList( stringList.StringList() );
+ consListConcat( list, extension );
+ }
+
+ return list;
+ }
+
+ ConsItemList *walkString( cstring String )
+ {
+ ConsItemList *list = walkStringList( String.StringList() );
+ return list;
+ }
+
+ /*
+ * Accum
+ */
+
+ ConsItemList *walkLitAccumEl( lit_accum_el litAccumEl )
+ {
+ ConsItemList *list = 0;
+ if ( litAccumEl.ConsData() != 0 ) {
+ String consData = unescape( litAccumEl.ConsData().text().c_str() );
+ ConsItem *consItem = ConsItem::cons( litAccumEl.ConsData().loc(),
+ ConsItem::InputText, consData );
+ list = ConsItemList::cons( consItem );
+ }
+ else if ( litAccumEl.AccumElList() != 0 ) {
+ list = walkAccumElList( litAccumEl.AccumElList() );
+ }
+ return list;
+ }
+
+ ConsItemList *walkLitAccumElList( _repeat_lit_accum_el litAccumElList, CONS_NL Nl )
+ {
+ ConsItemList *list = new ConsItemList;
+ while ( !litAccumElList.end() ) {
+ ConsItemList *extension = walkLitAccumEl( litAccumElList.value() );
+ list = consListConcat( list, extension );
+ litAccumElList = litAccumElList.next();
+ }
+
+ if ( Nl != 0 ) {
+ String consData = unescape( Nl.text().c_str() );
+ ConsItem *consItem = ConsItem::cons( Nl.loc(), ConsItem::InputText, consData );
+ ConsItemList *term = ConsItemList::cons( consItem );
+ list = consListConcat( list, term );
+ }
+
+ return list;
+ }
+
+ ConsItemList *walkAccumEl( accum_el accumEl )
+ {
+ ConsItemList *list = 0;
+ if ( accumEl.LitAccumElList() != 0 ) {
+ list = walkLitAccumElList( accumEl.LitAccumElList(), accumEl.Term().Nl() );
+ }
+ else if ( accumEl.TildeData() != 0 ) {
+ String consData = accumEl.TildeData().text().c_str();
+ consData += '\n';
+ ConsItem *consItem = ConsItem::cons( accumEl.TildeData().loc(),
+ ConsItem::InputText, consData );
+ list = ConsItemList::cons( consItem );
+ }
+ else if ( accumEl.CodeExpr() != 0 ) {
+ LangExpr *accumExpr = walkCodeExpr( accumEl.CodeExpr() );
+ ConsItem *consItem = ConsItem::cons( accumExpr->loc, ConsItem::ExprType, accumExpr );
+ list = ConsItemList::cons( consItem );
+ }
+ return list;
+ }
+
+ ConsItemList *walkAccumElList( _repeat_accum_el accumElList )
+ {
+ ConsItemList *list = new ConsItemList;
+ while ( !accumElList.end() ) {
+ ConsItemList *extension = walkAccumEl( accumElList.value() );
+ list = consListConcat( list, extension );
+ accumElList = accumElList.next();
+ }
+ return list;
+ }
+
+ ConsItemList *walkAccumTopEl( accum_top_el accumTopEl )
+ {
+ ConsItemList *list = 0;
+ if ( accumTopEl.LitAccumElList() != 0 )
+ list = walkLitAccumElList( accumTopEl.LitAccumElList(), accumTopEl.Term().Nl() );
+ else if ( accumTopEl.TildeData() != 0 ) {
+ String consData = accumTopEl.TildeData().text().c_str();
+ consData += '\n';
+ ConsItem *consItem = ConsItem::cons( accumTopEl.TildeData().loc(),
+ ConsItem::InputText, consData );
+ list = ConsItemList::cons( consItem );
+ }
+ else if ( accumTopEl.AccumElList() != 0 ) {
+ list = walkAccumElList( accumTopEl.AccumElList() );
+ }
+ return list;
+ }
+
+ ConsItemList *walkAccumList( accum_list accumList )
+ {
+ ConsItemList *list = walkAccumTopEl( accumList.AccumTopEl() );
+
+ if ( accumList.AccumList() != 0 ) {
+ ConsItemList *extension = walkAccumList( accumList.AccumList() );
+ consListConcat( list, extension );
+ }
+
+ return list;
+ }
+
+ ConsItemList *walkAccumulate( accumulate Accumulate )
+ {
+ ConsItemList *list = walkAccumList( Accumulate.AccumList() );
+ return list;
+ }
+
+ void walkFieldInit( FieldInitVect *list, field_init fieldInit )
+ {
+ LangExpr *expr = walkCodeExpr( fieldInit.CodeExpr() );
+ FieldInit *init = FieldInit::cons( expr->loc, "_name", expr );
+ list->append( init );
+ }
+
+ FieldInitVect *walkOptFieldInit( opt_field_init optFieldInit )
+ {
+ FieldInitVect *list = 0;
+ if ( optFieldInit.FieldInitList() != 0 ) {
+ list = new FieldInitVect;
+ _repeat_field_init fieldInitList = optFieldInit.FieldInitList();
+ while ( !fieldInitList.end() ) {
+ walkFieldInit( list, fieldInitList.value() );
+ fieldInitList = fieldInitList.next();
+ }
+ }
+ return list;
+ }
+
+ LangExpr *walkCodeFactor( code_factor codeFactor )
+ {
+ LangExpr *expr = 0;
+ if ( codeFactor.VarRef() != 0 ) {
+ var_ref varRef = codeFactor.VarRef();
+ LangVarRef *langVarRef = walkVarRef( varRef );
+
+ LangTerm *term = 0;
+ if ( codeFactor.CodeExprList() == 0 ) {
+ term = LangTerm::cons( langVarRef->loc, LangTerm::VarRefType, langVarRef );
+ }
+ else {
+ ExprVect *exprVect = walkCodeExprList( codeFactor.CodeExprList() );
+ term = LangTerm::cons( langVarRef->loc, langVarRef, exprVect );
+ }
+
+ expr = LangExpr::cons( term );
+ }
+ else if ( codeFactor.Number() != 0 ) {
+ String number = codeFactor.Number().text().c_str();
+ LangTerm *term = LangTerm::cons( codeFactor.Number().loc(),
+ LangTerm::NumberType, number );
+ expr = LangExpr::cons( term );
+ }
+ else if ( codeFactor.Lit() != 0 ) {
+ String lit = codeFactor.Lit().text().c_str();
+ LangTerm *term = LangTerm::cons( codeFactor.Lit().loc(), LangTerm::StringType, lit );
+ expr = LangExpr::cons( term );
+ }
+ else if ( codeFactor.Parse() != 0 ) {
+ /* The type we are parsing. */
+ type_ref typeRefTree = codeFactor.TypeRef();
+ TypeRef *typeRef = walkTypeRef( typeRefTree );
+ ObjectField *objField = walkOptCapture( codeFactor.OptCapture() );
+ FieldInitVect *init = walkOptFieldInit( codeFactor.OptFieldInit() );
+ ConsItemList *list = walkAccumulate( codeFactor.Accumulate() );
+
+ expr = parseCmd( codeFactor.Parse().loc(), false, objField, typeRef, init, list );
+ }
+ else if ( codeFactor.ParseStop() != 0 ) {
+ /* The type we are parsing. */
+ type_ref typeRefTree = codeFactor.TypeRef();
+ TypeRef *typeRef = walkTypeRef( typeRefTree );
+ ObjectField *objField = walkOptCapture( codeFactor.OptCapture() );
+ FieldInitVect *init = walkOptFieldInit( codeFactor.OptFieldInit() );
+ ConsItemList *list = walkAccumulate( codeFactor.Accumulate() );
+
+ expr = parseCmd( codeFactor.ParseStop().loc(), true, objField, typeRef, init, list );
+ }
+ else if ( codeFactor.Cons() != 0 ) {
+ /* The type we are parsing. */
+ type_ref typeRefTree = codeFactor.TypeRef();
+ TypeRef *typeRef = walkTypeRef( typeRefTree );
+ ObjectField *objField = walkOptCapture( codeFactor.OptCapture() );
+ ConsItemList *list = walkConstructor( codeFactor.Constructor() );
+ FieldInitVect *init = walkOptFieldInit( codeFactor.OptFieldInit() );
+
+ expr = construct( codeFactor.Cons().loc(), objField, list, typeRef, init );
+ }
+ else if ( codeFactor.Send() != 0 ) {
+ LangVarRef *varRef = walkVarRef( codeFactor.ToVarRef() );
+ ConsItemList *list = walkAccumulate( codeFactor.Accumulate() );
+ expr = send( codeFactor.Send().loc(), varRef, list );
+ }
+ else if ( codeFactor.Nil() != 0 ) {
+ expr = LangExpr::cons( LangTerm::cons( codeFactor.Nil().loc(),
+ LangTerm::NilType ) );
+ }
+ else if ( codeFactor.True() != 0 ) {
+ expr = LangExpr::cons( LangTerm::cons( codeFactor.True().loc(),
+ LangTerm::TrueType ) );
+ }
+ else if ( codeFactor.False() != 0 ) {
+ expr = LangExpr::cons( LangTerm::cons( codeFactor.False().loc(),
+ LangTerm::FalseType ) );
+ }
+ else if ( codeFactor.ParenCodeExpr() != 0 ) {
+ expr = walkCodeExpr( codeFactor.ParenCodeExpr() );
+ }
+ else if ( codeFactor.String() != 0 ) {
+ ConsItemList *list = walkString( codeFactor.String() );
+ expr = LangExpr::cons( LangTerm::cons( codeFactor.String().loc(), list ) );
+ }
+ else if ( codeFactor.MatchVarRef() != 0 ) {
+ LangVarRef *varRef = walkVarRef( codeFactor.MatchVarRef() );
+ PatternItemList *list = walkPattern( codeFactor.Pattern() );
+ expr = match( codeFactor.loc(), varRef, list );
+ }
+ else if ( codeFactor.InVarRef() != 0 ) {
+ TypeRef *typeRef = walkTypeRef( codeFactor.TypeRef() );
+ LangVarRef *varRef = walkVarRef( codeFactor.InVarRef() );
+ expr = LangExpr::cons( LangTerm::cons( typeRef->loc,
+ LangTerm::SearchType, typeRef, varRef ) );
+ }
+ else if ( codeFactor.MakeTreeExprList() != 0 ) {
+ ExprVect *exprList = walkCodeExprList( codeFactor.MakeTreeExprList() );
+ expr = LangExpr::cons( LangTerm::cons( codeFactor.loc(),
+ LangTerm::MakeTreeType, exprList ) );
+ }
+ else if ( codeFactor.MakeTokenExprList() != 0 ) {
+ ExprVect *exprList = walkCodeExprList( codeFactor.MakeTokenExprList() );
+ expr = LangExpr::cons( LangTerm::cons( codeFactor.loc(),
+ LangTerm::MakeTokenType, exprList ) );
+ }
+ else if ( codeFactor.TypeIdTypeRef() != 0 ) {
+ TypeRef *typeRef = walkTypeRef( codeFactor.TypeIdTypeRef() );
+ expr = LangExpr::cons( LangTerm::cons( codeFactor.loc(),
+ LangTerm::TypeIdType, typeRef ) );
+ }
+ else if ( codeFactor.NewCodeFactor() != 0 ) {
+ LangExpr *newExpr = walkCodeFactor( codeFactor.NewCodeFactor() );
+ expr = LangExpr::cons( LangTerm::cons( codeFactor.loc(),
+ LangTerm::NewType, newExpr ) );
+ }
+ return expr;
+ }
+
+ LangExpr *walkCodeAdditive( code_additive additive )
+ {
+ LangExpr *expr = 0;
+ if ( additive.Plus() != 0 ) {
+ LangExpr *left = walkCodeAdditive( additive.Additive() );
+ LangExpr *right = walkCodeMultiplicitive( additive.Multiplicitive() );
+ expr = LangExpr::cons( additive.Plus().loc(), left, '+', right );
+ }
+ else if ( additive.Minus() != 0 ) {
+ LangExpr *left = walkCodeAdditive( additive.Additive() );
+ LangExpr *right = walkCodeMultiplicitive( additive.Multiplicitive() );
+ expr = LangExpr::cons( additive.Minus().loc(), left, '-', right );
+ }
+ else {
+ expr = walkCodeMultiplicitive( additive.Multiplicitive() );
+ }
+ return expr;
+ }
+
+
+ LangExpr *walkCodeUnary( code_unary unary )
+ {
+ LangExpr *expr = walkCodeFactor( unary.Factor() );
+
+ if ( unary.Bang() != 0 ) {
+ expr = LangExpr::cons( unary.Bang().loc(), '!', expr );
+ }
+ else if ( unary.Dollar() != 0 ) {
+ expr = LangExpr::cons( unary.Dollar().loc(), '$', expr );
+ }
+ else if ( unary.Caret() != 0 ) {
+ expr = LangExpr::cons( unary.Caret().loc(), '^', expr );
+ }
+ else if ( unary.Percent() != 0 ) {
+ expr = LangExpr::cons( unary.Percent().loc(), '%', expr );
+ }
+
+ return expr;
+ }
+
+
+ LangExpr *walkCodeRelational( code_relational codeRelational )
+ {
+ LangExpr *expr = 0;
+ if ( codeRelational.Relational() != 0 ) {
+ LangExpr *left = walkCodeRelational( codeRelational.Relational() );
+ LangExpr *right = walkCodeAdditive( codeRelational.Additive() );
+
+ if ( codeRelational.EqEq() != 0 ) {
+ expr = LangExpr::cons( codeRelational.EqEq().loc(), left, OP_DoubleEql, right );
+ }
+ if ( codeRelational.Neq() != 0 ) {
+ expr = LangExpr::cons( codeRelational.Neq().loc(), left, OP_NotEql, right );
+ }
+ else if ( codeRelational.Lt() != 0 ) {
+ expr = LangExpr::cons( codeRelational.Lt().loc(), left, '<', right );
+ }
+ else if ( codeRelational.Gt() != 0 ) {
+ expr = LangExpr::cons( codeRelational.Gt().loc(), left, '>', right );
+ }
+ else if ( codeRelational.LtEq() != 0 ) {
+ expr = LangExpr::cons( codeRelational.LtEq().loc(), left, OP_LessEql, right );
+ }
+ else if ( codeRelational.GtEq() != 0 ) {
+ expr = LangExpr::cons( codeRelational.GtEq().loc(), left, OP_GrtrEql, right );
+ }
+ }
+ else {
+ expr = walkCodeAdditive( codeRelational.Additive() );
+ }
+ return expr;
+ }
+
+ LangStmt *walkExprStmt( expr_stmt &exprStmt )
+ {
+ LangStmt *stmt;
+ if ( exprStmt.CodeExpr() != 0 ) {
+ code_expr codeExpr = exprStmt.CodeExpr();
+ LangExpr *expr = walkCodeExpr( codeExpr );
+ stmt = LangStmt::cons( expr->loc, LangStmt::ExprType, expr );
+ }
+ return stmt;
+ }
+
+ ObjectField *walkVarDef( var_def varDef )
+ {
+ String id = varDef.Id().text().c_str();
+ TypeRef *typeRef = walkTypeRef( varDef.TypeRef() );
+ return ObjectField::cons( varDef.Id().loc(), typeRef, id );
+ }
+
+ LangTerm *walkIterCall( iter_call IterCall )
+ {
+ LangTerm *langTerm = 0;
+ if ( IterCall.Id() != 0 ) {
+ String tree = IterCall.Id().text().c_str();
+ langTerm = LangTerm::cons( IterCall.Id().loc(),
+ LangTerm::VarRefType, LangVarRef::cons( IterCall.Id().loc(), tree ) );
+ }
+ else {
+ LangVarRef *varRef = walkVarRef( IterCall.VarRef() );
+ ExprVect *exprVect = walkCodeExprList( IterCall.CodeExprList() );
+ langTerm = LangTerm::cons( varRef->loc, varRef, exprVect );
+ }
+
+ return langTerm;
+ }
+
+
+ LangStmt *walkElsifClause( elsif_clause elsifClause )
+ {
+ pushScope();
+ LangExpr *expr = walkCodeExpr( elsifClause.ElsifExpr() );
+ StmtList *stmtList = walkBlockOrSingle( elsifClause.BlockOrSingle() );
+ LangStmt *stmt = LangStmt::cons( LangStmt::IfType, expr, stmtList, 0 );
+ popScope();
+ return stmt;
+ }
+
+ LangStmt *walkOptionalElse( optional_else optionalElse )
+ {
+ LangStmt *stmt = 0;
+ if ( optionalElse.BlockOrSingle() != 0 ) {
+ pushScope();
+ StmtList *stmtList = walkBlockOrSingle( optionalElse.BlockOrSingle() );
+ stmt = LangStmt::cons( LangStmt::ElseType, stmtList );
+ popScope();
+ }
+ return stmt;
+ }
+
+ LangStmt *walkElsifList( elsif_list elsifList )
+ {
+ LangStmt *stmt = 0;
+ if ( elsifList.ElsifList() != 0 ) {
+ stmt = walkElsifClause( elsifList.ElsifClause() );
+ stmt->elsePart = walkElsifList( elsifList.ElsifList() );
+ }
+ else {
+ stmt = walkOptionalElse( elsifList.OptionalElse() );
+ }
+ return stmt;
+ }
+
+ void walkContextVarDef( context_var_def ContextVarDef )
+ {
+ ObjectField *objField = walkVarDef( ContextVarDef.VarDef() );
+ contextVarDef( objField->loc, objField );
+ }
+
+ TypeRef *walkReferenceTypeRef( reference_type_ref ReferenceTypeRef )
+ {
+ TypeRef *typeRef = walkTypeRef( ReferenceTypeRef.TypeRef() );
+ return TypeRef::cons( ReferenceTypeRef.R().loc(), TypeRef::Ref, typeRef );
+ }
+
+ ObjectField *walkParamVarDef( param_var_def paramVarDef )
+ {
+ String id = paramVarDef.Id().text().c_str();
+ TypeRef *typeRef = 0;
+
+ if ( paramVarDef.TypeRef() != 0 )
+ typeRef = walkTypeRef( paramVarDef.TypeRef() );
+ else
+ typeRef = walkReferenceTypeRef( paramVarDef.RefTypeRef() );
+
+ return addParam( paramVarDef.Id().loc(), typeRef, id );
+ }
+
+ ParameterList *walkParamVarDefList( _repeat_param_var_def paramVarDefList )
+ {
+ ParameterList *paramList = new ParameterList;
+ while ( !paramVarDefList.end() ) {
+ ObjectField *param = walkParamVarDef( paramVarDefList.value() );
+ appendParam( paramList, param );
+ paramVarDefList = paramVarDefList.next();
+ }
+ return paramList;
+ }
+
+ void walkFunctionDef( function_def FunctionDef )
+ {
+ ObjectDef *localFrame = blockOpen();
+
+ TypeRef *typeRef = walkTypeRef( FunctionDef.TypeRef() );
+ String id = FunctionDef.Id().text().c_str();
+ ParameterList *paramList = walkParamVarDefList( FunctionDef.ParamVarDefList() );
+ StmtList *stmtList = walkLangStmtList( FunctionDef.LangStmtList() );
+ functionDef( stmtList, localFrame, paramList, typeRef, id );
+
+ blockClose();
+ }
+
+ void walkIterDef( iter_def IterDef )
+ {
+ ObjectDef *localFrame = blockOpen();
+
+ String id = IterDef.Id().text().c_str();
+ ParameterList *paramList = walkParamVarDefList( IterDef.ParamVarDefList() );
+ StmtList *stmtList = walkLangStmtList( IterDef.LangStmtList() );
+ iterDef( stmtList, localFrame, paramList, id );
+
+ blockClose();
+ }
+
+ void walkContextItem( context_item contextItem )
+ {
+ if ( contextItem.RlDef() != 0 ) {
+ walkRlDef( contextItem.RlDef() );
+ }
+ else if ( contextItem.ContextVarDef() != 0 ) {
+ walkContextVarDef( contextItem.ContextVarDef() );
+ }
+ else if ( contextItem.TokenDef() != 0 ) {
+ walkTokenDef( contextItem.TokenDef() );
+ }
+ else if ( contextItem.IgnoreDef() != 0 ) {
+ walkIgnoreDef( contextItem.IgnoreDef() );
+ }
+ else if ( contextItem.LiteralDef() != 0 ) {
+ walkLiteralDef( contextItem.LiteralDef() );
+ }
+ else if ( contextItem.CflDef() != 0 ) {
+ walkCflDef( contextItem.CflDef() );
+ }
+ else if ( contextItem.RegionDef() != 0 ) {
+ walkLexRegion( contextItem.RegionDef() );
+ }
+ else if ( contextItem.ContextDef() != 0 ) {
+ walkContextDef( contextItem.ContextDef() );
+ }
+ else if ( contextItem.FunctionDef() != 0 ) {
+ walkFunctionDef( contextItem.FunctionDef() );
+ }
+ else if ( contextItem.IterDef() != 0 ) {
+ walkIterDef( contextItem.IterDef() );
+ }
+ else if ( contextItem.PreEof() != 0 ) {
+ walkPreEof( contextItem.PreEof() );
+ }
+ else if ( contextItem.ExportDef() != 0 ) {
+ walkExportDef( contextItem.ExportDef() );
+ }
+ else if ( contextItem.PrecedenceDef() != 0 ) {
+ walkPrecedenceDef( contextItem.PrecedenceDef() );
+ }
+ }
+
+ void walkContextDef( context_def contextDef )
+ {
+ String name = contextDef.Name().text().c_str();
+ contextHead( contextDef.Name().loc(), name );
+
+ _repeat_context_item contextItemList = contextDef.ContextItemList();
+ while ( !contextItemList.end() ) {
+ walkContextItem( contextItemList.value() );
+ contextItemList = contextItemList.next();
+ }
+
+ contextStack.pop();
+ namespaceStack.pop();
+ }
+
+ void walkNamespaceDef( namespace_def NamespaceDef )
+ {
+ String name = NamespaceDef.Name().text().c_str();
+ createNamespace( NamespaceDef.Name().loc(), name );
+ walkRootItemList( NamespaceDef.RootItemList() );
+ namespaceStack.pop();
+ }
+
+ void walkRootItem( root_item &rootItem, StmtList *stmtList )
+ {
+ if ( rootItem.RlDef() != 0 ) {
+ walkRlDef( rootItem.RlDef() );
+ }
+ else if ( rootItem.TokenDef() != 0 ) {
+ walkTokenDef( rootItem.TokenDef() );
+ }
+ else if ( rootItem.IgnoreDef() != 0 ) {
+ walkIgnoreDef( rootItem.IgnoreDef() );
+ }
+ else if ( rootItem.LiteralDef() != 0 ) {
+ walkLiteralDef( rootItem.LiteralDef() );
+ }
+ else if ( rootItem.CflDef() != 0 ) {
+ walkCflDef( rootItem.CflDef() );
+ }
+ else if ( rootItem.RegionDef() != 0 ) {
+ walkLexRegion( rootItem.RegionDef() );
+ }
+ else if ( rootItem.Statement() != 0 ) {
+ LangStmt *stmt = walkStatement( rootItem.Statement() );
+ if ( stmt != 0 )
+ stmtList->append( stmt );
+ }
+ else if ( rootItem.ContextDef() != 0 ) {
+ walkContextDef( rootItem.ContextDef() );
+ }
+ else if ( rootItem.NamespaceDef() != 0 ) {
+ walkNamespaceDef( rootItem.NamespaceDef() );
+ }
+ else if ( rootItem.FunctionDef() != 0 ) {
+ walkFunctionDef( rootItem.FunctionDef() );
+ }
+ else if ( rootItem.IterDef() != 0 ) {
+ walkIterDef( rootItem.IterDef() );
+ }
+ else if ( rootItem.IterDef() != 0 ) {
+ walkIterDef( rootItem.IterDef() );
+ }
+ else if ( rootItem.PreEof() != 0 ) {
+ walkPreEof( rootItem.PreEof() );
+ }
+ else if ( rootItem.ExportDef() != 0 ) {
+ LangStmt *stmt = walkExportDef( rootItem.ExportDef() );
+ if ( stmt != 0 )
+ stmtList->append( stmt );
+ }
+ else if ( rootItem.AliasDef() != 0 ) {
+ walkAliasDef( rootItem.AliasDef() );
+ }
+ else if ( rootItem.PrecedenceDef() != 0 ) {
+ walkPrecedenceDef( rootItem.PrecedenceDef() );
+ }
+ else if ( rootItem.Include() != 0 ) {
+ StmtList *includeList = walkInclude( rootItem.Include() );
+ stmtList->append( *includeList );
+ }
+ else if ( rootItem.GlobalDef() != 0 ) {
+ LangStmt *stmt = walkGlobalDef( rootItem.GlobalDef() );
+ if ( stmt != 0 )
+ stmtList->append( stmt );
+ }
+ }
+
+ bool walkOptNoIgnore( opt_no_ignore OptNoIngore )
+ {
+ return OptNoIngore.Ni() != 0;
+ }
+
+ void walkLiteralItem( literal_item literalItem )
+ {
+ bool niLeft = walkOptNoIgnore( literalItem.NiLeft() );
+ bool niRight = walkOptNoIgnore( literalItem.NiRight() );
+
+ String lit = literalItem.Lit().text().c_str();
+ if ( strcmp( lit, "''" ) == 0 )
+ zeroDef( literalItem.Lit().loc(), lit, niLeft, niRight );
+ else
+ literalDef( literalItem.Lit().loc(), lit, niLeft, niRight );
+ }
+
+ void walkLiteralList( literal_list literalList )
+ {
+ if ( literalList.LiteralList() != 0 )
+ walkLiteralList( literalList.LiteralList() );
+ walkLiteralItem( literalList.LiteralItem() );
+ }
+
+ void walkLiteralDef( literal_def literalDef )
+ {
+ walkLiteralList( literalDef.LiteralList() );
+ }
+
+ StmtList *walkRootItemList( _repeat_root_item rootItemList )
+ {
+ StmtList *stmtList = new StmtList;
+
+ /* Walk the list of items. */
+ while ( !rootItemList.end() ) {
+ root_item rootItem = rootItemList.value();
+ walkRootItem( rootItem, stmtList );
+ rootItemList = rootItemList.next();
+ }
+ return stmtList;
+ }
+
+ virtual void go( long activeRealm );
+};
+
+void LoadColm::go( long activeRealm )
+{
+ LoadColm::init();
+
+ const char *argv[2];
+ argv[0] = inputFileName;
+ argv[1] = 0;
+
+ ColmProgram *program = colmNewProgram( &main_runtimeData, activeRealm );
+ colmRunProgram( program, 1, argv );
+
+ /* Extract the parse tree. */
+ start Start = ColmTree( program );
+ str Error = ColmError( program );
+
+ if ( Start == 0 ) {
+ gblErrorCount += 1;
+ InputLoc loc = Error.loc();
+ error(loc) << inputFileName << ": parse error: " << Error.text() << std::endl;
+ return;
+ }
+
+ StmtList *stmtList = walkRootItemList( Start.RootItemList() );
+ colmDeleteProgram( program );
+
+ pd->rootCodeBlock = CodeBlock::cons( stmtList, 0 );
+}
+
+BaseParser *consLoadColm( Compiler *pd, const char *inputFileName )
+{
+ return new LoadColm( pd, inputFileName );
+}