func (p *Parser) Parse() *tp.ScriptObject {
script := new(tp.ScriptObject)
// script.Name = proto.String(p.FullPath)
if !p.RootFile || TritiumParserShowRewriterFileName {
script.Name = proto.String(filepath.Join(p.ScriptPath, p.FileName))
} else {
script.Name = proto.String("__rewriter__")
}
stmts := tp.ListInstructions()
defs := make([]*tp.Function, 0) // Add a new constructor in instruction.go
// Look for the namespace directive first.
if p.peek().Lexeme == NAMESPACE {
p.namespaces()
}
for p.peek().Lexeme != EOF {
switch p.peek().Lexeme {
case FUNC:
defs = append(defs, p.definition())
case OPEN:
p.open(false)
default:
stmt := p.statement()
stmts = append(stmts, stmt)
// need to intersperse imports with definitions
if constants.Instruction_InstructionType_name[int32(stmt.GetType())] == "IMPORT" {
// Make a special function stub that represents the import.
// Need to do this because we can't mix definitions and instructions in
// the same array.
imp := new(tp.Function)
imp.Name = proto.String("@import")
imp.Description = proto.String(stmt.GetValue())
defs = append(defs, imp)
}
}
}
if len(defs) == 0 {
defs = nil
}
var line int32
if len(stmts) == 0 {
stmts = nil
} else {
line = *stmts[0].LineNumber
}
script.Functions = defs
script.Root = tp.MakeBlock(stmts, line)
// if defs == nil && p.currentNamespace() != "tritium" {
// panic(fmt.Sprintf("%s: %d -- custom modules may only be declared in function definition files", p.FileName, moduleLineNum))
// }
return script
}
func (p *Parser) call(funcName *Token) (node *tp.Instruction) {
funcNameStr := funcName.Value // grab the function name
funcLineNo := funcName.LineNumber
if p.peek().Lexeme != LPAREN {
p.error("parenthesized argument list expected in call to " + funcNameStr)
}
p.pop() // pop the lparen
ords, kwdnames, kwdvals := p.arguments(funcNameStr) // gather the arguments
numArgs := len(ords)
// this will never happen because p.arguments() only returns when it encounters an rparen
if p.peek().Lexeme != RPAREN {
p.error("unterminated argument list in call to " + funcNameStr)
}
p.pop() // pop the rparen
var block []*tp.Instruction
if p.peek().Lexeme == LBRACE {
block = p.block()
}
// Expand keyword args
if kwdnames != nil && kwdvals != nil {
kwdToGensym := make(map[string]string, len(kwdnames))
outer := tp.ListInstructions()
for i, k := range kwdnames {
tempname := p.gensym()
tempvar := tp.MakeFunctionCall("var",
tp.ListInstructions(tp.MakeText(tempname, funcLineNo),
kwdvals[i]),
nil, funcLineNo)
outer = append(outer, tempvar)
kwdToGensym[k] = tempname
}
inner := tp.ListInstructions()
for _, k := range kwdnames {
getter := tp.MakeFunctionCall("var",
tp.ListInstructions(tp.MakeText(kwdToGensym[k], funcLineNo)),
nil, funcLineNo)
setter := tp.MakeFunctionCall("set",
tp.ListInstructions(tp.MakeText(k, funcLineNo), getter),
nil, funcLineNo)
inner = append(inner, setter)
}
if block != nil {
for _, v := range block {
inner = append(inner, v)
}
}
theCall := tp.MakeFunctionCall(funcNameStr, ords, inner, funcLineNo)
outer = append(outer, theCall)
node = tp.MakeBlock(outer, funcLineNo)
} else if funcNameStr == "concat" && numArgs > 2 {
// expand variadic concat into nested binary concats
lhs := tp.FoldLeft("concat", ords[0], ords[1:numArgs-1])
rhs := ords[numArgs-1]
node = tp.MakeFunctionCall("concat", tp.ListInstructions(lhs, rhs), block, funcLineNo)
} else if funcNameStr == "log" && numArgs > 1 {
// expand variadic log into composition of log and concat
cats := tp.FoldLeft("concat", ords[0], ords[1:])
node = tp.MakeFunctionCall("log", tp.ListInstructions(cats), block, funcLineNo)
} else {
node = tp.MakeFunctionCall(funcNameStr, ords, block, funcLineNo)
}
// if it's not a root file, we can assume that it's a user-called function
if !p.CompilingMixer /* p.RootFile == false && IncludeSelectorInfo == true */ {
node.IsUserCalled = proto.Bool(true)
}
return node
}