283 lines
8.0 KiB
Go
283 lines
8.0 KiB
Go
/*
|
|
Package analyzer implements a semantic analyzer for the ARF language. In it,
|
|
there is a function called Analyze which takes in a module path and returns a
|
|
table of sections representative of that module. The result of this operation is
|
|
not cached.
|
|
|
|
The section table returned by Analyze can be expected to be both syntactically
|
|
correct and semantically sound.
|
|
|
|
This package automatically invokes the parser and lexer packages.
|
|
*/
|
|
package analyzer
|
|
|
|
import "os"
|
|
import "fmt"
|
|
import "path/filepath"
|
|
import "git.tebibyte.media/arf/arf/parser"
|
|
import "git.tebibyte.media/arf/arf/infoerr"
|
|
|
|
// analysisOperation holds information about an ongoing analysis operation.
|
|
type analysisOperation struct {
|
|
sectionTable SectionTable
|
|
modulePath string
|
|
|
|
currentPosition locator
|
|
currentSection parser.Section
|
|
currentTree parser.SyntaxTree
|
|
}
|
|
|
|
// Analyze performs a semantic analysis on the module specified by path, and
|
|
// returns a SectionTable that can be translated into C. The result of this is
|
|
// not cached.
|
|
func Analyze (modulePath string, skim bool) (table SectionTable, err error) {
|
|
if modulePath[0] != '/' {
|
|
cwd, _ := os.Getwd()
|
|
modulePath = filepath.Join(cwd, modulePath)
|
|
}
|
|
|
|
analyzer := analysisOperation {
|
|
sectionTable: make(SectionTable),
|
|
modulePath: modulePath,
|
|
}
|
|
|
|
err = analyzer.analyze()
|
|
table = analyzer.sectionTable
|
|
return
|
|
}
|
|
|
|
// analyze performs an analysis operation given the state of the operation
|
|
// struct.
|
|
func (analyzer *analysisOperation) analyze () (err error) {
|
|
var tree parser.SyntaxTree
|
|
tree, err = parser.Fetch(analyzer.modulePath, false)
|
|
if err != nil { return }
|
|
sections := tree.Sections()
|
|
|
|
for !sections.End() {
|
|
_, err = analyzer.fetchSection(locator {
|
|
modulePath: analyzer.modulePath,
|
|
name: sections.Value().Name(),
|
|
})
|
|
if err != nil { return err }
|
|
sections.Next()
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// fetchSection returns a section from the section table. If it has not already
|
|
// been analyzed, it analyzes it first. If the section does not actually exist,
|
|
// a nil section is returned. When this happens, an error should be created on
|
|
// whatever syntax tree node "requested" the section be analyzed.
|
|
func (analyzer *analysisOperation) fetchSection (
|
|
where locator,
|
|
) (
|
|
section Section,
|
|
err error,
|
|
) {
|
|
var exists bool
|
|
section, exists = analyzer.resolvePrimitive(where)
|
|
if exists { return }
|
|
|
|
section, exists = analyzer.sectionTable[where]
|
|
if exists { return }
|
|
|
|
// fetch the module. since we already have our main module parsed fully
|
|
// and not skimmed, we can just say "yeah lets skim stuff here".
|
|
var tree parser.SyntaxTree
|
|
tree, err = parser.Fetch(where.modulePath, true)
|
|
if err != nil {
|
|
section = nil
|
|
return
|
|
}
|
|
|
|
var parsedSection = tree.LookupSection(where.name)
|
|
if parsedSection == nil {
|
|
section = nil
|
|
return
|
|
}
|
|
|
|
previousPosition := analyzer.currentPosition
|
|
previousSection := analyzer.currentSection
|
|
previousTree := analyzer.currentTree
|
|
analyzer.currentPosition = where
|
|
analyzer.currentSection = parsedSection
|
|
analyzer.currentTree = tree
|
|
|
|
defer func () {
|
|
analyzer.currentPosition = previousPosition
|
|
analyzer.currentSection = previousSection
|
|
analyzer.currentTree = previousTree
|
|
} ()
|
|
|
|
// analyze section. have analysis methods work on currentPosition
|
|
// and currentSection.
|
|
//
|
|
// while building an analyzed section, add it to the section
|
|
// table as soon as the vital details are acquired, and mark it as
|
|
// incomplete. that way, it can still be referenced by itself in certain
|
|
// scenarios.
|
|
switch parsedSection.(type) {
|
|
case parser.TypeSection:
|
|
section, err = analyzer.analyzeTypeSection()
|
|
if err != nil { return}
|
|
case parser.EnumSection:
|
|
section, err = analyzer.analyzeEnumSection()
|
|
if err != nil { return}
|
|
case parser.FaceSection:
|
|
case parser.DataSection:
|
|
section, err = analyzer.analyzeDataSection()
|
|
if err != nil { return}
|
|
case parser.FuncSection:
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// fetchSectionFromIdentifier is like fetchSection, but takes in an identifier
|
|
// referring to a section and returns the section. This works within the context
|
|
// of whatever module is currently being analyzed. The identifier in question
|
|
// may have more items than 1 or 2, but those will be ignored. This method
|
|
// "consumes" items from the identifier, it will return an identifier without
|
|
// those items. If the section comes from a different module (and permissions
|
|
// should therefore be respected), external will be set to true.
|
|
func (analyzer *analysisOperation) fetchSectionFromIdentifier (
|
|
which parser.Identifier,
|
|
) (
|
|
section Section,
|
|
external bool,
|
|
bitten parser.Identifier,
|
|
err error,
|
|
) {
|
|
item, bitten := which.Bite()
|
|
|
|
path, exists := analyzer.currentTree.ResolveRequire(item)
|
|
if exists {
|
|
// we have our module path, so get the section name
|
|
item, bitten = bitten.Bite()
|
|
external = true
|
|
} else {
|
|
// that wasn't a module name, so the module path must be our
|
|
// current one
|
|
path = analyzer.currentPosition.modulePath
|
|
}
|
|
|
|
section, err = analyzer.fetchSection (locator {
|
|
name: item,
|
|
modulePath: path,
|
|
})
|
|
if err != nil { return }
|
|
|
|
if section == nil {
|
|
err = which.NewError (
|
|
"section \"" + item + "\" does not exist",
|
|
infoerr.ErrorKindError,
|
|
)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// resolvePrimitive checks to see if the locator is in the current module, and
|
|
// refers to a primitive. If it does, it returns a pointer to that primitive
|
|
// and true for exists. If it doesn't, it returns nil and false.
|
|
func (analyzer *analysisOperation) resolvePrimitive (
|
|
where locator,
|
|
) (
|
|
section Section,
|
|
exists bool,
|
|
) {
|
|
// primitives are scoped as if they are contained within the current
|
|
// module, so if the location refers to something outside of the current
|
|
// module, it is definetly not referring to a primitive.
|
|
if where.modulePath != analyzer.currentPosition.modulePath {
|
|
return
|
|
}
|
|
|
|
exists = true
|
|
switch where.name {
|
|
case "Int": section = &PrimitiveInt
|
|
case "UInt": section = &PrimitiveUInt
|
|
case "I8": section = &PrimitiveI8
|
|
case "I16": section = &PrimitiveI16
|
|
case "I32": section = &PrimitiveI32
|
|
case "I64": section = &PrimitiveI64
|
|
case "U8": section = &PrimitiveU8
|
|
case "U16": section = &PrimitiveU16
|
|
case "U32": section = &PrimitiveU32
|
|
case "U64": section = &PrimitiveU64
|
|
case "Obj": section = &PrimitiveObj
|
|
// case "Face": section = &PrimitiveFace
|
|
// case "Func": section = &PrimitiveFunc
|
|
case "String": section = &BuiltInString
|
|
default:
|
|
exists = false
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// addSection adds a section to the analyzer's section table. If a section with
|
|
// that name already exists, it panics because the parser should not have given
|
|
// that to us.
|
|
func (analyzer *analysisOperation) addSection (section Section) {
|
|
_, exists := analyzer.sectionTable[section.locator()]
|
|
if exists {
|
|
panic (
|
|
"invalid state: duplicate section " +
|
|
section.locator().ToString())
|
|
}
|
|
analyzer.sectionTable[section.locator()] = section
|
|
return
|
|
}
|
|
|
|
// typeCheck checks to see if source can fit as an argument into a slot of type
|
|
// destination. If it can, it retunrs nil. If it can't, it returns an error
|
|
// explaining why.
|
|
func (analyzer *analysisOperation) typeCheck (
|
|
source Argument,
|
|
destination Type,
|
|
) (
|
|
err error,
|
|
) {
|
|
if !source.canBePassedAs(destination) {
|
|
err = source.NewError (
|
|
typeMismatchErrorMessage (
|
|
source.What(),
|
|
destination),
|
|
infoerr.ErrorKindError)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// inCurrentModule returns whether or not the specified section resides within
|
|
// the current module.
|
|
func (analyzer *analysisOperation) inCurrentModule (
|
|
section Section,
|
|
) (
|
|
inCurrent bool,
|
|
){
|
|
inCurrent =
|
|
section.locator().modulePath ==
|
|
analyzer.currentPosition.modulePath
|
|
return
|
|
}
|
|
|
|
// TODO: make a method of analyzer that, given a name, searches through all
|
|
// accessible scopes and returns the thing the name references. when analyzing
|
|
// a function, the analyzer should remember a trail of scopes.
|
|
|
|
// doIndent perfroms a fmt.Sprint operation on input, indenting the string. This
|
|
// does not add a trailing newline.
|
|
func doIndent (indent int, input ...any) (output string) {
|
|
for index := 0; index < indent; index ++ {
|
|
output += "\t"
|
|
}
|
|
|
|
output += fmt.Sprint(input...)
|
|
return
|
|
}
|