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 printScriptObject(so *tp.ScriptObject, indLvl int) {
printIndent("Name -> %v", indLvl, so.GetName())
printIndent("Scope Type -> %v", indLvl, so.GetScopeTypeId())
printIndent("Linked -> %v", indLvl, so.GetLinked())
printIndent("Module -> %v", indLvl, so.GetModule())
printIndent("Root:", indLvl)
printInstruction(so.GetRoot(), indLvl+1)
}