[ { "path": ".github/workflows/go.yml", "content": "# This workflow will build a golang project\n# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-go\n\nname: Go\n\non:\n push:\n branches: [ \"main\" ]\n pull_request:\n branches: [ \"main\" ]\n\njobs:\n\n build:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v3\n\n - name: Set up Go\n uses: actions/setup-go@v3\n with:\n go-version: 'stable'\n\n - name: Build\n run: go build -v ./...\n\n - name: Test\n run: go test -v -race ./...\n" }, { "path": ".gitignore", "content": "*.test\nlib/\nlibsass-tmp/\n\n\n" }, { "path": ".gitmodules", "content": "[submodule \"libsass-src\"]\n\tpath = libsass-src\n\turl = https://github.com/sass/libsass.git\n" }, { "path": "LICENSE", "content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright 2018 Drew Wells\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License." }, { "path": "Makefile", "content": "export PKG_CONFIG_PATH=$(shell pwd)/lib/pkgconfig\n\ninstall: deps\n\ndeps: fetch\n\nfetch:\n\tgit submodule sync\n\tgit submodule update --init\n\nlibsass-src: fetch\n\n\nlibsass-src/Makefile.conf: fetch\n\ninclude libsass-src/Makefile.conf\n\nLIBSASS_VERSION:=$(shell cd libsass-src; ./version.sh)\nlibsass-build/include/sass/version.h: libsass-src/include/sass/version.h.in\n\techo \"Stamping version $(LIBSASS_VERSION)\"\n\tsed 's/@PACKAGE_VERSION@/$(LIBSASS_VERSION)/' libsass-src/include/sass/version.h.in > libsass-build/include/sass/version.h\n\n.PHONY: libsass-build\nSOURCES=libsass-build/*.cpp libsass-build/*.c libsass-build/*.h libsass-build/*.hpp\nlibsass-build: libsass-src\n\tmkdir -p libsass-build/include\n\trm -rf $(SOURCES)\n\n\t# more stuff\n\tcp -R libsass-src/src/*.c libsass-build\n\tcp -R libsass-src/src/*.cpp libsass-build\n\tcp -R libsass-src/src/*.h libsass-build\n\tcp -R libsass-src/src/*.hpp libsass-build\n\n\tcp -R libsass-src/src/b64 libsass-build\n\tcp -R libsass-src/include libsass-build\n\tcp -R libsass-src/src/memory libsass-build\n\tcp -R libsass-src/src/utf8 libsass-build\n\n\t# hack remove the [NA] version.h\n\trm libsass-build/include/sass/version.h\n\t$(MAKE) libsass-build/include/sass/version.h\n\n\ttouch libs/*.go\n\nupdate-libsass: libsass-build\n\t@echo \"Success\"\n\n.PHONY: test\ntest:\n\tgo test -race .\n\ncleanfiles:\n\trm -rf lib include libsass-src libsass-tmp\n\nclean: cleanfiles\n\tgit submodule update\n" }, { "path": "README.md", "content": "libsass\n=========\n\n* Deprecated\nTry this project [https://github.com/bep/godartsass](https://github.com/bep/godartsass)\n\n[![Circle CI](https://circleci.com/gh/wellington/go-libsass.svg?style=svg)](https://circleci.com/gh/wellington/go-libsass) [![Build status](https://ci.appveyor.com/api/projects/status/uhl4swbb2r7lcfpc/branch/master?svg=true)](https://ci.appveyor.com/project/drewwells/go-libsass/branch/master)\n\nThe only Sass compliant Go library! go-libsass is a wrapper to the [sass/libsass](http://github.com/sass/libsass) project.\n\nTo build, setup Go\n\n go build\n\nTo test\n\n go test\n\nBasic example more examples found in [examples](examples)\n\n```go\nbuf := bytes.NewBufferString(\"div { p { color: red; } }\")\nif err != nil {\n\tlog.Fatal(err)\n}\ncomp, err := libsass.New(os.Stdout, buf)\nif err != nil {\n\tlog.Fatal(err)\n}\n\nif err := comp.Run(); err != nil {\n\tlog.Fatal(err)\n}\n```\n\nOutput\n```\ndiv p {\n color: red; }\n```\n\n### Updating libsass\n\n```\ncd libsass-src; git fetch; git checkout vX.X.X\ngit commit -m \"updated libsass to vX.X.X\"\nmake update-libsass\n# iterate on includes and code changes until tests pass\n```\n\n### FAQ\n\n* Compiling go-libsass is very slow, what can be done?\n\n Go-libsass compiles C/C++ libsass on every build. You can install the package and speed up building `go install github.com/wellington/go-libsass`. Alternatively, it's possible to link against system libsass and forego C compiling with `go build -tags dev`.\n\n* How do I cross compile?\n\n Since this package uses C bindings, you will need gcc for the target platform. For windows see, https://github.com/wellington/go-libsass/issues/37\n" }, { "path": "appveyor.yml", "content": "build: off\n\nclone_folder: c:\\gopath\\src\\github.com\\wellington\\go-libsass\n\nenvironment:\n GOPATH: c:\\gopath\n\nstack: go 1.10.0\n\ninstall:\n - ps: |\n # Install MinGW.\n $url = \"https://bintray.com/artifact/download/drewwells/generic/x86_64-5.1.0-release-win32-seh-rt_v4-rev0.7z\"\n $strFileName=\"C:\\mingw64\\bin\\mingw32-make.exe\"\n If (Test-Path $strFileName){\n Write-Host \"Using cached mingw64\"\n }Else{\n Write-Host \"Fetching mingw64\"\n Invoke-WebRequest -UserAgent wget -Uri $url -OutFile ming32-64.7z\n &7z x -oC:\\ ming32-64.7z > $null\n }\n - set CC=gcc\n - set CXX=g++\n # why is this necessary\n - set PATH=%PATH%;C:\\mingw-w64\\x86_64-7.3.0-posix-seh-rt_v5-rev0\\mingw64\\bin\n - echo %PATH%\n - echo %GOPATH%\n - dir C:\\mingw-w64\n - dir C:\\mingw-w64\\x86_64-7.3.0-posix-seh-rt_v5-rev0\\mingw64\n - dir C:\\mingw-w64\\x86_64-7.3.0-posix-seh-rt_v5-rev0\\mingw64\\bin\n\nbuild_script:\n - go build -x -ldflags \"-extldflags '-static'\"\n" }, { "path": "blah/blah.go", "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/wellington/go-libsass/libs\"\n)\n\nfunc main() {\n\t//run(\"blah.scss\")\n\trun(\"error.scss\")\n}\n\nfunc run(path string) {\n\n\t//cheads := libs.SassMakeImporterList(1)\n\n\tgofc := libs.SassMakeFileContext(path)\n\t// goopts := libs.SassFileContextGetOptions(gofc)\n\t// libs.SassOptionSetCHeaders(goopts, cheads)\n\n\t// libs.SassOptionSetOutputStyle(goopts, 2)\n\t// Set options\n\t// libs.SassFileContextSetOptions(gofc, goopts)\n\n\tgoctx := libs.SassFileContextGetContext(gofc)\n\tgocomp := libs.SassMakeFileCompiler(gofc)\n\tdefer libs.SassDeleteCompiler(gocomp)\n\n\tlibs.SassCompilerParse(gocomp)\n\tlibs.SassCompilerExecute(gocomp)\n\tgostr := libs.SassContextGetOutputString(goctx)\n\tfmt.Println(gostr)\n\terrStatus := libs.SassContextGetErrorStatus(goctx)\n\tif errStatus > 0 {\n\t\tfmt.Println(\"error:\", libs.SassContextGetErrorJSON(goctx))\n\t}\n}\n" }, { "path": "blah/blah.scss", "content": "div { p { color: red; } }\n" }, { "path": "blah/error.scss", "content": "p {\n" }, { "path": "compiler.go", "content": "package libsass\n\nimport (\n\t\"errors\"\n\t\"io\"\n\n\t\"context\"\n)\n\nvar (\n\tErrPayloadEmpty = errors.New(\"empty payload\")\n\tErrNoCompile = errors.New(\"No compile has occurred\")\n\t_ Pather = &sass{}\n\t_ Compiler = &sass{}\n)\n\n// Pather describes the file system paths necessary for a project\ntype Pather interface {\n\tImgDir() string\n\tBuildDir() string\n\tHTTPPath() string\n\tImgBuildDir() string\n\tFontDir() string\n}\n\n// Compiler interface is used to translate input Sass network, filepath,\n// or otherwise and transforms it to CSS. The interface includes methods\n// for adding imports and specifying build options necessary to do the\n// transformation.\n//\ntype Compiler interface {\n\t// Run does a synchronous build via cgo. It is thread safe, but there is\n\t// no guarantee that the cgo calls will always be that way.\n\tRun() error\n\t// Imports returns the imports used for a compile. This is built\n\t// at parser time in libsass\n\tImports() []string\n\t// Option allows the configuration of the compiler. The option is\n\t// unexported to encourage use of preconfigured option functions.\n\tOption(...FuncOpt) error\n\n\t// CacheBust specifies the cache bust method used by the compiler\n\t// Available options: ts, sum\n\tCacheBust() string\n\n\t// LineComments specifies whether line comments were inserted into\n\t// output CSS\n\tLineComments() bool\n\n\t// Payload returns the attached spritewell information attached\n\t// to the compiler context\n\tPayload() context.Context\n\n\t// Syntax represents the style of code Sass or SCSS\n\tSyntax() Syntax\n}\n\nfunc New(dst io.Writer, src io.Reader, opts ...FuncOpt) (Compiler, error) {\n\n\tc := &sass{\n\t\tdst: dst,\n\t\tsrc: src,\n\t\tctx: newContext(),\n\t}\n\n\tc.ctx.in = src\n\tc.ctx.out = dst\n\tc.ctx.compiler = c\n\terr := c.Option(opts...)\n\n\treturn c, err\n}\n\n// sass implements compiler interface for Sass and Scss stylesheets. To\n// configure the compiler, use the option method.\ntype sass struct {\n\t// FIXME: old context for storing state, use compiler instead\n\tctx *compctx\n\tdst io.Writer\n\tmappath string\n\n\t// src is the input stream to compile\n\tsrc io.Reader\n\t// path to the input file\n\tsrcFile string\n\n\t// cachebust instructs the compiler to generate new paths\n\t// preventing browser caching\n\tcachebust string\n\thttpPath string\n\tincludePaths []string\n\timports []string\n\tcmt bool\n\tsourceMapRoot string\n\t// payload is passed around for handlers to have context\n\tpayload context.Context\n\n\t// current syntax of the compiler, Sass or SCSS\n\tsyntax Syntax\n}\n\nvar _ Compiler = &sass{}\n\nfunc (c *sass) run() error {\n\tdefer func() {\n\t\tc.imports = c.ctx.ResolvedImports\n\t}()\n\n\tif len(c.srcFile) > 0 {\n\t\treturn c.ctx.fileCompile(c.srcFile, c.dst, c.mappath, c.sourceMapRoot)\n\t}\n\treturn c.ctx.compile(c.dst, c.src)\n}\n\n// BuildDir is where CSS is written to disk\nfunc (s *sass) BuildDir() string {\n\treturn s.ctx.BuildDir\n}\n\n// CacheBust reveals the current cache busting state\nfunc (c *sass) CacheBust() string {\n\treturn c.cachebust\n}\n\nfunc (s *sass) HTTPPath() string {\n\treturn s.ctx.HTTPPath\n}\n\n// ImgBuildDir fetch the image build directory\nfunc (s *sass) ImgBuildDir() string {\n\treturn s.ctx.GenImgDir\n}\n\n// ImgDir returns the Image Directory used for locating images\nfunc (c *sass) ImgDir() string {\n\treturn c.ctx.ImageDir\n}\n\n// Imports returns the full list of partials used to build the\n// output stylesheet.\nfunc (c *sass) Imports() []string {\n\treturn c.imports\n}\n\n// FontDir returns the font directory option\nfunc (c *sass) FontDir() string {\n\treturn c.ctx.FontDir\n}\n\n// LineComments returns the source comment status\nfunc (c *sass) LineComments() bool {\n\treturn c.cmt\n}\n\nfunc (c *sass) Payload() context.Context {\n\treturn c.ctx.Payload\n}\n\n// Run starts transforming S[c|a]ss to CSS\nfunc (c *sass) Run() error {\n\treturn c.run()\n}\n\nfunc (c *sass) Syntax() Syntax {\n\treturn c.syntax\n}\n" }, { "path": "compiler_test.go", "content": "package libsass\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"log\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"testing\"\n)\n\nfunc ExampleCompiler_stdin() {\n\n\tsrc := bytes.NewBufferString(`div { p { color: red; } }`)\n\n\tcomp, err := New(os.Stdout, src)\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\terr = comp.Run()\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\t// Output:\n\t// div p {\n\t// color: red; }\n\t//\n\n}\n\nfunc ExampleComipler_sass() {\n\tsrc := bytes.NewBufferString(`\nhtml\n font-family: 'MonoSocial'\n`)\n\tcomp, err := New(os.Stdout, src, WithSyntax(SassSyntax))\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\terr = comp.Run()\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\t// Output:\n\t// html {\n\t// font-family: 'MonoSocial'; }\n\n}\n\nfunc TestCompiler_path(t *testing.T) {\n\tvar dst bytes.Buffer\n\n\tcomp, err := New(&dst, nil, Path(\"test/scss/basic.scss\"))\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\terr = comp.Run()\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te := `div p {\n color: red; }\n`\n\tif e != dst.String() {\n\t\tt.Errorf(\"got: %s wanted: %s\", dst.String(), e)\n\t}\n\n\tif e := 1; len(comp.Imports()) != e {\n\t\tt.Errorf(\"got: %d wanted: %d\", len(comp.Imports()), e)\n\t}\n\n}\n\nfunc TestCompiler_path_withpathsresolver(t *testing.T) {\n\tvar dst bytes.Buffer\n\n\tabsArgs := [][]string{}\n\n\tcomp, err := New(\n\t\t&dst,\n\t\tnil,\n\t\tPath(\"test/scss/file.scss\"),\n\t\tImportsOption(NewImportsWithResolver(func(importedUrl string, importerAbsPath string) (string, string, bool) {\n\t\t\tabsArgs = append(absArgs, []string{importedUrl, importerAbsPath})\n\t\t\tif importedUrl == \"a\" {\n\t\t\t\treturn \"test/scss/a.scss\", \".a { color: #aaaaaa }\\n@import 'b';\", true\n\t\t\t} else if importedUrl == \"b\" {\n\t\t\t\treturn \"test/scss/b.scss\", \".b { color: #bbbbbb }\", true\n\t\t\t}\n\t\t\treturn \"\", \"\", false\n\t\t})),\n\t)\n\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\terr = comp.Run()\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te := `.a {\n color: #aaaaaa; }\n\n.b {\n color: #bbbbbb; }\n`\n\tif e != dst.String() {\n\t\tt.Errorf(\"got: %s wanted: %s\", dst.String(), e)\n\t}\n\n\tif e := 3; len(comp.Imports()) != e {\n\t\tt.Errorf(\"got: %d wanted: %d\", len(comp.Imports()), e)\n\t}\n\n\texpectedAbsArgs := `[[a test/scss/file.scss] [b a]]`\n\tif absArgsStr := fmt.Sprintf(\"%+v\", absArgs); expectedAbsArgs != absArgsStr {\n\t\tt.Errorf(\"abs args got: %s wanted: %s\", absArgsStr, expectedAbsArgs)\n\t}\n}\n\nfunc TestCompiler_path_withabsresolver(t *testing.T) {\n\tvar dst bytes.Buffer\n\n\tabsArgs := [][]string{}\n\n\twd, err := os.Getwd()\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\tcomp, err := New(\n\t\t&dst,\n\t\tnil,\n\t\tPath(\"test/scss/file.scss\"),\n\t\tImportsOption(NewImportsWithAbsResolver(func(importedUrl string, importerAbsPath string) (string, string, bool) {\n\t\t\t// convert the path to a stable representation\n\t\t\t// (convert abs path to a relative path, with the prefix $CWD/)\n\t\t\tvar pathToSave string\n\t\t\tif filepath.IsAbs(importerAbsPath) {\n\t\t\t\tpathToSave, err = filepath.Rel(wd, importerAbsPath)\n\t\t\t\tif err != nil {\n\t\t\t\t\tt.Fatal(err)\n\t\t\t\t}\n\t\t\t\tpathToSave = \"$CWD/\" + pathToSave\n\t\t\t} else {\n\t\t\t\tpathToSave = importerAbsPath\n\t\t\t}\n\n\t\t\t// save the args\n\t\t\tabsArgs = append(absArgs, []string{\n\t\t\t\timportedUrl,\n\t\t\t\tfilepath.ToSlash(pathToSave),\n\t\t\t})\n\n\t\t\t// handle magic modules \"a\" and \"b\"\n\t\t\tif importedUrl == \"a\" {\n\t\t\t\treturn wd + filepath.FromSlash(\"/test/scss/a.scss\"), \".a { color: #aaaaaa }\\n@import 'b';\", true\n\t\t\t} else if importedUrl == \"b\" {\n\t\t\t\treturn wd + filepath.FromSlash(\"/test/scss/b.scss\"), \".b { color: #bbbbbb }\", true\n\t\t\t}\n\t\t\treturn \"\", \"\", false\n\t\t})),\n\t)\n\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\terr = comp.Run()\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te := `.a {\n color: #aaaaaa; }\n\n.b {\n color: #bbbbbb; }\n`\n\tif e != dst.String() {\n\t\tt.Errorf(\"got: %s wanted: %s\", dst.String(), e)\n\t}\n\n\tif e := 3; len(comp.Imports()) != e {\n\t\tt.Errorf(\"got: %d wanted: %d\", len(comp.Imports()), e)\n\t}\n\n\texpectedAbsArgs := `[[a $CWD/test/scss/file.scss] [b $CWD/test/scss/a.scss]]`\n\tif absArgsStr := fmt.Sprintf(\"%+v\", absArgs); expectedAbsArgs != absArgsStr {\n\t\tt.Errorf(\"abs args got: %s wanted: %s\", absArgsStr, expectedAbsArgs)\n\t}\n}\n" }, { "path": "context.go", "content": "package libsass\n\nimport (\n\t\"bytes\"\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"io/ioutil\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"strings\"\n\n\t\"github.com/wellington/go-libsass/libs\"\n)\n\n// Context handles the interactions with libsass. Context\n// exposes libsass options that are available.\ntype compctx struct {\n\t// TODO: hack to give handlers Access to the Compiler\n\tcompiler Compiler\n\n\toptions libs.SassOptions\n\tcontext libs.SassContext\n\tincludeMap bool\n\n\t// Options\n\tOutputStyle int\n\tPrecision int\n\tComments bool\n\tIncludePaths []string\n\t// Input directories\n\tFontDir string\n\tImageDir string\n\t// Output/build directories\n\tBuildDir string\n\tGenImgDir string\n\n\t// HTTP supporting code\n\tHTTPPath string\n\tIn, Src, Out, Map, MainFile string\n\tStatus int //libsass status code\n\n\t// many error parameters some are unnecessary and should be removed\n\terrorString string\n\terr SassError\n\n\tin io.Reader\n\tout io.Writer\n\n\t// Funcs is a slice of Sass function handlers. Registry these globally\n\t// by calling RegisterHandler\n\tFuncs *Funcs\n\t// Imports is a map of overridden imports. When Sass attempts to\n\t// import a path matching on in this map, it will include the import\n\t// found in the map before looking for a file on the system.\n\tImports *Imports\n\t// Headers are a map of strings to start any Sass project with. Any\n\t// header listed here will be present before any other Sass code is\n\t// compiled.\n\tHeaders *Headers\n\n\t// ResolvedImports is the list of files libsass used to compile this\n\t// Sass sheet.\n\tResolvedImports []string\n\n\t// Attach additional data to a context for use by custom\n\t// handlers/mixins\n\tPayload context.Context\n}\n\n// Constants/enums for the output style.\nconst (\n\tNESTED_STYLE = iota\n\tEXPANDED_STYLE\n\tCOMPACT_STYLE\n\tCOMPRESSED_STYLE\n)\n\nvar Style map[string]int\n\nfunc init() {\n\tStyle = make(map[string]int)\n\tStyle[\"nested\"] = NESTED_STYLE\n\tStyle[\"expanded\"] = EXPANDED_STYLE\n\tStyle[\"compact\"] = COMPACT_STYLE\n\tStyle[\"compressed\"] = COMPRESSED_STYLE\n\n}\n\nfunc newContext() *compctx {\n\tc := &compctx{\n\t\tHeaders: NewHeaders(),\n\t\tImports: NewImports(),\n\t}\n\t// FIXME: this doesn't actually work for new options being added\n\t// to just the compiler\n\tc.compiler = &sass{ctx: c}\n\tc.Funcs = NewFuncs(c)\n\treturn c\n}\n\n// Init validates options in the struct and returns a Sass Options.\nfunc (ctx *compctx) Init(goopts libs.SassOptions) libs.SassOptions {\n\tif ctx.Precision == 0 {\n\t\tctx.Precision = 5\n\t}\n\tctx.options = goopts\n\tctx.Headers.Bind(goopts)\n\tctx.Imports.Bind(goopts)\n\tctx.Funcs.Bind(goopts)\n\tlibs.SassOptionSetSourceComments(goopts, ctx.compiler.LineComments())\n\t//os.PathListSeparator\n\tincs := strings.Join(ctx.IncludePaths, string(os.PathListSeparator))\n\tlibs.SassOptionSetIncludePath(goopts, incs)\n\tlibs.SassOptionSetPrecision(goopts, ctx.Precision)\n\tlibs.SassOptionSetOutputStyle(goopts, ctx.OutputStyle)\n\tlibs.SassOptionSetSourceComments(goopts, ctx.Comments)\n\n\tif ctx.includeMap {\n\t\tlibs.SassOptionSetSourceMapEmbed(goopts, true)\n\t}\n\n\treturn goopts\n}\n\nfunc (ctx *compctx) fileCompile(path string, out io.Writer, mappath, sourceMapRoot string) error {\n\tdefer ctx.Reset()\n\tgofc := libs.SassMakeFileContext(path)\n\tgoopts := libs.SassFileContextGetOptions(gofc)\n\tctx.Init(goopts)\n\n\tvar fpath string\n\t// libSass won't create a source map unless you ask it to\n\t// embed one or give it a file path. It won't actually write\n\t// to this file, but it will add this filename into the\n\t// css output.\n\tif len(mappath) > 0 {\n\t\tlibs.SassOptionSetSourceMapFile(goopts, mappath)\n\n\t\t// Output path must be set for libSass to build relative\n\t\t// paths between the source map and the source files\n\t\tif f, ok := out.(*os.File); ok {\n\t\t\tfpath = f.Name()\n\t\t}\n\n\t\t// without this, the sourceMappingURL in the out file\n\t\t// creates strange relative paths\n\t\tlibs.SassOptionSetOutputPath(goopts, fpath)\n\t}\n\n\t// write source map paths relative to this path\n\tif len(sourceMapRoot) > 0 {\n\t\tlibs.SassOptionSetSourceMapRoot(goopts, sourceMapRoot)\n\t}\n\n\t// Set options to the sass context\n\tlibs.SassFileContextSetOptions(gofc, goopts)\n\tgocc := libs.SassFileContextGetContext(gofc)\n\tctx.context = gocc\n\tgocompiler := libs.SassMakeFileCompiler(gofc)\n\tlibs.SassCompilerParse(gocompiler)\n\tctx.ResolvedImports = libs.GetImportList(gocc)\n\tlibs.SassCompilerExecute(gocompiler)\n\tdefer libs.SassDeleteCompiler(gocompiler)\n\n\tgoout := libs.SassContextGetOutputString(gocc)\n\tif out == nil {\n\t\treturn errors.New(\"out writer required\")\n\t}\n\t_, err := io.WriteString(out, goout)\n\tif err != nil {\n\t\treturn err\n\t}\n\tctx.Status = libs.SassContextGetErrorStatus(gocc)\n\terrJSON := libs.SassContextGetErrorJSON(gocc)\n\tmapout := libs.SassContextGetSourceMapString(gocc)\n\n\tif len(mappath) > 0 && len(mapout) > 0 {\n\t\terr := ioutil.WriteFile(mappath, []byte(mapout), 0666)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\t// Yet another property for storing errors\n\terr = ctx.ProcessSassError([]byte(errJSON))\n\tif err != nil {\n\t\treturn err\n\t}\n\tif ctx.Error() != \"\" {\n\t\t// TODO: this is weird, make something more idiomatic*/\n\t\treturn errors.New(ctx.Error())\n\t}\n\n\treturn nil\n}\n\n// compile reads in and writes the libsass compiled result to out.\n// Options and custom functions are applied as specified in Context.\nfunc (ctx *compctx) compile(out io.Writer, in io.Reader) error {\n\n\tdefer ctx.Reset()\n\tvar (\n\t\tbs []byte\n\t\terr error\n\t)\n\n\t// libSass will fail on Sass syntax given as non-file input\n\t// convert the input on its behalf\n\tif ctx.compiler.Syntax() == SassSyntax {\n\t\t// this is memory intensive\n\t\tvar buf bytes.Buffer\n\t\terr := ToScss(in, &buf)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tbs = buf.Bytes()\n\t} else {\n\t\t// ScssSyntax\n\t\tbs, err = ioutil.ReadAll(in)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\n\tif len(bs) == 0 {\n\t\treturn errors.New(\"No input provided\")\n\t}\n\n\tgodc := libs.SassMakeDataContext(string(bs))\n\tgoopts := libs.SassDataContextGetOptions(godc)\n\tlibs.SassOptionSetSourceComments(goopts, true)\n\n\tctx.Init(goopts)\n\n\tlibs.SassDataContextSetOptions(godc, goopts)\n\tgoctx := libs.SassDataContextGetContext(godc)\n\tctx.context = goctx\n\tgocompiler := libs.SassMakeDataCompiler(godc)\n\tlibs.SassCompilerParse(gocompiler)\n\tlibs.SassCompilerExecute(gocompiler)\n\tdefer libs.SassDeleteCompiler(gocompiler)\n\n\tgoout := libs.SassContextGetOutputString(goctx)\n\tio.WriteString(out, goout)\n\n\tctx.Status = libs.SassContextGetErrorStatus(goctx)\n\terrJSON := libs.SassContextGetErrorJSON(goctx)\n\terr = ctx.ProcessSassError([]byte(errJSON))\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tif ctx.Error() != \"\" {\n\t\tlines := bytes.Split(bs, []byte(\"\\n\"))\n\t\tvar out string\n\t\tfor i := -7; i < 7; i++ {\n\t\t\tif i+ctx.err.Line >= 0 && i+ctx.err.Line < len(lines) {\n\t\t\t\tout += fmt.Sprintf(\"%s\\n\", string(lines[i+ctx.err.Line]))\n\t\t\t}\n\t\t}\n\t\t// TODO: this is weird, make something more idiomatic\n\t\treturn errors.New(ctx.Error() + \"\\n\" + out)\n\t}\n\n\treturn nil\n}\n\n// Rel creates relative paths between the build directory where the CSS lives\n// and the image directory that is being linked. This is not compatible\n// with generated images like sprites.\nfunc (p *compctx) RelativeImage() string {\n\trel, _ := filepath.Rel(p.BuildDir, p.ImageDir)\n\treturn filepath.ToSlash(filepath.Clean(rel))\n}\n" }, { "path": "context_test.go", "content": "package libsass\n\nimport (\n\t\"bytes\"\n\t\"log\"\n\t\"os\"\n\t\"testing\"\n\n\t\"github.com/wellington/go-libsass/libs\"\n)\n\nfunc TestContextFile(t *testing.T) {\n\n\tin := bytes.NewBufferString(`div {\n span {\n color: black;\n }\n width: 100px;\n height: 100px;\n}\n\np {\n\tbackground: red;\n}`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\n\te := `div {\n width: 100px;\n height: 100px; }\n div span {\n color: black; }\n\np {\n background: red; }\n`\n\n\tif e != out.String() {\n\t\tt.Errorf(\"wanted:\\n%s\\n\"+\n\t\t\t\"got:\\n%s\\n\", e, out.String())\n\t}\n}\n\nfunc TestContextNilRun(t *testing.T) {\n\tvar in, out bytes.Buffer\n\tctx := newContext()\n\terr := ctx.compile(&out, &in)\n\tif err == nil {\n\t\tt.Error(\"No error returned\")\n\t}\n\tif e := \"No input provided\"; e != err.Error() {\n\t\tt.Errorf(\"wanted:\\n%s\\ngot:\\n%s\", e, err)\n\t}\n}\n\nfunc TestContextRun(t *testing.T) {\n\n\tin := bytes.NewBufferString(`$red-var: red;\n$hex: #00FF00;\ndiv {\n background: $hex;\n $hex: #00DD00;\n font-size: 10pt;\n}\n`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\n\te := `div {\n background: #00FF00;\n font-size: 10pt; }\n`\n\n\tif e != out.String() {\n\t\tt.Errorf(\"wanted:\\n%s\\n\"+\n\t\t\t\"got:\\n%s\\n\", e, out.String())\n\t}\n\n}\n\nfunc TestLibsassError(t *testing.T) {\n\tin := bytes.NewBufferString(`div {\n color: red(blue, purple);\n}`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\n\tctx.Funcs.Add(Func{\n\t\tSign: \"foo()\",\n\t\tFn: TestCallback,\n\t\tCtx: &ctx,\n\t})\n\terr := ctx.compile(&out, in)\n\n\tif err == nil {\n\t\tt.Error(\"No error thrown for incorrect arity\")\n\t}\n\n\tif e := \"wrong number of arguments (2 for 1) for `red'\"; e != ctx.err.Message {\n\t\tt.Errorf(\"wanted:%s\\ngot:%s\\n\", e, ctx.err.Message)\n\t}\n\te := `Error > stdin:2\nwrong number of arguments (2 for 1) for ` + \"`\" + `red'\ndiv {\n color: red(blue, purple);\n}\n`\n\tif e != err.Error() {\n\t\tt.Errorf(\"wanted:\\n%s\\ngot:\\n%s\\n\", e, err)\n\t}\n}\n\nfunc ExampleContext_Compile() {\n\tin := bytes.NewBufferString(`div {\n\t\t\t color: red(blue);\n\t\t\t background: foo();\n\t\t\t}`)\n\n\tctx := newContext()\n\n\tctx.Funcs.Add(Func{\n\t\tSign: \"foo()\",\n\t\tFn: func(v interface{}, usv libs.UnionSassValue, rsv *libs.UnionSassValue) error {\n\t\t\tres, _ := Marshal(\"no-repeat\")\n\t\t\t*rsv = res.Val()\n\t\t\treturn nil\n\t\t},\n\t\tCtx: &ctx,\n\t})\n\terr := ctx.compile(os.Stdout, in)\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\t// Output:\n\t// div {\n\t// color: 0;\n\t// background: no-repeat; }\n}\n\nfunc BenchmarkContextCompile(b *testing.B) {\n\tbits := []byte(`div { color: #005500; }`)\n\tbig := []byte(`div { color: #005500; } `)\n\tctx := newContext()\n\tout := bytes.NewBuffer(big)\n\n\tfor i := 0; i < b.N; i++ {\n\t\tin := bytes.NewBuffer(bits)\n\t\tout.Reset()\n\t\terr := ctx.compile(out, in)\n\t\tif err != nil {\n\t\t\tb.Error(err)\n\t\t}\n\t}\n}\n" }, { "path": "doc.go", "content": "// Package context wraps access to libsass. Higher level abstractions\n// are used to make the package more like Go than C. For low level\n// access see: http://godoc.org/github.com/wellington/go-libsass/libs\n//\n// For more info, see https://github.com/sass/libsass\npackage libsass\n" }, { "path": "encoding.go", "content": "package libsass\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"image/color\"\n\t\"reflect\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/wellington/go-libsass/libs\"\n)\n\nvar (\n\tErrSassNumberNoUnit = errors.New(\"SassNumber has no units\")\n)\n\ntype SassValue struct {\n\tvalue libs.UnionSassValue\n}\n\nfunc (sv SassValue) Val() libs.UnionSassValue {\n\treturn sv.value\n}\n\nfunc NewSassValue() SassValue {\n\treturn SassValue{value: libs.NewUnionSassValue()}\n}\n\nfunc unmarshal(arg SassValue, v interface{}) error {\n\tsv := arg.Val()\n\t//Get the underlying value of v and its kind\n\tf := reflect.ValueOf(v)\n\n\tif f.Kind() == reflect.Ptr {\n\t\tf = f.Elem()\n\t}\n\n\tk := f.Kind()\n\tt := f.Type()\n\n\tif k == reflect.Interface {\n\t\tswitch {\n\t\tcase libs.IsNil(sv):\n\t\t\tf.Set(reflect.ValueOf(\"\"))\n\t\t\treturn nil\n\t\tcase libs.IsString(sv):\n\t\t\tk = reflect.String\n\t\tcase libs.IsBool(sv):\n\t\t\tk = reflect.Bool\n\t\tcase libs.IsNumber(sv):\n\t\t\tk = reflect.Struct\n\t\tcase libs.IsList(sv):\n\t\t\tk = reflect.Slice\n\t\t\tt = reflect.SliceOf(t)\n\t\tcase libs.IsError(sv):\n\t\t\t// This should get implemented as type error\n\t\t\tk = reflect.String\n\t\tcase libs.IsColor(sv):\n\t\t\tk = reflect.Struct\n\t\tdefault:\n\t\t\treturn errors.New(\"Uncovertable interface value.\")\n\t\t}\n\t}\n\n\tswitch k {\n\tcase reflect.Invalid:\n\t\treturn errors.New(\"Invalid SASS Value - Taylor Swift\")\n\tcase reflect.String:\n\t\tif libs.IsString(sv) || libs.IsError(sv) {\n\t\t\tvar gc string\n\t\t\tif libs.IsString(sv) {\n\t\t\t\tgc = libs.String(sv)\n\t\t\t} else {\n\t\t\t\tgc = libs.Error(sv)\n\t\t\t}\n\t\t\t//drop quotes\n\t\t\tif t, err := strconv.Unquote(gc); err == nil {\n\t\t\t\tgc = t\n\t\t\t}\n\t\t\tif strings.HasPrefix(gc, \"'\") && strings.HasSuffix(gc, \"'\") {\n\t\t\t\tgc = gc[1 : len(gc)-1]\n\t\t\t}\n\t\t\tif !f.CanSet() {\n\t\t\t\treturn errors.New(\"Can not set string\")\n\t\t\t}\n\n\t\t\tswitch t := f.Kind(); t {\n\t\t\tcase reflect.String:\n\t\t\t\tf.SetString(gc)\n\t\t\tcase reflect.Interface:\n\t\t\t\tf.Set(reflect.ValueOf(gc))\n\t\t\t}\n\t\t} else {\n\t\t\treturn throwMisMatchTypeError(arg, \"string\")\n\t\t}\n\tcase reflect.Bool:\n\t\tif libs.IsBool(sv) {\n\t\t\tb := libs.Bool(sv)\n\t\t\tf.Set(reflect.ValueOf(b))\n\t\t} else {\n\t\t\treturn throwMisMatchTypeError(arg, \"bool\")\n\t\t}\n\tcase reflect.Struct:\n\t\tswitch {\n\t\tcase libs.IsColor(sv):\n\t\t\tcol := libs.Color(sv)\n\t\t\tf.Set(reflect.ValueOf(col))\n\t\tcase libs.IsNumber(sv):\n\t\t\tu, err := getSassNumberUnit(arg)\n\t\t\tif err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tsn := libs.SassNumber{\n\t\t\t\tValue: libs.Float(sv),\n\t\t\t\tUnit: u,\n\t\t\t}\n\t\t\tf.Set(reflect.ValueOf(sn))\n\t\tdefault:\n\t\t\treturn throwMisMatchTypeError(arg, \"color.RGBA or SassNumber\")\n\t\t}\n\tcase reflect.Slice:\n\t\tif !libs.IsList(sv) {\n\t\t\treturn throwMisMatchTypeError(arg, \"slice\")\n\t\t}\n\t\tlibs.Slice(arg.Val(), v)\n\tdefault:\n\t\treturn errors.New(\"Unsupported SassValue\")\n\t}\n\treturn nil\n}\n\n// Decode converts Sass Value to Go compatible data types.\nfunc Unmarshal(arg SassValue, v ...interface{}) error {\n\tvar err error\n\tsv := arg.Val()\n\tvar l int\n\tif libs.IsList(sv) {\n\t\tl = libs.Len(sv)\n\t}\n\tif arg.Val() == nil {\n\t\treturn errors.New(\"I can't work with this. arg UnionSassValue must not be nil. - Unmarshaller\")\n\t} else if len(v) == 0 {\n\t\treturn errors.New(\"Cannot Unmarshal an empty value - Michael Scott\")\n\t} else if len(v) > 1 {\n\t\tif len(v) < l { //check for optional arguements that are not passed and pad with nil\n\t\t\treturn fmt.Errorf(\n\t\t\t\t\"Arguments mismatch %d C arguments did not match %d\",\n\t\t\t\tl, len(v))\n\t\t}\n\t\tfor i := 0; i < l; i++ {\n\t\t\tval := libs.Index(sv, i)\n\t\t\terr = unmarshal(SassValue{value: val}, v[i])\n\t\t\tif err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\t\treturn err\n\t} else if libs.IsList(sv) &&\n\t\tgetKind(v[0]) != reflect.Slice &&\n\t\tl == 1 { //arg is a slice of 1 but we want back a non slice\n\t\tval := libs.Index(sv, 0)\n\t\treturn unmarshal(SassValue{value: val}, v[0])\n\t} else if libs.IsList(sv) &&\n\t\tgetKind(v[0]) == reflect.Slice &&\n\t\tlibs.IsList(libs.Index(sv, 0)) &&\n\t\tl == 1 { //arg is a list of single list and we only want back a list so we need to unwrap\n\t\tval := libs.Index(sv, 0)\n\t\treturn unmarshal(SassValue{value: val}, v[0])\n\t\t//return unmarshal(C.sass_list_get_value(arg, C.size_t(0)), v[0])\n\t} else {\n\t\treturn unmarshal(arg, v[0])\n\t}\n}\n\nfunc getKind(v interface{}) reflect.Kind {\n\tf := reflect.ValueOf(v)\n\n\tif f.Kind() == reflect.Ptr {\n\t\tf = f.Elem()\n\t}\n\n\treturn f.Kind()\n}\n\nfunc noSassNumberUnit(arg SassValue) bool {\n\tu := libs.Unit(arg.Val())\n\treturn u == \"\" || u == \"none\"\n}\n\nfunc getSassNumberUnit(arg SassValue) (string, error) {\n\tu := libs.Unit(arg.Val())\n\tvar err error\n\tif noSassNumberUnit(arg) {\n\t\treturn u, ErrSassNumberNoUnit\n\t}\n\tif _, ok := libs.SassUnitConversions[u]; !ok {\n\t\treturn u, fmt.Errorf(\"SassNumber units %s are unsupported\", u)\n\t}\n\treturn u, err\n}\n\nfunc Marshal(v interface{}) (SassValue, error) {\n\treturn makevalue(v)\n}\n\n// make is needed to create types for use by test\nfunc makevalue(v interface{}) (SassValue, error) {\n\tf := reflect.ValueOf(v)\n\tvar err error\n\tswitch f.Kind() {\n\tdefault:\n\t\treturn SassValue{value: libs.MakeNil()}, nil\n\tcase reflect.Bool:\n\t\tb := v.(bool)\n\t\treturn SassValue{value: libs.MakeBool(b)}, nil\n\tcase reflect.String:\n\t\ts := v.(string)\n\t\treturn SassValue{value: libs.MakeString(s)}, nil\n\tcase reflect.Struct: //only SassNumber and color.RGBA are supported\n\t\tif sn, ok := v.(libs.SassNumber); ok {\n\t\t\treturn SassValue{\n\t\t\t\tvalue: libs.MakeNumber(sn.Float(), sn.UnitOf()),\n\t\t\t}, err\n\t\t} else if sc, ok := v.(color.RGBA); ok {\n\t\t\treturn SassValue{value: libs.MakeColor(sc)}, nil\n\t\t} else {\n\t\t\terr = errors.New(fmt.Sprintf(\"The struct type %s is unsupported for marshalling\", reflect.TypeOf(v).String()))\n\t\t\treturn SassValue{value: libs.MakeNil()}, err\n\t\t}\n\tcase reflect.Slice:\n\t\t// Initialize the list\n\t\tlst := libs.MakeList(f.Len())\n\t\tfor i := 0; i < f.Len(); i++ {\n\t\t\tt, er := makevalue(f.Index(i).Interface())\n\t\t\tif err == nil && er != nil {\n\t\t\t\terr = er\n\t\t\t}\n\t\t\tlibs.SetIndex(lst, i, t.Val())\n\t\t}\n\t\treturn SassValue{value: lst}, err\n\t}\n}\n\nfunc throwMisMatchTypeError(arg SassValue, expectedType string) error {\n\tvar intf interface{}\n\tunmarshal(arg, &intf)\n\tsvinf := libs.Interface(arg.Val())\n\treturn fmt.Errorf(\"Invalid Sass type expected: %s got: %T value: %v\",\n\t\texpectedType, svinf, svinf)\n}\n" }, { "path": "encoding_test.go", "content": "package libsass\n\nimport (\n\t\"fmt\"\n\t\"image/color\"\n\t\"reflect\"\n\t\"testing\"\n\n\t\"github.com/wellington/go-libsass/libs\"\n)\n\ntype unsupportedStruct struct {\n\tvalue float64\n}\n\ntype TestError interface {\n\tError(...interface{})\n}\n\nfunc testMarshal(t TestError, v interface{}) SassValue {\n\tres, err := Marshal(v)\n\tif err != nil {\n\t\tt.Error(err)\n\t}\n\treturn res\n}\n\nfunc TestUnmarshalNumber(t *testing.T) {\n\n\tc := libs.SassNumber{1.0, \"mm\"}\n\tsv, _ := makevalue(c)\n\tvar i libs.SassNumber\n\tUnmarshal(sv, &i)\n\tif c != i {\n\t\tt.Errorf(\"got: %v wanted: %v\", i, c)\n\t}\n\n\td := libs.SassNumber{1.5, \"pt\"}\n\tdv, _ := makevalue(d)\n\tvar ed libs.SassNumber\n\tUnmarshal(dv, &ed)\n\tif d != ed {\n\t\tt.Errorf(\"got: %v wanted: %v\", ed, d)\n\t}\n\n\td = libs.SassNumber{2.0, \"TaylorSwifts\"}\n\tdv, _ = makevalue(d)\n\tvar ei libs.SassNumber\n\terr := Unmarshal(dv, &ei)\n\tif err == nil {\n\t\tt.Error(\"No error thrown for invalid type\")\n\t}\n\tif e := fmt.Sprintf(\"SassNumber units %s are unsupported\", d.Unit); e != err.Error() {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\\n\", err.Error(), e)\n\t}\n\n}\n\nfunc TestUnmarshalStringValue(t *testing.T) {\n\te := \"example\"\n\tinput, _ := makevalue(e)\n\tvar s string\n\tUnmarshal(input, &s)\n\tif e != s {\n\t\tt.Errorf(\"got: % #v\\nwanted: %s\", s, e)\n\t}\n}\n\nfunc TestUnmarshalError(t *testing.T) {\n\te := \"error message\"\n\tobj := Error(fmt.Errorf(\"%s\", e))\n\tvar s string\n\terr := Unmarshal(obj, &s)\n\tif err != nil {\n\t\tt.Error(err)\n\t}\n\tif e != s {\n\t\tt.Errorf(\"got: %s wanted: %s\", s, e)\n\t}\n}\n\nfunc TestUnmarshal_complex(t *testing.T) {\n\t// Only interfaces supported for lists, is this ok?\n\te := []string{\"ex1\", \"ex2\"}\n\tlist, _ := makevalue(e)\n\tvar s []string\n\tUnmarshal(list, &s)\n\n\tif len(s) != len(e) {\n\t\tt.Error(\"Length mismatch\")\n\t\treturn\n\t}\n\n\tfor i := range e {\n\t\tif e[i] != s[i] {\n\t\t\tt.Errorf(\"got: %v wanted %v\", s, e)\n\t\t}\n\t}\n}\n\n// Can't import C in the test package, so this is how to test cgo code\nfunc TestUnmarshal_unknown(t *testing.T) {\n\t// Test for nil (no value, pointer, or empty error)\n\tvar unk interface{}\n\tres, err := Marshal(unk)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\tvar v interface{}\n\t_ = Unmarshal(res, &v)\n\tif v != \"\" {\n\t\tt.Error(\"non-nil returned\")\n\t}\n\n\t// Need a test for non-supported type\n}\n\nfunc TestMarshalInvalidUnitSassNumber(t *testing.T) {\n\tnum := libs.SassNumber{45, \"em\"}\n\tvar num2 libs.SassNumber\n\tx := testMarshal(t, num)\n\terror := Unmarshal(x, &num2)\n\n\tif error.Error() != \"SassNumber units em are unsupported\" {\n\t\tt.Errorf(\"got: %s wanted: %s\", error.Error(), \"SassNumber units em are unsupported\")\n\t}\n}\n\nfunc TestMarshal_list(t *testing.T) {\n\tlst1 := []libs.SassNumber{\n\t\tlibs.SassNumber{Value: 1, Unit: \"px\"},\n\t\tlibs.SassNumber{Value: 2, Unit: \"rad\"},\n\t\tlibs.SassNumber{Value: 3, Unit: \"grad\"},\n\t\tlibs.SassNumber{Value: 4, Unit: \"deg\"}}\n\tvar lst2 []libs.SassNumber\n\n\tx := testMarshal(t, lst1)\n\t_ = Unmarshal(x, &lst2)\n\n\tif len(lst1) != len(lst2) {\n\t\tt.Error(\"List length mismatch\")\n\t}\n\n\tfor i := range lst1 {\n\t\tif lst1[i] != lst2[i] {\n\t\t\tt.Errorf(\"wanted: %v got: %v\", lst1[i], lst2[i])\n\t\t}\n\t}\n}\n\nfunc TestMarshal_number_interface(t *testing.T) {\n\tvar fl = libs.SassNumber{Value: 3, Unit: \"turn\"}\n\tvar intf interface{}\n\n\tx := testMarshal(t, fl)\n\t_ = Unmarshal(x, &intf)\n\n\tif fl != intf {\n\t\tt.Errorf(\"got: %v wanted: %v\", intf, fl)\n\t}\n}\n\nfunc TestMarshalBool(t *testing.T) {\n\tvar b = bool(true)\n\tvar be bool\n\n\tbm := testMarshal(t, b)\n\tUnmarshal(bm, &be)\n\n\tif b != be {\n\t\tt.Errorf(\"got: %t wanted: %t\", be, b)\n\t}\n}\n\nfunc TestMarshalInterfaceListToMultiVariable(t *testing.T) {\n\tvar lst = []interface{}{libs.SassNumber{Value: 5, Unit: \"pt\"}, \"a\", true}\n\tvar i libs.SassNumber\n\tvar s string\n\tvar b bool\n\tvar ir = libs.SassNumber{5, \"pt\"}\n\tvar sr = string(\"a\")\n\tvar br = bool(true)\n\n\tlstm := testMarshal(t, lst)\n\t_ = Unmarshal(lstm, &i, &s, &b)\n\n\tif !reflect.DeepEqual(i, ir) {\n\t\tt.Errorf(\"got: %v wanted: %v\", i, ir)\n\t}\n\tif s != sr {\n\t\tt.Errorf(\"got: %s wanted: %s\", s, sr)\n\t}\n\tif b != br {\n\t\tt.Errorf(\"got: %t wanted: %t\", b, br)\n\t}\n}\n\nfunc TestMarshalInterfaceListToMultiVariablewList(t *testing.T) {\n\tvar lst = []interface{}{\n\t\tlibs.SassNumber{Value: 5, Unit: \"pt\"}, \"a\", true,\n\t\t[]string{\"a\", \"b\", \"c\", \"d\"}}\n\tvar i libs.SassNumber\n\tvar s string\n\tvar b bool\n\tvar sl []string\n\tvar ir = libs.SassNumber{Value: 5, Unit: \"pt\"}\n\tvar sr = string(\"a\")\n\tvar br = bool(true)\n\tvar slr = []string{\"a\", \"b\", \"c\", \"d\"}\n\n\tlstm := testMarshal(t, lst)\n\t_ = Unmarshal(lstm, &i, &s, &b, &sl)\n\n\tif !reflect.DeepEqual(i, ir) {\n\t\tt.Errorf(\"got: %v wanted: %v\", i, ir)\n\t}\n\tif s != sr {\n\t\tt.Errorf(\"got: %s wanted: %s\", s, sr)\n\t}\n\tif b != br {\n\t\tt.Errorf(\"got: %t wanted: %t\", b, br)\n\t}\n\tif !reflect.DeepEqual(sl, slr) {\n\t\tt.Errorf(\"got: %s wanted: %s\", sl, slr)\n\t}\n}\n\nfunc TestMarshalInterfaceListSingleVariable(t *testing.T) {\n\tvar lst = []interface{}{libs.SassNumber{Value: 5, Unit: \"mm\"}}\n\tvar i libs.SassNumber\n\tvar ir = libs.SassNumber{5, \"mm\"}\n\n\tlstm := testMarshal(t, lst)\n\t_ = Unmarshal(lstm, &i)\n\n\tif !reflect.DeepEqual(i, ir) {\n\t\tt.Errorf(\"got: %v wanted: %v\", i, ir)\n\t}\n}\n\nfunc TestMarshalSassNumber(t *testing.T) {\n\tsn := libs.SassNumber{\n\t\tValue: float64(3.5),\n\t\tUnit: \"px\",\n\t}\n\tvar sne = libs.SassNumber{}\n\n\tsnm := testMarshal(t, sn)\n\t_ = Unmarshal(snm, &sne)\n\n\tif !reflect.DeepEqual(sne, sn) {\n\t\tt.Errorf(\"wanted:\\n%#v\\ngot:\\n% #v\", sn, sne)\n\t}\n}\n\nfunc TestMarshalError(t *testing.T) {\n\te := \"error has been thrown\"\n\terr := fmt.Errorf(e)\n\teusv := Error(err)\n\tvar s string\n\tUnmarshal(eusv, &s)\n\n\tif s != e {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\", s, e)\n\t}\n}\n\nfunc TestMarshalColor(t *testing.T) {\n\tc := color.RGBA{\n\t\tR: uint8(5),\n\t\tG: uint8(6),\n\t\tB: uint8(7),\n\t\tA: uint8(8),\n\t}\n\tvar ce = color.RGBA{}\n\n\tcm := testMarshal(t, c)\n\t_ = Unmarshal(cm, &ce)\n\n\tif !reflect.DeepEqual(ce, c) {\n\t\tt.Errorf(\"What the damn hell. Wanted:\\n%#v\\ngot:\\n% #v\", c, ce)\n\t}\n}\n\nfunc TestListListtoInterfaceList(t *testing.T) {\n\tvar lst = []interface{}{\"a\", \"b\"}\n\tvar lstlst = []interface{}{lst}\n\n\tvar lst2 []interface{}\n\n\tvar elst = []interface{}{\"a\", \"b\"}\n\n\tx := testMarshal(t, lstlst)\n\t_ = Unmarshal(x, &lst2)\n\n\tif len(lst2) != len(elst) {\n\t\tt.Error(\"List length mismatch\")\n\t}\n\n\tif !reflect.DeepEqual(lst2, elst) {\n\t\tt.Errorf(\"What the damn hell. Wanted:\\n%#v\\ngot:\\n% #v\", elst, lst2)\n\t}\n}\n\nfunc TestSlice_make(t *testing.T) {\n\tl := []string{\"a\", \"b\"}\n\tx := testMarshal(t, l)\n\tvar res []string\n\terr := Unmarshal(x, &res)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\tif e := len(l); e != len(res) {\n\t\tt.Errorf(\"got: %d wanted: %d\", len(res), e)\n\t}\n\tif e := l[0]; e != res[0] {\n\t\tt.Fatalf(\"got: %s wanted: %s\", res[0], e)\n\t}\n\n\t// Now test new fancy libs.Slice()\n\tres = []string{}\n\tlibs.Slice(x.Val(), &res)\n\tif e := len(l); e != len(res) {\n\t\tt.Errorf(\"got: %d wanted: %d\", len(res), e)\n\t}\n\tif e := l[0]; e != res[0] {\n\t\tt.Fatalf(\"got: %s wanted: %s\", res[0], e)\n\t}\n}\n\nfunc TestSlice_mixedtypes(t *testing.T) {\n\tinfs := []interface{}{\"a\", \"b\", libs.SassNumber{Value: 1, Unit: \"mm\"}}\n\tsv := testMarshal(t, infs)\n\tvar res []interface{}\n\tlibs.Slice(sv.Val(), &res)\n\n\tif !reflect.DeepEqual(res, infs) {\n\t\tt.Errorf(\"got: % #v wanted: % #v\\n\", res, infs)\n\t}\n\n}\n\nfunc TestSV_equal(t *testing.T) {\n\tb := libs.MakeBool(true)\n\tbb := libs.MakeBool(true)\n\n\tif libs.Interface(b) != libs.Interface(bb) {\n\t\tt.Fatal(\"equal failed\")\n\t}\n\n\tc := libs.MakeColor(color.RGBA{})\n\tcc := libs.MakeColor(color.RGBA{})\n\n\tif libs.Interface(c) != libs.Interface(cc) {\n\t\tt.Fatal(\"equal failed\")\n\t}\n\n\ts := libs.MakeString(\"hi\")\n\tss := libs.MakeString(\"hi\")\n\tif libs.Interface(s) != libs.Interface(ss) {\n\t\tt.Fatal(\"equal failed\")\n\t}\n}\n\nfunc TestMarshal_map_set(t *testing.T) {\n\tt.Skip(\"maps are not supported\")\n\tm := map[string]string{\"key\": \"val\"}\n\tx := testMarshal(t, m)\n\tvar mm map[string]string\n\terr := Unmarshal(x, &mm)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\tfmt.Printf(\"% #v\\n\", mm)\n}\n\nfunc TestMarshalUnsupportedStruct(t *testing.T) {\n\tus := unsupportedStruct{\n\t\tvalue: 5.5,\n\t}\n\n\t_, err := Marshal(us)\n\n\texpectedErr := fmt.Errorf(\n\t\t\"The struct type %s is unsupported for marshalling\",\n\t\treflect.TypeOf(us).String())\n\n\tif !reflect.DeepEqual(expectedErr, err) {\n\t\tt.Errorf(\"Marshalling of unsupported struct did not return an error\")\n\t}\n}\n\nfunc TestQuotedStringUnmarshal(t *testing.T) {\n\ttestmap := []string{\n\t\t\"\\\"Taylor Swift\\\"\",\n\t\t\"'Taylor Swift'\",\n\t}\n\te := \"Taylor Swift\"\n\n\tvar se string\n\n\tfor _, s := range testmap {\n\t\tsm := testMarshal(t, s)\n\t\tUnmarshal(sm, &se)\n\t\tif e != se {\n\t\t\tt.Errorf(\"What the damn hell. Got: %s wanted: %s\", se, e)\n\t\t}\n\n\t}\n}\n\nfunc TestOptionalParameters(t *testing.T) {\n\tvar lst = []interface{}{libs.SassNumber{Value: 5, Unit: \"px\"}, \"a\", true}\n\tvar i libs.SassNumber\n\tvar s string\n\tvar b bool\n\tvar s2 string\n\tvar i2 float64\n\tvar ir = libs.SassNumber{Value: 5, Unit: \"px\"}\n\tvar sr = string(\"a\")\n\tvar br = bool(true)\n\n\tlstm := testMarshal(t, lst)\n\t_ = Unmarshal(lstm, &i, &s, &b, &s2, &i2)\n\n\tif !reflect.DeepEqual(i, ir) {\n\t\tt.Errorf(\"got: %v wanted: %v\", i, ir)\n\t}\n\tif s != sr {\n\t\tt.Errorf(\"got: %s wanted: %s\", s, sr)\n\t}\n\tif b != br {\n\t\tt.Errorf(\"got: %t wanted: %t\", b, br)\n\t}\n\tif s2 != \"\" {\n\t\tt.Errorf(\"got: %s wanted empty string\", s)\n\t}\n\tif i2 != 0 {\n\t\tt.Errorf(\"got: %f wanted: 0\", i2)\n\t}\n\n}\n\nfunc TestNullUnionSassValue(t *testing.T) {\n\tusv := NewSassValue()\n\tvar inf interface{}\n\terr := Unmarshal(usv, &inf)\n\te := \"I can't work with this. arg UnionSassValue must not be nil. - Unmarshaller\"\n\tif err != nil {\n\t\tt.Errorf(\"got: %s wanted: %s\", err, e)\n\t}\n}\n\nfunc TestWrongUnmarshalToFloatType(t *testing.T) {\n\ts := \"Taylor Swift\"\n\tvar ie libs.SassNumber\n\n\tsm := testMarshal(t, s)\n\terr := Unmarshal(sm, &ie)\n\n\te := \"Invalid Sass type expected: color.RGBA or SassNumber got: string value: Taylor Swift\"\n\tif err.Error() != e {\n\t\tt.Errorf(\"got:\\n%s \\nwanted:\\n%s\", err, e)\n\t}\n}\n" }, { "path": "error.go", "content": "package libsass\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n)\n\n// SassError represents an error object returned from Sass. SassError\n// stores useful information for bubbling up libsass errors.\ntype SassError struct {\n\tStatus, Line, Column int\n\tFile, Message string\n}\n\n// ProcessSassError reads the original libsass error and creates helpful debuggin\n// information for debuggin that error.\nfunc (ctx *compctx) ProcessSassError(bs []byte) error {\n\n\tif len(bs) == 0 {\n\t\treturn nil\n\t}\n\n\terr := json.Unmarshal(bs, &ctx.err)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\terrors := ctx.err\n\tctx.errorString = fmt.Sprintf(\"Error > %s:%d\\n%s\",\n\t\terrors.File, errors.Line, errors.Message)\n\treturn nil\n}\n\nfunc (ctx *compctx) Error() string {\n\treturn ctx.errorString\n}\n\n// Reset returns removes all error state information.\nfunc (ctx *compctx) Reset() {\n\tctx.errorString = \"\"\n}\n\n// ErrorLine attempts to resolve the file associated with\n// a stdin:#\nfunc (ctx *compctx) ErrorLine() int {\n\tvar n int\n\tfmt.Sscanf(ctx.Error(), \"Error > stdin:%d\", &n)\n\treturn n\n}\n" }, { "path": "error_test.go", "content": "package libsass\n\nimport (\n\t\"bytes\"\n\t\"strings\"\n\n\t\"testing\"\n)\n\ntype ErrorMap struct {\n\tline int\n\tmessage string\n}\n\nfunc TestError_basic(t *testing.T) {\n\tin := bytes.NewBufferString(`div {\n @include invalid-function('');\n}`)\n\tout := bytes.NewBuffer([]byte(\"\"))\n\tctx := newContext()\n\terr := ctx.compile(out, in)\n\tif err == nil {\n\t\tt.Error(\"No error returned\")\n\t}\n\n\te := ErrorMap{2, \"no mixin named invalid-function\"}\n\n\tif e.line != ctx.err.Line {\n\t\tt.Errorf(\"wanted: %d\\ngot: %d\", e.line, ctx.err.Line)\n\t}\n\n\tif !strings.Contains(ctx.err.Message, e.message) {\n\t\tt.Errorf(\"%q does not contain %q\", ctx.err.Message, e.message)\n\t}\n\n\tif ctx.errorString != ctx.Error() {\n\t\tt.Errorf(\"wanted: %s got: %s\", ctx.errorString, ctx.Error())\n\t}\n}\n\nfunc TestError_JSON(t *testing.T) {\n\tin := bytes.NewBufferString(`div {\n height: 10px;`)\n\tout := &bytes.Buffer{}\n\tctx := newContext()\n\terr := ctx.compile(out, in)\n\n\te := `Error > stdin:2\nInvalid CSS after \" height: 10px;\": expected \"}\", was \"\"\ndiv {\n height: 10px;\n`\n\n\tif err == nil {\n\t\tt.Fatal(\"no error thrown\")\n\t}\n\n\tif e != err.Error() {\n\t\tt.Fatalf(\"got: %s\\nwanted: %s\", err, e)\n\t}\n}\n\nfunc TestError_unbound(t *testing.T) {\n\tin := bytes.NewBufferString(`div {\n background: map-get($sprite,139);\n}`)\n\tout := bytes.NewBuffer([]byte(\"\"))\n\tctx := newContext()\n\terr := ctx.compile(out, in)\n\tif err == nil {\n\t\tt.Error(\"No error returned\")\n\t}\n\n\te := ErrorMap{2, \"unbound variable $sprite\"}\n\tif e.line != ctx.err.Line {\n\t\tt.Errorf(\"wanted:\\n%d\\ngot:\\n%d\", e.line, ctx.err.Line)\n\t}\n\n}\n\nfunc TestError_function(t *testing.T) {\n\tin := bytes.NewBufferString(`// Empty line\n@function uniqueFnName($file) {\n @return map-get($file,prop);\n}\ndiv {\n background: uniqueFnName(randfile);\n}`)\n\tout := bytes.NewBuffer([]byte(\"\"))\n\tctx := newContext()\n\terr := ctx.compile(out, in)\n\tif err == nil {\n\t\tt.Error(\"No error returned\")\n\t}\n\n\te := ErrorMap{3, \"argument `$map` of `map-get($map, $key)` must be a map\"}\n\tif e.line != ctx.err.Line {\n\t\tt.Errorf(\"wanted:\\n%d\\ngot:\\n%d\", e.line, ctx.err.Line)\n\t}\n\n\tif !strings.Contains(ctx.err.Message, e.message) {\n\t\tt.Errorf(\"%q does not contain %q\", ctx.err.Message, e.message)\n\t}\n}\n\nfunc TestError_import(t *testing.T) {\n\tin := bytes.NewBufferString(`span {}\n@import \"fail\";\n`)\n\n\tout := bytes.NewBuffer([]byte(\"\"))\n\tctx := newContext()\n\terr := ctx.compile(out, in)\n\tif err == nil {\n\t\tt.Error(\"No error returned\")\n\t}\n\te := ErrorMap{2, `File to import not found or unreadable: fail.`}\n\tif e.line != ctx.err.Line {\n\t\tt.Errorf(\"wanted:\\n%d\\ngot:\\n%d\", e.line, ctx.err.Line)\n\t}\n\n\tif !strings.Contains(ctx.err.Message, e.message) {\n\t\tt.Errorf(\"%q does not contain %q\", ctx.err.Message, e.message)\n\t}\n}\n\nfunc TestError_processsass(t *testing.T) {\n\tin := []byte(`{\n \"status\": 1,\n \"file\": \"stdin\",\n \"line\": 3100,\n \"column\": 20,\n \"message\": \"error in C function inline-image: format: .svg not supported\\nBacktrace:\\n\\tstdin:3100, in function inline-image\\n\\tstdin:3100, in mixin printCSSImg\\n\\tstdin:3117\"\n}`)\n\tctx := newContext()\n\terr := ctx.ProcessSassError(in)\n\tif err != nil {\n\t\tt.Error(err)\n\t}\n\n\te := `Error > stdin:3100\nerror in C function inline-image: format: .svg not supported\nBacktrace:\n\tstdin:3100, in function inline-image\n\tstdin:3100, in mixin printCSSImg\n\tstdin:3117`\n\tif e != ctx.Error() {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\", err.Error(), e)\n\t}\n}\n\nfunc TestError_invalid(t *testing.T) {\n\tctx := newContext()\n\terr := ctx.ProcessSassError([]byte(\"/a\"))\n\n\tif len(err.Error()) == 0 {\n\t\tt.Error(\"No error thrown on invalid sass json package\")\n\t}\n}\n\nfunc TestError_line(t *testing.T) {\n\tctx := newContext()\n\tctx.errorString = \"Error > stdin:1000\"\n\tif e := 1000; e != ctx.ErrorLine() {\n\t\tt.Errorf(\"got: %d wanted: %d\", ctx.ErrorLine(), e)\n\t}\n\n}\n" }, { "path": "examples/basic/file.scss", "content": "div {\n p { color: black; }\n}\n" }, { "path": "examples/basic/main.go", "content": "package main\n\nimport (\n\t\"log\"\n\t\"os\"\n\n\tlibsass \"github.com/wellington/go-libsass\"\n)\n\nfunc main() {\n\tr, err := os.Open(\"file.scss\")\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\tcomp, err := libsass.New(os.Stdout, r)\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\tif err := comp.Run(); err != nil {\n\t\tlog.Fatal(err)\n\t}\n}\n" }, { "path": "examples/customfunc/README.md", "content": "Cryptographically secure pseudorandom number generator in Sass. Well that is easy to do with this custom `crypto()` handler!\n\nStart by registering a Sass function with the name `crypto()`. Now when `crypto()` is found in Sass, the cryptotext Go function will be called.\n\nInput\n\n``` sass\ndiv { text: crypto(); }\n\n```\n\n\nOutput\n\n``` css\ndiv {\n text: 'c91db27d5e580ef4292e'; }\n```\n\nSass function written in Go\n\n``` go\nfunc cryptotext(ctx context.Context, usv libsass.SassValue) (*libsass.SassValue, error) {\n\n\tc := 10\n\tb := make([]byte, c)\n\t_, err := rand.Read(b)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tres, err := libsass.Marshal(fmt.Sprintf(\"'%x'\", b))\n\treturn &res, err\n}\n```\n" }, { "path": "examples/customfunc/main.go", "content": "package main\n\nimport (\n\t\"bytes\"\n\t\"context\"\n\t\"crypto/rand\"\n\t\"fmt\"\n\t\"log\"\n\t\"os\"\n\n\t\"github.com/wellington/go-libsass\"\n)\n\n// cryptotext is of type libsass.SassFunc. As libsass compiles the\n// source Sass, it will look for `crypto()` then call this function.\nfunc cryptotext(ctx context.Context, usv libsass.SassValue) (*libsass.SassValue, error) {\n\n\tc := 10\n\tb := make([]byte, c)\n\t_, err := rand.Read(b)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tres, err := libsass.Marshal(fmt.Sprintf(\"'%x'\", b))\n\treturn &res, err\n}\n\nfunc main() {\n\t// Register a custom Sass func crypto\n\tlibsass.RegisterSassFunc(\"crypto()\", cryptotext)\n\n\t// Input Sass source\n\tinput := `div { text: crypto(); }`\n\n\tbuf := bytes.NewBufferString(input)\n\t// Starts a compiler writing to Stdout and reading from\n\t// a bytes buffer of the input source\n\tcomp, err := libsass.New(os.Stdout, buf)\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\t// Run() kicks off the compiler and instructs libsass how\n\t// to read our input, handling the output from libsass\n\tif err := comp.Run(); err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\t// Output:\n\t// div {\n\t// text: 'c91db27d5e580ef4292e'; }\n}\n" }, { "path": "examples/custompreamble/README.md", "content": "Example using libSass Headers. Headers include Sass code at the top of every file. It is used by Wellington to include mixins like sprite-dimensions. In this example, we add a preamble to every file. It could be used to add license notes or include base styles that are shared everywhere.\n" }, { "path": "examples/custompreamble/main.go", "content": "// Create a preamble for every CSS file\npackage main\n\nimport (\n\t\"bytes\"\n\t\"log\"\n\t\"os\"\n\n\t\"github.com/wellington/go-libsass\"\n)\n\nfunc main() {\n\tlibsass.RegisterHeader(`\n/*\n * This is a preamble which will be added to every CSS file generated.\n * It uses the libSass header which includes the text on every file.\n *\n */`)\n\n\t// Input Sass source\n\tinput := `div {}`\n\n\tbuf := bytes.NewBufferString(input)\n\t// Starts a compiler writing to Stdout and reading from\n\t// a bytes buffer of the input source\n\tcomp, err := libsass.New(os.Stdout, buf)\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\t// Run() kicks off the compiler and instructs libsass how\n\t// to read our input, handling the output from libsass\n\tif err := comp.Run(); err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\t// Output:\n\t// /*\n\t// * This is a preamble which will be added to every CSS file generated.\n\t//\t* It uses the libSass header which includes the text on every file.\n\t//\t*\n\t//\t*/\n\t//\n}\n" }, { "path": "examples/options/file.scss", "content": "@import \"settings\"\n\nhtml {\n background-color: $bg;\n}\n" }, { "path": "examples/options/main.go", "content": "package main\n\nimport (\n\t\"log\"\n\t\"os\"\n\n\tlibsass \"github.com/wellington/go-libsass\"\n)\n\nfunc main() {\n\tr, err := os.Open(\"file.scss\")\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\tcomp, err := libsass.New(os.Stdout, r)\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\t// configure @import paths\n\tincludePaths := []string{\"partials\"}\n\terr = comp.Option(libsass.IncludePaths(includePaths))\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\tif err := comp.Run(); err != nil {\n\t\tlog.Fatal(err)\n\t}\n}\n" }, { "path": "examples/options/partials/_settings.sass", "content": "$bg: red" }, { "path": "export.go", "content": "package libsass\n\nimport \"github.com/wellington/go-libsass/libs\"\n\n// Error takes a Go error and returns a libsass Error\nfunc Error(err error) SassValue {\n\treturn SassValue{value: libs.MakeError(err.Error())}\n}\n\n// Warn takes a string and causes a warning in libsass\nfunc Warn(s string) SassValue {\n\treturn SassValue{value: libs.MakeWarning(s)}\n}\n" }, { "path": "export_test.go", "content": "package libsass\n\nimport (\n\t\"errors\"\n\t\"testing\"\n)\n\nfunc TestRegisterHandler(t *testing.T) {\n\tl := len(globalHandlers)\n\tRegisterHandler(\"foo\",\n\t\tfunc(v interface{}, csv SassValue, rsv *SassValue) error {\n\t\t\tu, _ := Marshal(false)\n\t\t\t*rsv = u\n\t\t\treturn nil\n\t\t})\n\tif e := l + 1; len(globalHandlers) != e {\n\t\tt.Errorf(\"got: %d wanted: %d\", len(globalHandlers), e)\n\t}\n}\n\nfunc TestError_simple(t *testing.T) {\n\terr := errors.New(\"help me\")\n\tsv := Error(err)\n\n\tvar s string\n\tUnmarshal(sv, &s)\n\tif err.Error() != s {\n\t\tt.Errorf(\"got: %s wanted: %s\", s, err)\n\t}\n}\n" }, { "path": "file_test.go", "content": "package libsass\n\nimport (\n\t\"bytes\"\n\t\"path/filepath\"\n\t\"strings\"\n\t\"testing\"\n)\n\nfunc TestFile_resolved(t *testing.T) {\n\tpath := \"test/scss/main.scss\"\n\tvar out bytes.Buffer\n\tctx := newContext()\n\terr := ctx.fileCompile(path, &out, \"\", \"\")\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\n\te := ``\n\n\tif e != out.String() {\n\t\tt.Errorf(\"wanted:\\n%s\\n\"+\n\t\t\t\"got:\\n%s\\n\", e, out.String())\n\t}\n\n\tif e := 1; len(ctx.ResolvedImports) != e {\n\t\tt.Errorf(\"got: %d wanted: %d\", len(ctx.ResolvedImports), e)\n\t}\n\n\tabs, err := filepath.Abs(\".\")\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\trelPath := strings.TrimPrefix(ctx.ResolvedImports[0], abs)\n\n\tif !strings.HasSuffix(relPath, path) {\n\t\tt.Errorf(\"got: %s wanted: %s\", relPath, e)\n\t}\n\n}\n" }, { "path": "func.go", "content": "package libsass\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"sync\"\n\n\t\"github.com/wellington/go-libsass/libs\"\n)\n\nvar ghMu sync.RWMutex\n\n// globalHandlers is the list of handlers registered externally\nvar globalHandlers []handler\n\n// RegisterSassFunc assigns the passed Func to the specified signature sign\nfunc RegisterSassFunc(sign string, fn SassFunc) {\n\tghMu.Lock()\n\tglobalHandlers = append(globalHandlers, handler{\n\t\tsign: sign,\n\t\tcallback: SassHandler(fn),\n\t})\n\tghMu.Unlock()\n}\n\ntype key int\n\nconst (\n\tcompkey key = iota\n)\n\nfunc NewCompilerContext(c Compiler) context.Context {\n\treturn context.WithValue(context.TODO(), compkey, c)\n}\n\nvar ErrCompilerNotFound = errors.New(\"compiler not found\")\n\n// CompFromCtx retrieves a compiler from a passed context\nfunc CompFromCtx(ctx context.Context) (Compiler, error) {\n\tv := ctx.Value(compkey)\n\tcomp, ok := v.(Compiler)\n\tif !ok {\n\t\treturn comp, ErrCompilerNotFound\n\t}\n\treturn comp, nil\n}\n\n// SassFunc describes func for handling Sass Values\ntype SassFunc func(ctx context.Context, in SassValue) (*SassValue, error)\n\n// SassHandler contains callback context for running code within\n// a libsass handler\nfunc SassHandler(h SassFunc) libs.SassCallback {\n\treturn func(v interface{}, usv libs.UnionSassValue, rsv *libs.UnionSassValue) error {\n\t\tif *rsv == nil {\n\t\t\t*rsv = libs.MakeNil()\n\t\t}\n\n\t\tlibCtx, ok := v.(*compctx)\n\t\tif !ok {\n\t\t\treturn errors.New(\"libsass Context not found\")\n\t\t}\n\n\t\tctx := NewCompilerContext(libCtx.compiler)\n\n\t\t// Cast to exported Go types\n\t\treq := SassValue{value: usv}\n\t\tres, err := h(ctx, req)\n\n\t\tif err != nil {\n\t\t\t// Returns the error to libsass Compiler\n\t\t\t*rsv = libs.MakeError(err.Error())\n\t\t\t// Returning an error does nothing as libsass is in charge of\n\t\t\t// reporting error to user\n\t\t\treturn err\n\t\t}\n\n\t\t*rsv = res.Val()\n\t\treturn err\n\t}\n}\n\n// RegisterHandler sets the passed signature and callback to the\n// handlers array.\nfunc RegisterHandler(sign string, callback HandlerFunc) {\n\tghMu.Lock()\n\tglobalHandlers = append(globalHandlers, handler{\n\t\tsign: sign,\n\t\tcallback: Handler(callback),\n\t})\n\tghMu.Unlock()\n}\n\n// HandlerFunc describes the method signature for registering\n// a Go function to be called by libsass.\ntype HandlerFunc func(v interface{}, req SassValue, res *SassValue) error\n\n// Handler accepts a HandlerFunc and returns SassCallback for sending\n// to libsass. The third argument must be a pointer and the function\n// must return an error.\nfunc Handler(h HandlerFunc) libs.SassCallback {\n\treturn func(v interface{}, usv libs.UnionSassValue, rsv *libs.UnionSassValue) error {\n\t\tif *rsv == nil {\n\t\t\t*rsv = libs.MakeNil()\n\t\t}\n\t\treq := SassValue{value: usv}\n\t\tres := SassValue{value: *rsv}\n\t\terr := h(v, req, &res)\n\n\t\tif rsv != nil {\n\t\t\t*rsv = res.Val()\n\t\t}\n\n\t\treturn err\n\t}\n}\n\ntype handler struct {\n\tsign string\n\tcallback libs.SassCallback\n}\n\nvar _ libs.SassCallback = TestCallback\n\nfunc testCallback(h HandlerFunc) libs.SassCallback {\n\treturn func(v interface{}, _ libs.UnionSassValue, _ *libs.UnionSassValue) error {\n\t\treturn nil\n\t}\n}\n\n// TestCallback implements libs.SassCallback. TestCallback is a useful\n// place to start when developing new handlers.\nvar TestCallback = testCallback(func(_ interface{}, _ SassValue, _ *SassValue) error {\n\treturn nil\n})\n\n// Cookie is used for passing context information to libsass. Cookie is\n// passed to custom handlers when libsass executes them through the go\n// bridge.\ntype Func struct {\n\tSign string\n\tFn libs.SassCallback\n\tCtx interface{}\n}\n\ntype Funcs struct {\n\tsync.RWMutex\n\twg sync.WaitGroup\n\tclosing chan struct{}\n\tf []Func\n\tidx []int\n\n\t// Func are complex, we need a reference to the entire context to\n\t// successfully execute them.\n\tctx *compctx\n}\n\nfunc NewFuncs(ctx *compctx) *Funcs {\n\treturn &Funcs{\n\t\tclosing: make(chan struct{}),\n\t\tctx: ctx,\n\t}\n}\n\nfunc (fs *Funcs) Add(f Func) {\n\tfs.Lock()\n\tdefer fs.Unlock()\n\tfs.f = append(fs.f, f)\n}\n\n// SetFunc assigns the registered methods to SassOptions. Functions\n// are called when the compiler encounters the registered signature.\nfunc (fs *Funcs) Bind(goopts libs.SassOptions) {\n\tghMu.RLock()\n\tcookies := make([]libs.Cookie, len(globalHandlers)+len(fs.f))\n\t// Append registered handlers to cookie array\n\tfor i, h := range globalHandlers {\n\t\tcookies[i] = libs.Cookie{\n\t\t\tSign: h.sign,\n\t\t\tFn: h.callback,\n\t\t\tCtx: fs.ctx,\n\t\t}\n\t}\n\tl := len(globalHandlers)\n\tghMu.RUnlock()\n\n\tfor i, h := range fs.f {\n\t\tcookies[i+l] = libs.Cookie{\n\t\t\tSign: h.Sign,\n\t\t\tFn: h.Fn,\n\t\t\tCtx: fs.ctx,\n\t\t}\n\t}\n\tfs.idx = libs.BindFuncs(goopts, cookies)\n}\n\nfunc (fs *Funcs) Close() {\n\terr := libs.RemoveFuncs(fs.idx)\n\tif err != nil {\n\t\tfmt.Println(\"error cleaning up funcs\", err)\n\t}\n\tclose(fs.closing)\n\tfs.wg.Wait()\n}\n" }, { "path": "func_test.go", "content": "package libsass\n\nimport (\n\t\"bytes\"\n\t\"image/color\"\n\t\"reflect\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/wellington/go-libsass/libs\"\n)\n\nfunc TestFunc_simpletypes(t *testing.T) {\n\tin := bytes.NewBufferString(`div {\n background: foo(null, 3px, asdf, false);\n}`)\n\n\t//var out bytes.Buffer\n\tctx := newContext()\n\t// Communication channel for the C Sass callback function\n\tch := make(chan []interface{}, 1)\n\n\tctx.Funcs.Add(Func{\n\n\t\tSign: \"foo($null, $num, $str, $bool)\",\n\t\tFn: Handler(func(v interface{}, req SassValue, res *SassValue) error {\n\t\t\tvar n interface{}\n\t\t\tvar num libs.SassNumber\n\t\t\tvar s string\n\t\t\tvar b bool\n\t\t\tvar intf = []interface{}{n, num, s, b}\n\t\t\terr := Unmarshal(req, &intf)\n\t\t\tif err != nil {\n\t\t\t\tt.Fatal(err)\n\t\t\t}\n\t\t\t// Send the interface fn arguments to the ch channel\n\t\t\tch <- intf\n\t\t\treturn nil\n\t\t}),\n\t\tCtx: &ctx,\n\t})\n\tvar out bytes.Buffer\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Error(err)\n\t}\n\n\te := []interface{}{\n\t\t\"\",\n\t\tlibs.SassNumber{Value: 3.0, Unit: \"px\"},\n\t\t\"asdf\",\n\t\tfalse,\n\t}\n\tvar args []interface{}\n\tselect {\n\tcase <-time.After(10 * time.Millisecond):\n\t\tt.Fatal(\"timeout\")\n\tcase args = <-ch:\n\t}\n\tif !reflect.DeepEqual(e, args) {\n\t\tt.Errorf(\"wanted:\\n% #v\\ngot:\\n% #v\", e, args)\n\t}\n}\n\nfunc TestFunc_colortype(t *testing.T) {\n\tin := bytes.NewBufferString(`div {\n background: foo(#005500);\n}`)\n\n\t//var out bytes.Buffer\n\tctx := newContext()\n\t// Communication channel for the C Sass callback function\n\tch := make(chan []interface{}, 1)\n\n\tctx.Funcs.Add(Func{\n\t\tSign: \"foo($color)\",\n\t\tFn: func(v interface{}, usv libs.UnionSassValue, rsv *libs.UnionSassValue) error {\n\t\t\t// Send the interface fn arguments to the ch channel\n\t\t\tvar infs = []interface{}{color.RGBA{}}\n\t\t\terr := Unmarshal(SassValue{value: usv}, &infs)\n\t\t\tif err != nil {\n\t\t\t\tt.Fatal(err)\n\t\t\t}\n\t\t\tch <- infs\n\t\t\tres, _ := Marshal(false)\n\t\t\t*rsv = res.Val()\n\t\t\treturn nil\n\t\t},\n\t\tCtx: &ctx,\n\t})\n\tvar out bytes.Buffer\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Error(err)\n\t}\n\n\te := []interface{}{\n\t\tcolor.RGBA{R: 0x0, G: 0x55, B: 0x0, A: 0x1},\n\t}\n\tvar args []interface{}\n\tselect {\n\tcase <-time.After(100 * time.Millisecond):\n\t\tt.Fatal(\"timeout\")\n\tcase args = <-ch:\n\t}\n\tif !reflect.DeepEqual(e, args) {\n\t\tt.Errorf(\"wanted:\\n% #v\\ngot:\\n% #v\", e, args)\n\t}\n\n}\n\nfunc TestFunc_complextypes(t *testing.T) {\n\tin := bytes.NewBufferString(`div {\n\t background: foo((a,b,1mm,#003300));\n\t }`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tch := make(chan interface{}, 1)\n\tctx.Funcs.Add(Func{\n\t\tSign: \"foo($list)\",\n\t\tFn: func(v interface{}, usv libs.UnionSassValue, rsv *libs.UnionSassValue) error {\n\t\t\tvar sv interface{}\n\t\t\tUnmarshal(SassValue{value: usv}, &sv)\n\t\t\tch <- sv\n\t\t\tres, _ := Marshal(false)\n\t\t\t*rsv = res.Val()\n\t\t\treturn nil\n\t\t},\n\t\tCtx: &ctx,\n\t})\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Error(err)\n\t}\n\n\te := []interface{}{\n\t\t\"a\",\n\t\t\"b\",\n\t\tlibs.SassNumber{Value: 1, Unit: \"mm\"},\n\t\tcolor.RGBA{R: 0x0, G: 0x33, B: 0x0, A: 0x1},\n\t}\n\tvar args interface{}\n\tselect {\n\tcase <-time.After(100 * time.Millisecond):\n\t\tt.Fatal(\"timeout\")\n\tcase args = <-ch:\n\t}\n\tif !reflect.DeepEqual(e, args) {\n\t\tt.Errorf(\"wanted:\\n%#v\\ngot:\\n% #v\", e, args)\n\t}\n}\n\nfunc TestFunc_customarity(t *testing.T) {\n\tin := bytes.NewBufferString(`div {\n color: red(blue);\n background: foo(1pt, 2cm);\n}`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\n\tctx.Funcs.Add(Func{\n\t\tSign: \"foo()\",\n\t\tFn: TestCallback,\n\t\tCtx: &ctx,\n\t})\n\terr := ctx.compile(&out, in)\n\tif err == nil {\n\t\tt.Error(\"No error thrown for incorrect arity\")\n\t}\n\te := \"wrong number of arguments (2 for 0) for `foo'\"\n\tif e != ctx.err.Message {\n\t\tt.Errorf(\"wanted:\\n%s\\ngot:\\n%s\\n\", e, ctx.err.Message)\n\t}\n\te = `Error > stdin:3\nwrong number of arguments (2 for 0) for ` + \"`\" + `foo'\ndiv {\n color: red(blue);\n background: foo(1pt, 2cm);\n}\n`\n\tif e != err.Error() {\n\t\tt.Errorf(\"wanted:\\n%s\\ngot:\\n%s\\n\", e, err)\n\t}\n\n}\n" }, { "path": "go.mod", "content": "module github.com/wellington/go-libsass\n\ngo 1.18\n\nrequire golang.org/x/net v0.0.0-20220921203646-d300de134e69\n" }, { "path": "go.sum", "content": "golang.org/x/net v0.0.0-20220921203646-d300de134e69 h1:hUJpGDpnfwdJW8iNypFjmSY0sCBEL+spFTZ2eO+Sfps=\ngolang.org/x/net v0.0.0-20220921203646-d300de134e69/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=\n" }, { "path": "header.go", "content": "package libsass\n\nimport (\n\t\"strconv\"\n\t\"sync\"\n\n\t\"github.com/wellington/go-libsass/libs\"\n)\n\nvar globalHeaders []string\n\n// RegisterHeader fifo\nfunc RegisterHeader(body string) {\n\tghMu.Lock()\n\tglobalHeaders = append(globalHeaders, body)\n\tghMu.Unlock()\n}\n\ntype Header struct {\n\tidx *string\n\tContent string\n}\n\ntype Headers struct {\n\twg sync.WaitGroup\n\tclosing chan struct{}\n\tsync.RWMutex\n\th []Header\n\t// idx is a pointer for libsass to lookup these Headers\n\tidx int\n}\n\n// NewHeaders instantiates a Headers for prefixing Sass to input\n// See: https://github.com/sass/libsass/wiki/API-Sass-Importer\nfunc NewHeaders() *Headers {\n\th := &Headers{\n\t\tclosing: make(chan struct{}),\n\t}\n\treturn h\n}\n\nfunc (hdrs *Headers) Bind(opts libs.SassOptions) {\n\t// Push the headers into the local array\n\tghMu.RLock()\n\tfor _, gh := range globalHeaders {\n\t\tif !hdrs.Has(gh) {\n\t\t\thdrs.Add(gh)\n\t\t}\n\t}\n\tghMu.RUnlock()\n\n\t// Loop through headers creating ImportEntry\n\tentries := make([]libs.ImportEntry, hdrs.Len())\n\thdrs.RLock()\n\tfor i, ent := range hdrs.h {\n\t\tuniquename := \"hdr\" + strconv.FormatInt(int64(i), 10)\n\t\tentries[i] = libs.ImportEntry{\n\t\t\t// Each entry requires a unique identifier\n\t\t\t// https://github.com/sass/libsass/issues/1292\n\t\t\tPath: uniquename,\n\t\t\tSource: ent.Content,\n\t\t\tSrcMap: \"\",\n\t\t}\n\t}\n\thdrs.RUnlock()\n\t// Preserve reference to libs address to these entries\n\thdrs.idx = libs.BindHeader(opts, entries)\n}\n\nfunc (hdrs *Headers) Close() {\n\t// Clean up memory reserved for headers\n\tlibs.RemoveHeaders(hdrs.idx)\n\tclose(hdrs.closing)\n\thdrs.wg.Wait()\n}\n\nfunc (h *Headers) Add(s string) {\n\th.Lock()\n\tdefer h.Unlock()\n\n\th.h = append(h.h, Header{\n\t\tContent: s,\n\t})\n}\n\nfunc (h *Headers) Has(s string) bool {\n\tfor _, c := range h.h {\n\t\tif s == c.Content {\n\t\t\treturn true\n\t\t}\n\t}\n\treturn false\n}\n\nfunc (h *Headers) Len() int {\n\treturn len(h.h)\n}\n" }, { "path": "header_test.go", "content": "package libsass\n\nimport (\n\t\"bytes\"\n\t\"testing\"\n)\n\nfunc TestSassHeader_single(t *testing.T) {\n\tin := bytes.NewBufferString(`div {\n @include mix();\n}\n`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.Headers.Add(`@mixin mix() {\n width: 50px;\n}\n`)\n\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tfor _, h := range ctx.Headers.h {\n\t\t\tt.Logf(\"% #v\\n\", h)\n\t\t}\n\t\tt.Fatal(err)\n\t}\n\te := `div {\n width: 50px; }\n`\n\tif e != out.String() {\n\t\tt.Fatalf(\"got:\\n%s\\nwanted:\\n%s\", out.String(), e)\n\t}\n\n}\n\nfunc TestSassHeader_multi(t *testing.T) {\n\tin := bytes.NewBufferString(`div {\n @include mix();\n color: red();\n}\n`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.Headers.Add(`@mixin mix() {\n width: 50px;\n}\n`)\n\tctx.Headers.Add(`@function red() { @return red; }`)\n\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\te := `div {\n width: 50px;\n color: red; }\n`\n\tif e != out.String() {\n\t\tt.Fatalf(\"got:\\n%s\\nwanted:\\n%s\", out.String(), e)\n\t}\n\n}\n" }, { "path": "importer.go", "content": "package libsass\n\nimport (\n\t\"errors\"\n\t\"io\"\n\t\"sync\"\n\t\"time\"\n\n\t\"github.com/wellington/go-libsass/libs\"\n)\n\nvar (\n\tErrImportNotFound = errors.New(\"Import unreachable or not found\")\n)\n\n// Import contains Rel and Abs path and a string of the contents\n// representing an import.\ntype Import struct {\n\tBody io.ReadCloser\n\tbytes []byte\n\tmod time.Time\n\tPrev string\n\tPath string\n}\n\n// ModTime returns modification time\nfunc (i Import) ModTime() time.Time {\n\treturn i.mod\n}\n\n// Imports is a map with key of \"path/to/file\"\ntype Imports struct {\n\twg sync.WaitGroup\n\tclosing chan struct{}\n\tsync.RWMutex\n\tm map[string]Import\n\tresolver ResolverCallback\n\tidx int\n}\n\ntype ResolverCallback struct {\n\tresolverMode libs.ResolverMode\n\tresolverFn libs.ImportResolver\n}\n\nfunc NewImports() *Imports {\n\treturn &Imports{\n\t\tclosing: make(chan struct{}),\n\t}\n}\n\nfunc NewImportsWithResolver(resolver libs.ImportResolver) *Imports {\n\treturn &Imports{\n\t\tclosing: make(chan struct{}),\n\t\tresolver: ResolverCallback{\n\t\t\tresolverMode: libs.ResolverModeImporterUrl,\n\t\t\tresolverFn: resolver,\n\t\t},\n\t}\n}\n\nfunc NewImportsWithAbsResolver(resolver libs.ImportResolver) *Imports {\n\treturn &Imports{\n\t\tclosing: make(chan struct{}),\n\t\tresolver: ResolverCallback{\n\t\t\tresolverMode: libs.ResolverModeImporterAbsPath,\n\t\t\tresolverFn: resolver,\n\t\t},\n\t}\n}\n\nfunc (i *Imports) Close() {\n\tclose(i.closing)\n\ti.wg.Wait()\n}\n\n// Init sets up a new Imports map\nfunc (p *Imports) Init() {\n\tp.m = make(map[string]Import)\n}\n\n// Add registers an import in the context.Imports\nfunc (p *Imports) Add(prev string, path string, bs []byte) error {\n\tp.Lock()\n\tdefer p.Unlock()\n\n\t// TODO: align these with libsass name \"stdin\"\n\tif len(prev) == 0 || prev == \"string\" {\n\t\tprev = \"stdin\"\n\t}\n\tim := Import{\n\t\tbytes: bs,\n\t\tmod: time.Now(),\n\t\tPrev: prev,\n\t\tPath: path,\n\t}\n\n\tp.m[prev+\":\"+path] = im\n\treturn nil\n}\n\n// Del removes the import from the context.Imports\nfunc (p *Imports) Del(path string) {\n\tp.Lock()\n\tdefer p.Unlock()\n\n\tdelete(p.m, path)\n}\n\n// Get retrieves import bytes by path\nfunc (p *Imports) Get(prev, path string) ([]byte, error) {\n\tp.RLock()\n\tdefer p.RUnlock()\n\tfor _, imp := range p.m {\n\t\tif imp.Prev == prev && imp.Path == path {\n\t\t\treturn imp.bytes, nil\n\t\t}\n\t}\n\treturn nil, ErrImportNotFound\n}\n\n// Update attempts to create a fresh Body from the given path\n// Files last modified stamps are compared against import timestamp\nfunc (p *Imports) Update(name string) {\n\tp.Lock()\n\tdefer p.Unlock()\n\n}\n\n// Len counts the number of entries in context.Imports\nfunc (p *Imports) Len() int {\n\treturn len(p.m)\n}\n\n// Bind accepts a SassOptions and adds the registered\n// importers in the context.\nfunc (p *Imports) Bind(opts libs.SassOptions) {\n\tentries := make([]libs.ImportEntry, p.Len())\n\ti := 0\n\n\tp.RLock()\n\tfor _, ent := range p.m {\n\t\tbs := ent.bytes\n\t\tentries[i] = libs.ImportEntry{\n\t\t\tParent: ent.Prev,\n\t\t\tPath: ent.Path,\n\t\t\tSource: string(bs),\n\t\t}\n\t\ti++\n\t}\n\tp.RUnlock()\n\n\twrappedResolverFn := func(url string, prev string) (newURL string, body string, resolved bool) {\n\t\tif p.resolver.resolverFn != nil {\n\t\t\tnewURL, body, resolved = p.resolver.resolverFn(url, prev)\n\t\t\tif resolved {\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\t\tentry, err := libs.GetEntry(entries, prev, url)\n\t\tif err == nil {\n\t\t\treturn url, entry, true\n\t\t}\n\t\treturn \"\", \"\", false\n\t}\n\n\t// set entries somewhere so GC doesn't collect it\n\tp.idx = libs.BindImporter(opts, p.resolver.resolverMode, wrappedResolverFn)\n}\n" }, { "path": "importer_test.go", "content": "package libsass\n\nimport (\n\t\"bytes\"\n\t\"strings\"\n\t\"testing\"\n)\n\nfunc TestSassImport_single(t *testing.T) {\n\tin := bytes.NewBufferString(`@import \"a\";`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.Imports.m = make(map[string]Import)\n\tctx.Imports.Add(\"\", \"a\", []byte(\"a { color: blue; }\"))\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\te := `a {\n color: blue; }\n`\n\tif e != out.String() {\n\t\tt.Fatalf(\"got:\\n%s\\nwanted:\\n%s\", out.String(), e)\n\t}\n\n}\n\nfunc TestSassImport_file(t *testing.T) {\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.Imports.m = make(map[string]Import)\n\tctx.Imports.Add(\"test/scss/file.scss\", \"a\", []byte(\"a { color: blue; }\"))\n\terr := ctx.fileCompile(\"test/scss/file.scss\", &out, \"\", \"\")\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\te := `a {\n color: blue; }\n`\n\n\tif e != out.String() {\n\t\tt.Fatalf(\"got:\\n%s\\nwanted:\\n%s\", out.String(), e)\n\t}\n\n}\n\nfunc TestSassImport_multi(t *testing.T) {\n\tin := bytes.NewBufferString(`@import \"a\";\n@import \"b\";`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.Imports.m = make(map[string]Import)\n\tctx.Imports.Add(\"\", \"a\", []byte(\"a { color: blue; }\"))\n\tctx.Imports.Add(\"\", \"b\", []byte(\"b { font-weight: bold; }\"))\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\te := `a {\n color: blue; }\n\nb {\n font-weight: bold; }\n`\n\n\tif e != out.String() {\n\t\tt.Fatalf(\"got:\\n%s\\nwanted:\\n%s\", out.String(), e)\n\t}\n\n}\n\nfunc TestSassImporter_placeholder(t *testing.T) {\n\tin := bytes.NewBufferString(`@import \"branch\";\ndiv.branch {\n @extend %branch;\n}`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.Imports.m = make(map[string]Import)\n\tctx.Imports.Add(\"\", \"branch\", []byte(`%branch { color: brown; }`))\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\te := `div.branch {\n color: brown; }\n`\n\tif e != out.String() {\n\t\tt.Fatalf(\"got:\\n%s\\nwanted:\\n%s\", out.String(), e)\n\t}\n}\n\nfunc TestSassImporter_nested_placeholder(t *testing.T) {\n\tin := bytes.NewBufferString(`@import \"branch\";\ndiv.branch {\n @extend %branch;\n div.leaf {\n @extend %leaf;\n }\n}`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.Imports.m = make(map[string]Import)\n\tctx.Imports.Add(\"\", \"branch\", []byte(`@import \"leaf\";\n%branch { color: brown; }`))\n\tctx.Imports.Add(\"branch\", \"leaf\", []byte(\"%leaf { color: green; }\"))\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\te := `div.branch div.leaf {\n color: green; }\n\ndiv.branch {\n color: brown; }\n`\n\tif e != out.String() {\n\t\tt.Fatalf(\"got:\\n%s\\nwanted:\\n%s\", out.String(), e)\n\t}\n}\n\nfunc TestSassImporter_invalidimport(t *testing.T) {\n\tin := bytes.NewBufferString(`@import \"branch\";\ndiv.branch {\n @extend %branch;\n div.leaf {\n @extend %leaf;\n }\n}`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.Imports.m = make(map[string]Import)\n\terr := ctx.compile(&out, in)\n\tif err == nil {\n\t\tt.Fatal(\"No error thrown for missing import\")\n\t}\n\n\tmsg := \"File to import not found or unreadable: branch.\"\n\tif !strings.Contains(err.Error(), msg) {\n\t\tt.Errorf(\"%q does not contain %q\", err.Error(), msg)\n\t}\n}\n\nfunc TestSassImporter_notfound(t *testing.T) {\n\tin := bytes.NewBufferString(`@import \"branch\";\ndiv.branch {\n @extend %branch;\n div.leaf {\n @extend %leaf;\n }\n}`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.Imports.m = make(map[string]Import)\n\tctx.Imports.Add(\"\", \"nope\", []byte(`@import \"leaf\";\n%branch { color: brown; }`))\n\terr := ctx.compile(&out, in)\n\n\tmsg := \"File to import not found or unreadable: branch.\"\n\tif !strings.Contains(err.Error(), msg) {\n\t\tt.Errorf(\"%q does not contain %q\", err.Error(), msg)\n\t}\n}\n" }, { "path": "libs/SharedPtr.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/memory/SharedPtr.hpp\"\n#endif\n" }, { "path": "libs/ast.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/ast.hpp\"\n#endif\n" }, { "path": "libs/ast_fwd_decl.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/ast_fwd_decl.hpp\"\n#endif\n" }, { "path": "libs/base64vlq.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/base64vlq.hpp\"\n#endif\n" }, { "path": "libs/bind.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/bind.hpp\"\n#endif\n" }, { "path": "libs/cencode.c", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/cencode.c\"\n#endif\n" }, { "path": "libs/check_nesting.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/check_nesting.hpp\"\n#endif\n" }, { "path": "libs/color_maps.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/color_maps.hpp\"\n#endif\n" }, { "path": "libs/color_names.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/color_names.hpp\"\n#endif\n" }, { "path": "libs/constants.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/constants.hpp\"\n#endif\n" }, { "path": "libs/context.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/context.hpp\"\n#endif\n" }, { "path": "libs/cssize.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/cssize.hpp\"\n#endif\n" }, { "path": "libs/docs.go", "content": "// libs is a direct mapping to libsass C API. This package should not be\n// necessary to do any high level operations. It is instead intended\n// that go-libsass handles everything needed in your project.\n//\n// In case where low level API calls are necessary, use this package\n// to do so. For more details on what these methods do see:\n// https://github.com/sass/libsass/wiki/API-Documentation\n//\n// For the most part, consider this a hand curated SWIG of libsass C API.\npackage libs\n" }, { "path": "libs/emitter.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/emitter.hpp\"\n#endif\n" }, { "path": "libs/encoding.go", "content": "package libs\n\n// #include \n// #include \"sass/context.h\"\nimport \"C\"\nimport (\n\t\"image/color\"\n\t\"reflect\"\n\t\"unsafe\"\n)\n\ntype UnionSassValue *C.union_Sass_Value\n\n// NewUnionSassValue creates a new empty UnionSassValue\nfunc NewUnionSassValue() UnionSassValue {\n\treturn MakeNil()\n}\n\nfunc CloneValue(usv UnionSassValue) UnionSassValue {\n\treturn C.sass_clone_value(usv)\n}\n\nfunc DeleteValue(usv UnionSassValue) {\n\tC.sass_delete_value(usv)\n}\n\n// MakeNil creates Sass nil\nfunc MakeNil() UnionSassValue {\n\treturn C.sass_make_null()\n}\n\n// MakeBool creates Sass bool from a bool\nfunc MakeBool(b bool) UnionSassValue {\n\treturn C.sass_make_boolean(C.bool(b))\n}\n\n// MakeError creates Sass error from a string\nfunc MakeError(s string) UnionSassValue {\n\tcs := C.CString(s)\n\tdefer C.free(unsafe.Pointer(cs))\n\treturn C.sass_make_error(cs)\n}\n\n// MakeWarning creates Sass warning from a string\nfunc MakeWarning(s string) UnionSassValue {\n\tcs := C.CString(s)\n\tdefer C.free(unsafe.Pointer(cs))\n\treturn C.sass_make_warning(cs)\n}\n\nfunc MakeString(s string) UnionSassValue {\n\tstr := C.CString(s)\n\tdefer C.free(unsafe.Pointer(str))\n\treturn C.sass_make_string(str)\n}\n\n// TODO: validate unit\nfunc MakeNumber(f float64, unit string) UnionSassValue {\n\tcunit := C.CString(unit)\n\tcf := C.double(f)\n\tdefer C.free(unsafe.Pointer(cunit))\n\treturn C.sass_make_number(cf, cunit)\n}\n\n// MakeColor creates a Sass color from color.RGBA\nfunc MakeColor(c color.RGBA) UnionSassValue {\n\tr := C.double(c.R)\n\tg := C.double(c.G)\n\tb := C.double(c.B)\n\ta := C.double(c.A)\n\treturn C.sass_make_color(r, g, b, a)\n}\n\n// MakeList creates a Sass List\nfunc MakeList(len int) UnionSassValue {\n\treturn C.sass_make_list(C.size_t(len), C.SASS_COMMA, false)\n}\n\n// MakeMap cretes a new Sass Map\nfunc MakeMap(len int) UnionSassValue {\n\treturn C.sass_make_map(C.size_t(len))\n}\n\n// Slice creates a Sass List from a Go slice. Reflection is used.\nfunc Slice(usv UnionSassValue, inf interface{}) {\n\tif !IsList(usv) {\n\t\tpanic(\"sass value is not a list\")\n\t}\n\tl := Len(usv)\n\tr := reflect.ValueOf(inf)\n\tif r.Kind() == reflect.Ptr {\n\t\tr = r.Elem()\n\t}\n\tif !r.CanSet() {\n\t\tpanic(\"value is not addressable\")\n\t}\n\t// if a non-slice is passed, make a slice\n\tt := r.Type()\n\tif r.Kind() != reflect.Slice {\n\t\tt = reflect.SliceOf(t)\n\t}\n\td := reflect.MakeSlice(t, l, l)\n\tfor i := 0; i < l; i++ {\n\t\tsv := Index(usv, i)\n\t\tinf := Interface(sv)\n\t\trf := reflect.ValueOf(inf)\n\t\t// Special case for nil\n\t\tif inf == nil {\n\t\t\td.Index(i).Set(reflect.ValueOf(\"\"))\n\t\t\tcontinue\n\t\t}\n\t\td.Index(i).Set(rf)\n\t}\n\tr.Set(d)\n}\n\nfunc IsNil(usv UnionSassValue) bool {\n\treturn bool(C.sass_value_is_null(usv))\n}\n\nfunc IsBool(usv UnionSassValue) bool {\n\treturn bool(C.sass_value_is_boolean(usv))\n}\n\nfunc IsString(usv UnionSassValue) bool {\n\treturn bool(C.sass_value_is_string(usv))\n}\n\nfunc IsColor(usv UnionSassValue) bool {\n\treturn bool(C.sass_value_is_color(usv))\n}\n\nfunc IsNumber(usv UnionSassValue) bool {\n\treturn bool(C.sass_value_is_number(usv))\n}\n\nfunc IsList(usv UnionSassValue) bool {\n\treturn bool(C.sass_value_is_list(usv))\n}\n\nfunc IsMap(usv UnionSassValue) bool {\n\treturn bool(C.sass_value_is_map(usv))\n}\n\nfunc IsError(usv UnionSassValue) bool {\n\treturn bool(C.sass_value_is_error(usv))\n}\n\n// Interface creates Go types from union sass_value\nfunc Interface(usv UnionSassValue) interface{} {\n\tswitch {\n\tcase IsNil(usv):\n\t\treturn nil\n\tcase IsBool(usv):\n\t\treturn Bool(usv)\n\tcase IsString(usv):\n\t\treturn String(usv)\n\tcase IsColor(usv):\n\t\treturn Color(usv)\n\tcase IsNumber(usv):\n\t\treturn Number(usv)\n\tcase IsList(usv):\n\t\tfallthrough\n\t\t//return List(usv)\n\tcase IsMap(usv):\n\t\tfallthrough\n\t\t//return Map(usv)\n\tdefault:\n\t\treturn nil\n\t}\n\tpanic(\"call of interface not supported on type\")\n}\n\nfunc Len(usv UnionSassValue) int {\n\tswitch {\n\tcase IsList(usv):\n\t\treturn int(C.sass_list_get_length(usv))\n\tcase IsMap(usv):\n\t\treturn int(C.sass_map_get_length(usv))\n\t}\n\tpanic(\"call of len on unknown type\")\n}\n\nfunc Error(usv UnionSassValue) string {\n\tc := C.sass_error_get_message(usv)\n\tgc := C.GoString(c)\n\treturn gc\n}\n\nfunc String(usv UnionSassValue) string {\n\tc := C.sass_string_get_value(usv)\n\tgc := C.GoString(c)\n\treturn gc\n}\n\ntype SassNumber struct {\n\tValue float64\n\tUnit string\n}\n\nfunc (n SassNumber) Float() float64 {\n\treturn n.Value\n}\n\nfunc (n SassNumber) UnitOf() string {\n\treturn n.Unit\n}\n\nfunc Number(usv UnionSassValue) SassNumber {\n\treturn SassNumber{\n\t\tValue: Float(usv),\n\t\tUnit: Unit(usv),\n\t}\n}\n\nfunc Float(usv UnionSassValue) float64 {\n\tf := C.sass_number_get_value(usv)\n\treturn float64(f)\n}\n\nfunc Unit(usv UnionSassValue) string {\n\tc := C.sass_number_get_unit(usv)\n\treturn C.GoString(c)\n}\n\nfunc Bool(usv UnionSassValue) bool {\n\tb := C.sass_boolean_get_value(usv)\n\treturn bool(b)\n}\n\nfunc Color(usv UnionSassValue) color.Color {\n\treturn color.RGBA{\n\t\tR: uint8(C.sass_color_get_r(usv)),\n\t\tG: uint8(C.sass_color_get_g(usv)),\n\t\tB: uint8(C.sass_color_get_b(usv)),\n\t\tA: uint8(C.sass_color_get_a(usv)),\n\t}\n}\n\nfunc Index(usv UnionSassValue, i int) UnionSassValue {\n\tswitch {\n\tcase IsList(usv):\n\t\treturn C.sass_list_get_value(usv, C.size_t(i))\n\tdefault:\n\t\tpanic(\"call of index on unknown type\")\n\t}\n\treturn NewUnionSassValue()\n}\n\nfunc SetIndex(usv UnionSassValue, i int, item UnionSassValue) {\n\tswitch {\n\tcase IsList(usv):\n\t\tC.sass_list_set_value(usv, C.size_t(i), item)\n\t\treturn\n\tdefault:\n\t}\n\tpanic(\"call of setindex on unknown type\")\n}\n\nfunc MapKeys(m UnionSassValue) []UnionSassValue {\n\tres := make([]UnionSassValue, Len(m))\n\tfor i := range res {\n\t\tres[i] = C.sass_map_get_key(m, C.size_t(i))\n\t}\n\treturn res\n}\n\nfunc mapVals(m UnionSassValue) []UnionSassValue {\n\tres := make([]UnionSassValue, Len(m))\n\tfor i := range res {\n\t\tres[i] = C.sass_map_get_value(m, C.size_t(i))\n\t}\n\treturn res\n}\n\n// TODO: support maps\n// func MapIndex(m UnionSassValue, key UnionSassValue) UnionSassValue {\n// \tkeys := MapKeys(m)\n// }\n" }, { "path": "libs/environment.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/environment.hpp\"\n#endif\n" }, { "path": "libs/error_handling.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/error_handling.hpp\"\n#endif\n" }, { "path": "libs/eval.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/eval.hpp\"\n#endif\n" }, { "path": "libs/expand.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/expand.hpp\"\n#endif\n" }, { "path": "libs/export.go", "content": "package libs\n\n// #include \"sass/context.h\"\n//\nimport \"C\"\nimport (\n\t\"fmt\"\n\t\"sync\"\n)\n\n// SassCallback defines the callback libsass eventually executes in\n// sprite_sass\ntype SassCallback func(v interface{}, csv UnionSassValue, rsv *UnionSassValue) error\n\n// Cookie is used for passing context information to libsass. Cookie is\n// passed to custom handlers when libsass executes them through the go\n// bridge.\ntype Cookie struct {\n\tSign string\n\tFn SassCallback\n\tCtx interface{}\n}\n\n// gate gobridge, it has some unknown race conditions\nvar gobridgeMu sync.Mutex\n\n// GoBridge is exported to C for linking libsass to Go. This function\n// adheres to the interface provided by libsass.\n//\n//export GoBridge\nfunc GoBridge(cargs UnionSassValue, cidx C.int) UnionSassValue {\n\t// Recover the Cookie struct passed in\n\tidx := int(cidx)\n\tck, ok := globalFuncs.Get(idx).(Cookie)\n\tif !ok {\n\t\tfmt.Printf(\"failed to resolve Cookie %d\\n\", idx)\n\t\treturn MakeNil()\n\t}\n\t// ck := *(*Cookie)(ptr)\n\n\tvar usv UnionSassValue\n\terr := ck.Fn(ck.Ctx, cargs, &usv)\n\t_ = err\n\treturn usv\n}\n" }, { "path": "libs/extend.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/extend.hpp\"\n#endif\n" }, { "path": "libs/file.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/file.hpp\"\n#endif\n" }, { "path": "libs/func.go", "content": "package libs\n\n// #include \n// #include \n// #include \"sass/context.h\"\n//\n// extern union Sass_Value* GoBridge( union Sass_Value* s_args, uintptr_t idx);\n//\n// union Sass_Value* CallSassFunction( union Sass_Value* s_args, Sass_Function_Entry cb, struct Sass_Options* opts ) {\n// void* cookie = sass_function_get_cookie(cb);\n// union Sass_Value* ret;\n// uintptr_t idx = (uintptr_t)cookie;\n// ret = GoBridge(s_args, idx);\n// return ret;\n// }\n//\nimport \"C\"\nimport \"unsafe\"\n\ntype SassFunc C.Sass_Function_Entry\n\n// SassMakeFunction binds a Go pointer to a Sass function signature\nfunc SassMakeFunction(signature string, idx int) SassFunc {\n\tcsign := C.CString(signature)\n\tptr := unsafe.Pointer(uintptr(idx))\n\tfn := C.sass_make_function(\n\t\tcsign,\n\t\tC.Sass_Function_Fn(C.CallSassFunction),\n\t\tptr)\n\n\treturn (SassFunc)(fn)\n}\n\nvar globalFuncs SafeMap\n\nfunc init() {\n\tglobalFuncs.init()\n}\n\n// BindFuncs attaches a slice of Functions to a sass options. Signatures\n// are already defined in the SassFunc.\nfunc BindFuncs(opts SassOptions, cookies []Cookie) []int {\n\n\tfuncs := make([]SassFunc, len(cookies))\n\tids := make([]int, len(cookies))\n\tfor i, cookie := range cookies {\n\t\tidx := globalFuncs.Set(cookies[i])\n\t\tfn := SassMakeFunction(cookie.Sign, idx)\n\t\tfuncs[i] = fn\n\t\tids[i] = idx\n\t}\n\n\tsz := C.size_t(len(funcs))\n\tcfuncs := C.sass_make_function_list(sz)\n\tfor i, cfn := range funcs {\n\t\tC.sass_function_set_list_entry(cfuncs, C.size_t(i), C.Sass_Function_Entry(cfn))\n\t}\n\tC.sass_option_set_c_functions(opts, cfuncs)\n\treturn ids\n}\n\nfunc RemoveFuncs(ids []int) error {\n\tfor _, idx := range ids {\n\t\tglobalFuncs.Del(idx)\n\t}\n\treturn nil\n}\n" }, { "path": "libs/functions.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/functions.hpp\"\n#endif\n" }, { "path": "libs/header.go", "content": "package libs\n\n// #include \n// #include \n// #include \"sass/context.h\"\n//\n// extern struct Sass_Import** HeaderBridge(uintptr_t idx);\n//\n// Sass_Import_List SassHeaders(const char* cur_path, Sass_Importer_Entry cb, struct Sass_Compiler* comp)\n// {\n// void* cookie = sass_importer_get_cookie(cb);\n// uintptr_t idx = (uintptr_t)cookie;\n// Sass_Import_List list = HeaderBridge(idx);\n// return list;\n//\n// }\n//\nimport \"C\"\nimport \"unsafe\"\n\nvar globalHeaders SafeMap\n\nfunc init() {\n\tglobalHeaders.init()\n}\n\n// BindHeader attaches the header to a libsass context ensuring\n// gc does not delete the pointers necessary to make this happen.\nfunc BindHeader(opts SassOptions, entries []ImportEntry) int {\n\n\tidx := globalHeaders.Set(entries)\n\t// ptr := unsafe.Pointer(idx)\n\tczero := C.double(0)\n\timper := C.sass_make_importer(\n\t\tC.Sass_Importer_Fn(C.SassHeaders),\n\t\tczero,\n\t\tunsafe.Pointer(uintptr(idx)),\n\t)\n\timpers := C.sass_make_importer_list(1)\n\tC.sass_importer_set_list_entry(impers, 0, imper)\n\n\tC.sass_option_set_c_headers(\n\t\t(*C.struct_Sass_Options)(unsafe.Pointer(opts)),\n\t\timpers)\n\treturn idx\n}\n\nfunc RemoveHeaders(idx int) error {\n\tglobalHeaders.Del(idx)\n\treturn nil\n}\n" }, { "path": "libs/helpers.go", "content": "package libs\n\n// #include \n// #include \"sass/context.h\"\nimport \"C\"\n\nimport (\n\t\"reflect\"\n\t\"unsafe\"\n)\n\nfunc GetImportList(ctx SassContext) []string {\n\tcctx := (*C.struct_Sass_Context)(ctx)\n\tlen := int(C.sass_context_get_included_files_size(cctx))\n\timps := C.sass_context_get_included_files(cctx)\n\tlist := make([]string, len, len)\n\thdr := reflect.SliceHeader{\n\t\tData: uintptr(unsafe.Pointer(imps)),\n\t\tLen: len, Cap: len,\n\t}\n\tgoimps := *(*[]*C.char)(unsafe.Pointer(&hdr))\n\tfor i := range goimps {\n\t\tlist[i] = C.GoString(goimps[i])\n\t}\n\treturn list\n}\n\nfunc Version() string {\n\ts := C.libsass_version()\n\treturn C.GoString(s)\n}\n" }, { "path": "libs/importer.go", "content": "package libs\n\n// #include \n// #include \n// #include \n// #include \"sass/context.h\"\n//\n// extern struct Sass_Import** ImporterBridge(const char* url, const char* prev, uintptr_t idx);\n//\n// Sass_Import_List SassImporterPathsHandler(const char* cur_path, Sass_Importer_Entry cb, struct Sass_Compiler* comp)\n// {\n// void* cookie = sass_importer_get_cookie(cb);\n// struct Sass_Import* previous = sass_compiler_get_last_import(comp);\n// const char* prev_path = sass_import_get_imp_path(previous);\n// uintptr_t idx = (uintptr_t)cookie;\n// Sass_Import_List list = ImporterBridge(cur_path, prev_path, idx);\n// return list;\n// }\n//\n// Sass_Import_List SassImporterAbsHandler(const char* cur_path, Sass_Importer_Entry cb, struct Sass_Compiler* comp)\n// {\n// void* cookie = sass_importer_get_cookie(cb);\n// struct Sass_Import* previous = sass_compiler_get_last_import(comp);\n// const char* prev_abs_path = sass_import_get_abs_path(previous);\n// uintptr_t idx = (uintptr_t)cookie;\n// Sass_Import_List list = ImporterBridge(cur_path, prev_abs_path, idx);\n// return list;\n// }\n//\n//\n// #ifndef UINTMAX_MAX\n// # ifdef __UINTMAX_MAX__\n// # define UINTMAX_MAX __UINTMAX_MAX__\n// # endif\n// #endif\n//\n// //size_t max_size = UINTMAX_MAX;\nimport \"C\"\nimport \"unsafe\"\n\nvar globalImports SafeMap\n\n// ImportResolver can be used as a custom import resolver. Return an empty body to\n// signal loading the import body from the URL.\ntype ImportResolver func(url string, prev string) (newURL string, body string, resolved bool)\n\ntype ResolverMode int\n\nconst (\n\tResolverModeImporterUrl ResolverMode = iota\n\tResolverModeImporterAbsPath\n)\n\nfunc init() {\n\tglobalImports.init()\n}\n\n// BindImporter attaches a custom importer Go function to an import in Sass\nfunc BindImporter(opts SassOptions, resolverMode ResolverMode, resolver ImportResolver) int {\n\n\tidx := globalImports.Set(resolver)\n\tptr := unsafe.Pointer(uintptr(idx))\n\n\tvar handler unsafe.Pointer\n\tif resolverMode == ResolverModeImporterAbsPath {\n\t\thandler = C.SassImporterAbsHandler\n\t} else {\n\t\thandler = C.SassImporterPathsHandler\n\t}\n\n\timper := C.sass_make_importer(\n\t\tC.Sass_Importer_Fn(handler),\n\t\tC.double(0),\n\t\tptr,\n\t)\n\timpers := C.sass_make_importer_list(1)\n\tC.sass_importer_set_list_entry(impers, 0, imper)\n\n\tC.sass_option_set_c_importers(\n\t\t(*C.struct_Sass_Options)(unsafe.Pointer(opts)),\n\t\timpers,\n\t)\n\treturn idx\n}\n\nfunc RemoveImporter(idx int) error {\n\tglobalImports.Del(idx)\n\treturn nil\n}\n" }, { "path": "libs/inspect.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/inspect.hpp\"\n#endif\n" }, { "path": "libs/json.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/json.hpp\"\n#endif\n" }, { "path": "libs/kwd_arg_macros.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/kwd_arg_macros.hpp\"\n#endif\n" }, { "path": "libs/lexer.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/lexer.hpp\"\n#endif\n" }, { "path": "libs/listize.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/listize.hpp\"\n#endif\n" }, { "path": "libs/mapping.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/mapping.hpp\"\n#endif\n" }, { "path": "libs/node.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/node.hpp\"\n#endif\n" }, { "path": "libs/operation.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/operation.hpp\"\n#endif\n" }, { "path": "libs/output.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/output.hpp\"\n#endif\n" }, { "path": "libs/parser.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/parser.hpp\"\n#endif\n" }, { "path": "libs/paths.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/paths.hpp\"\n#endif\n" }, { "path": "libs/plugins.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/plugins.hpp\"\n#endif\n" }, { "path": "libs/position.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/position.hpp\"\n#endif\n" }, { "path": "libs/prelexer.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/prelexer.hpp\"\n#endif\n" }, { "path": "libs/remove_placeholders.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/remove_placeholders.hpp\"\n#endif\n" }, { "path": "libs/safemap.go", "content": "package libs\n\nimport \"sync\"\n\n// globalImports stores []ImportEntry in a place where GC won't\n// delete it\ntype SafeMap struct {\n\tsync.RWMutex\n\tidx int\n\tm map[int]interface{}\n}\n\nfunc (s *SafeMap) nextidx() int {\n\ts.Lock()\n\tdefer s.Unlock()\n\ts.idx++\n\treturn s.idx\n}\n\nfunc (s *SafeMap) init() {\n\ts.m = make(map[int]interface{})\n}\n\nfunc (s *SafeMap) Get(idx int) interface{} {\n\ts.RLock()\n\tdefer s.RUnlock()\n\treturn s.m[idx]\n}\n\nfunc (s *SafeMap) Del(idx int) {\n\ts.Lock()\n\tdelete(s.m, idx)\n\ts.Unlock()\n}\n\n// set accepts an entry and returns an index for it\nfunc (s *SafeMap) Set(ie interface{}) int {\n\tidx := s.nextidx()\n\ts.Lock()\n\ts.m[idx] = ie\n\tdefer s.Unlock()\n\n\treturn idx\n}\n" }, { "path": "libs/sass_number.go", "content": "package libs\n\nimport (\n\t\"math\"\n\t\"strconv\"\n)\n\nfunc (s SassNumber) String() string {\n\treturn strconv.FormatFloat(s.Value, 'f', -1, 64) + s.Unit\n}\n\nvar sassUnitConversions = map[string]map[string]float64{\n\t\"in\": {\n\t\t\"in\": 1,\n\t\t\"cm\": 2.54,\n\t\t\"pc\": 6,\n\t\t\"mm\": 25.4,\n\t\t\"pt\": 72,\n\t\t\"px\": 96,\n\t\t\"deg\": 1,\n\t\t\"grad\": 1,\n\t\t\"rad\": 1,\n\t\t\"turn\": 1,\n\t},\n\t\"cm\": {\n\t\t\"in\": 1.0 / 2.54,\n\t\t\"cm\": 1,\n\t\t\"pc\": 6.0 / 2.54,\n\t\t\"mm\": 10,\n\t\t\"pt\": 72.0 / 2.54,\n\t\t\"px\": 96.0 / 2.54,\n\t\t\"deg\": 1,\n\t\t\"grad\": 1,\n\t\t\"rad\": 1,\n\t\t\"turn\": 1,\n\t},\n\t\"pc\": {\n\t\t\"in\": 1.0 / 6.0,\n\t\t\"cm\": 2.54 / 6.0,\n\t\t\"pc\": 1,\n\t\t\"mm\": 25.4 / 6.0,\n\t\t\"pt\": 72.0 / 6.0,\n\t\t\"px\": 96.0 / 6.0,\n\t\t\"deg\": 1,\n\t\t\"grad\": 1,\n\t\t\"rad\": 1,\n\t\t\"turn\": 1,\n\t},\n\t\"mm\": {\n\t\t\"in\": 1.0 / 25.4,\n\t\t\"cm\": 1.0 / 10.0,\n\t\t\"pc\": 6.0 / 25.4,\n\t\t\"mm\": 1,\n\t\t\"pt\": 72.0 / 25.4,\n\t\t\"px\": 96.0 / 25.4,\n\t\t\"deg\": 1,\n\t\t\"grad\": 1,\n\t\t\"rad\": 1,\n\t\t\"turn\": 1,\n\t},\n\t\"pt\": {\n\t\t\"in\": 1.0 / 72.0,\n\t\t\"cm\": 2.54 / 72.0,\n\t\t\"pc\": 6.0 / 72.0,\n\t\t\"mm\": 25.4 / 72.0,\n\t\t\"pt\": 1,\n\t\t\"px\": 96.0 / 72.0,\n\t\t\"deg\": 1,\n\t\t\"grad\": 1,\n\t\t\"rad\": 1,\n\t\t\"turn\": 1,\n\t},\n\t\"px\": {\n\t\t\"in\": 1.0 / 96.0,\n\t\t\"cm\": 2.54 / 96.0,\n\t\t\"pc\": 6.0 / 96.0,\n\t\t\"mm\": 25.4 / 96.0,\n\t\t\"pt\": 72.0 / 96.0,\n\t\t\"px\": 1,\n\t\t\"deg\": 1,\n\t\t\"grad\": 1,\n\t\t\"rad\": 1,\n\t\t\"turn\": 1,\n\t},\n\t\"deg\": {\n\t\t\"in\": 1,\n\t\t\"cm\": 1,\n\t\t\"pc\": 1,\n\t\t\"mm\": 1,\n\t\t\"pt\": 1,\n\t\t\"px\": 1,\n\t\t\"deg\": 1,\n\t\t\"grad\": 40.0 / 36.0,\n\t\t\"rad\": math.Pi / 180.0,\n\t\t\"turn\": 1.0 / 360.0,\n\t},\n\t\"grad\": {\n\t\t\"in\": 1,\n\t\t\"cm\": 1,\n\t\t\"pc\": 1,\n\t\t\"mm\": 1,\n\t\t\"pt\": 1,\n\t\t\"px\": 1,\n\t\t\"deg\": 36.0 / 40.0,\n\t\t\"grad\": 1,\n\t\t\"rad\": math.Pi / 200.0,\n\t\t\"turn\": 1.0 / 400.0,\n\t},\n\t\"rad\": {\n\t\t\"in\": 1,\n\t\t\"cm\": 1,\n\t\t\"pc\": 1,\n\t\t\"mm\": 1,\n\t\t\"pt\": 1,\n\t\t\"px\": 1,\n\t\t\"deg\": 180.0 / math.Pi,\n\t\t\"grad\": 200.0 / math.Pi,\n\t\t\"rad\": 1,\n\t\t\"turn\": math.Pi / 2.0,\n\t},\n\t\"turn\": {\n\t\t\"in\": 1,\n\t\t\"cm\": 1,\n\t\t\"pc\": 1,\n\t\t\"mm\": 1,\n\t\t\"pt\": 1,\n\t\t\"px\": 1,\n\t\t\"deg\": 360.0,\n\t\t\"grad\": 400.0,\n\t\t\"rad\": 2.0 * math.Pi,\n\t\t\"turn\": 1,\n\t},\n}\n\nvar SassUnitConversions map[string]map[string]float64 = sassUnitConversions\n\nvar sassUnitTypes = map[string]string{\n\t\"in\": \"distance\",\n\t\"cm\": \"distance\",\n\t\"pc\": \"distance\",\n\t\"mm\": \"distance\",\n\t\"pt\": \"distance\",\n\t\"px\": \"distance\",\n\t\"deg\": \"angle\",\n\t\"grad\": \"angle\",\n\t\"rad\": \"angle\",\n\t\"turn\": \"angle\",\n}\n\n// Add sums the two numbers in the first numbers units\nfunc (sn SassNumber) Add(sn2 SassNumber) SassNumber {\n\tsn1Value, sn2Value := getConvertedUnits(sn, sn2)\n\treturn SassNumber{Value: sn1Value + sn2Value, Unit: sn.Unit}\n}\n\n// Subtract minuses the two numbers in the first numbers units\nfunc (sn SassNumber) Subtract(sn2 SassNumber) SassNumber {\n\tsn1Value, sn2Value := getConvertedUnits(sn, sn2)\n\treturn SassNumber{Value: sn1Value - sn2Value, Unit: sn.Unit}\n}\n\n// Multiply takes the multiplication of the two numbers\n// in the first numbers units\nfunc (sn SassNumber) Multiply(sn2 SassNumber) SassNumber {\n\tsn1Value, sn2Value := getConvertedUnits(sn, sn2)\n\treturn SassNumber{Value: sn1Value * sn2Value, Unit: sn.Unit}\n}\n\n// Divide takes the quotient of the two numbers in the first unit\nfunc (sn SassNumber) Divide(sn2 SassNumber) SassNumber {\n\tsn1Value, sn2Value := getConvertedUnits(sn, sn2)\n\treturn SassNumber{Value: sn1Value / sn2Value, Unit: sn.Unit}\n}\n\nfunc getConvertedUnits(sn1 SassNumber, sn2 SassNumber) (float64, float64) {\n\tvar sn2Value float64\n\tif sn2.Unit != sn1.Unit {\n\t\tsn2Value = convertUnits(sn2, sn1)\n\t} else {\n\t\tsn2Value = sn2.Value\n\t}\n\n\treturn sn1.Value, sn2Value\n}\n\nfunc convertUnits(from SassNumber, to SassNumber) float64 {\n\treturn sassUnitConversions[from.Unit][to.Unit] * from.Value\n}\n" }, { "path": "libs/sass_number_test.go", "content": "package libs\n\nimport (\n\t\"math\"\n\t\"testing\"\n)\n\nvar tolerance = float64(0.00001)\n\nfunc TestSassNumberAddDifferentUnits(t *testing.T) {\n\tvar sn1 = SassNumber{50, \"px\"}\n\tvar sn2 = SassNumber{15, \"cm\"}\n\n\tres := sn1.Add(sn2)\n\n\texpectedValue := 50 + ((96.0 / 2.54) * 15)\n\tif res.Unit != sn1.Unit {\n\t\tt.Errorf(\"SassNumber Add result Units are: %s, wanted %s\", res.Unit, sn1.Unit)\n\t} else if !compareFloats(res.Value, expectedValue) {\n\t\tt.Errorf(\"SassNumber Add result Value expected: %f, got %f\", expectedValue, res.Value)\n\t}\n}\n\nfunc TestSassNumberAddSameUnits(t *testing.T) {\n\tvar sn1 = SassNumber{80.0, \"mm\"}\n\tvar sn2 = SassNumber{25.0, \"mm\"}\n\n\tres := sn1.Add(sn2)\n\n\texpectedValue := 80.0 + 25.0\n\tif res.Unit != sn1.Unit {\n\t\tt.Errorf(\"SassNumber Add result Units are: %s, wanted %s\", res.Unit, sn1.Unit)\n\t} else if !compareFloats(res.Value, expectedValue) {\n\t\tt.Errorf(\"SassNumber Add result Value expected: %f, got %f\", expectedValue, res.Value)\n\t}\n}\n\nfunc TestSassNumberSubstractDifferentUnits(t *testing.T) {\n\tvar sn1 = SassNumber{60, \"grad\"}\n\tvar sn2 = SassNumber{25, \"deg\"}\n\n\tres := sn1.Subtract(sn2)\n\n\texpectedValue := 60 - ((40.0 / 36.0) * 25.0)\n\tif res.Unit != sn1.Unit {\n\t\tt.Errorf(\"SassNumber Subtract result Units are: %s, wanted %s\", res.Unit, sn1.Unit)\n\t} else if !compareFloats(res.Value, expectedValue) {\n\t\tt.Errorf(\"SassNumber Subtract result Value expected: %f, got %f\", expectedValue, res.Value)\n\t}\n}\n\nfunc TestSassNumberSubtractSameUnits(t *testing.T) {\n\tvar sn1 = SassNumber{80.0, \"mm\"}\n\tvar sn2 = SassNumber{25.0, \"mm\"}\n\n\tres := sn1.Subtract(sn2)\n\n\texpectedValue := 80.0 - 25.0\n\tif res.Unit != sn1.Unit {\n\t\tt.Errorf(\"SassNumber Subtract result Units are: %s, wanted %s\", res.Unit, sn1.Unit)\n\t} else if !compareFloats(res.Value, expectedValue) {\n\t\tt.Errorf(\"SassNumber Subtract result Value expected: %f, got %f\", expectedValue, res.Value)\n\t}\n}\n\nfunc TestSassNumberMultiplyDifferentUnits(t *testing.T) {\n\tvar sn1 = SassNumber{15, \"mm\"}\n\tvar sn2 = SassNumber{5, \"pt\"}\n\n\tres := sn1.Multiply(sn2)\n\n\texpectedValue := 15 * ((25.4 / 72.0) * 5)\n\tif res.Unit != sn1.Unit {\n\t\tt.Errorf(\"SassNumber Multiply result Units are: %s, wanted %s\", res.Unit, sn1.Unit)\n\t} else if !compareFloats(res.Value, expectedValue) {\n\t\tt.Errorf(\"SassNumber Multiply result Value expected: %f, got %f\", expectedValue, res.Value)\n\t}\n}\n\nfunc TestSassNumberMultiplySameUnits(t *testing.T) {\n\tvar sn1 = SassNumber{.4, \"rad\"}\n\tvar sn2 = SassNumber{.7, \"rad\"}\n\n\tres := sn1.Multiply(sn2)\n\n\texpectedValue := .4 * .7\n\tif res.Unit != sn1.Unit {\n\t\tt.Errorf(\"SassNumber add result Units are: %s, wanted %s\", res.Unit, sn1.Unit)\n\t} else if !compareFloats(res.Value, expectedValue) {\n\t\tt.Errorf(\"SassNumber Add result Value expected: %f, got %f\", expectedValue, res.Value)\n\t}\n}\n\nfunc TestSassNumberDivideDifferentUnits(t *testing.T) {\n\tvar sn1 = SassNumber{5, \"in\"}\n\tvar sn2 = SassNumber{15, \"px\"}\n\n\tres := sn1.Divide(sn2)\n\n\texpectedValue := 5 / ((1.0 / 96.0) * 15)\n\tif res.Unit != sn1.Unit {\n\t\tt.Errorf(\"SassNumber Divide result Units are: %s, wanted %s\", res.Unit, sn1.Unit)\n\t} else if !compareFloats(res.Value, expectedValue) {\n\t\tt.Errorf(\"SassNumber Divide result Value expected: %f, got %f\", expectedValue, res.Value)\n\t}\n}\n\nfunc TestSassNumberDivideSameUnits(t *testing.T) {\n\tvar sn1 = SassNumber{80.0, \"cm\"}\n\tvar sn2 = SassNumber{25.0, \"cm\"}\n\n\tres := sn1.Divide(sn2)\n\n\texpectedValue := 80.0 / 25.0\n\tif res.Unit != sn1.Unit {\n\t\tt.Errorf(\"SassNumber Divide result Units are: %s, wanted %s\", res.Unit, sn1.Unit)\n\t} else if !compareFloats(res.Value, expectedValue) {\n\t\tt.Errorf(\"SassNumber Divide result Value expected: %f, got %f\", expectedValue, res.Value)\n\t}\n}\n\n/*\nfunc TestUnknownUnit(t *testing.T) {\n\tvar sn1 = SassNumber{80.0, \"mm\"}\n\tvar sn2 = SassNumber{25.0, \"TalorSwift\"}\n\n\t_, err := sn1.Divide(sn2)\n\n\tif err == nil {\n\t\tt.Errorf(\"Wanted: %s but did not get an error\", fmt.Sprintf(\"Can not convert from %s to %s\", sn2.Unit, sn1.Unit))\n\t} else if err.Error() != fmt.Sprintf(\"Can not convert from %s to %s\", sn2.Unit, sn1.Unit) {\n\t\tt.Errorf(\"Wanted: %s got: %s\", fmt.Sprintf(\"Can not convert from %s to %s\", sn2.Unit, sn1.Unit), err.Error())\n\t}\n}\n\nfunc TestDistanceToAngleConversion(t *testing.T) {\n\tvar sn1 = SassNumber{80.0, \"mm\"}\n\tvar sn2 = SassNumber{25.0, \"rad\"}\n\n\t_, err := sn1.Divide(sn2)\n\n\tif err == nil {\n\t\tt.Errorf(\"Wanted: %s but did not get an error\", fmt.Sprintf(\"Can not convert sass Units between angles and distances: %s, %s\", sn2.Unit, sn1.Unit))\n\t} else if err.Error() != fmt.Sprintf(\"Can not convert sass Units between angles and distances: %s, %s\", sn2.Unit, sn1.Unit) {\n\t\tt.Errorf(\"Wanted: %s got: %s\", fmt.Sprintf(\"Can not convert sass Units between angles and distances: %s, %s\", sn2.Unit, sn1.Unit), err.Error())\n\t}\n}\n*/\n\nfunc TestChainedOperation(t *testing.T) {\n\tvar sn1 = SassNumber{5, \"in\"}\n\tvar sn2 = SassNumber{15, \"px\"}\n\tvar sn3 = SassNumber{55, \"px\"}\n\tvar sn4 = SassNumber{75, \"mm\"}\n\tvar sn5 = SassNumber{25, \"pt\"}\n\n\tres := sn1.Add(sn2).Subtract(sn3).Multiply(sn4).Divide(sn5)\n\n\texpectedValue := (((5.0 + ((1.0 / 96.0) * 15)) - ((1.0 / 96.0) * 55)) * ((1.0 / 25.4) * 75)) / ((1.0 / 72.0) * 25)\n\n\tif res.Unit != sn1.Unit {\n\t\tt.Errorf(\"SassNumber Divide result Units are: %s, wanted %s\", res.Unit, sn1.Unit)\n\t} else if !compareFloats(res.Value, expectedValue) {\n\t\tt.Errorf(\"SassNumber chained operation result Value expected: %f, got %f\", expectedValue, res.Value)\n\t}\n}\n\nfunc compareFloats(f1 float64, f2 float64) bool {\n\tif math.Abs(f1-f2) < tolerance {\n\t\treturn true\n\t}\n\treturn false\n}\n" }, { "path": "libs/sass_util.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/sass_util.hpp\"\n#endif\n" }, { "path": "libs/source_map.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/source_map.hpp\"\n#endif\n" }, { "path": "libs/subset_map.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/subset_map.hpp\"\n#endif\n" }, { "path": "libs/to_c.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/to_c.hpp\"\n#endif\n" }, { "path": "libs/to_string.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/to_string.hpp\"\n#endif\n" }, { "path": "libs/to_value.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/to_value.hpp\"\n#endif\n" }, { "path": "libs/toscss.go", "content": "package libs\n\n// #include \n// #include \"sass2scss.h\"\nimport \"C\"\nimport (\n\t\"io\"\n\t\"io/ioutil\"\n\t\"unsafe\"\n)\n\n// ToScss converts Sass to Scss using sass2scss. Readers and Writers are\n// used, but libsass does not support streaming.\nfunc ToScss(r io.Reader, w io.Writer) error {\n\tbs, _ := ioutil.ReadAll(r)\n\tin := C.CString(string(bs))\n\tdefer C.free(unsafe.Pointer(in))\n\n\tchars := C.sass2scss(\n\t\t// FIXME: readers would be much more efficient\n\t\tin,\n\t\t// SASS2SCSS_PRETTIFY_1 Egyptian brackets\n\t\tC.int(1),\n\t)\n\t_, err := io.WriteString(w, C.GoString(chars))\n\treturn err\n}\n" }, { "path": "libs/units.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/units.hpp\"\n#endif\n" }, { "path": "libs/unity.cpp", "content": "#ifndef USE_LIBSASS\n\n\n#include \"../libsass-build/ast.cpp\"\n#include \"../libsass-build/ast_fwd_decl.cpp\"\n#include \"../libsass-build/backtrace.cpp\"\n#include \"../libsass-build/base64vlq.cpp\"\n#include \"../libsass-build/bind.cpp\"\n#include \"../libsass-build/check_nesting.cpp\"\n#include \"../libsass-build/color_maps.cpp\"\n#include \"../libsass-build/constants.cpp\"\n#include \"../libsass-build/context.cpp\"\n#include \"../libsass-build/cssize.cpp\"\n#include \"../libsass-build/emitter.cpp\"\n#include \"../libsass-build/environment.cpp\"\n#include \"../libsass-build/error_handling.cpp\"\n#include \"../libsass-build/eval.cpp\"\n#include \"../libsass-build/expand.cpp\"\n#include \"../libsass-build/extend.cpp\"\n#include \"../libsass-build/file.cpp\"\n#include \"../libsass-build/functions.cpp\"\n#include \"../libsass-build/inspect.cpp\"\n#include \"../libsass-build/json.cpp\"\n#include \"../libsass-build/lexer.cpp\"\n#include \"../libsass-build/listize.cpp\"\n#include \"../libsass-build/node.cpp\"\n#include \"../libsass-build/operators.cpp\"\n#include \"../libsass-build/output.cpp\"\n#include \"../libsass-build/parser.cpp\"\n#include \"../libsass-build/plugins.cpp\"\n#include \"../libsass-build/position.cpp\"\n#include \"../libsass-build/prelexer.cpp\"\n#include \"../libsass-build/remove_placeholders.cpp\"\n#include \"../libsass-build/sass2scss.cpp\"\n#include \"../libsass-build/sass_context.cpp\"\n#include \"../libsass-build/sass.cpp\"\n#include \"../libsass-build/sass_functions.cpp\"\n#include \"../libsass-build/sass_util.cpp\"\n#include \"../libsass-build/sass_values.cpp\"\n#include \"../libsass-build/source_map.cpp\"\n#include \"../libsass-build/subset_map.cpp\"\n#include \"../libsass-build/to_c.cpp\"\n#include \"../libsass-build/to_value.cpp\"\n#include \"../libsass-build/units.cpp\"\n#include \"../libsass-build/utf8_string.cpp\"\n#include \"../libsass-build/util.cpp\"\n#include \"../libsass-build/values.cpp\"\n#include \"../libsass-build/memory/SharedPtr.cpp\"\n#endif\n" }, { "path": "libs/utf8.h", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/utf8.h\"\n#endif\n" }, { "path": "libs/utf8_string.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/utf8_string.hpp\"\n#endif\n" }, { "path": "libs/util.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/util.hpp\"\n#endif\n" }, { "path": "libs/values.hpp", "content": "#ifndef USE_LIBSASS\n#include \"../libsass-build/values.hpp\"\n#endif\n" }, { "path": "libs/wrap.go", "content": "package libs\n\n// #include \"stdint.h\"\n//\n// extern struct Sass_Import** HeaderBridge(uintptr_t idx);\n//\n// #//for C.free\n// #include \"stdlib.h\"\n//\n// #include \"sass/context.h\"\n//\nimport \"C\"\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"reflect\"\n\t\"strings\"\n\t\"unsafe\"\n)\n\ntype SassImporter *C.struct_Sass_Importer\ntype SassImporterList C.Sass_Importer_List\n\n// SassMakeImporterList maps to C.sass_make_importer_list\nfunc SassMakeImporterList(gol int) SassImporterList {\n\tl := C.size_t(gol)\n\tcimp := C.sass_make_importer_list(l)\n\treturn (SassImporterList)(cimp)\n}\n\ntype ImportEntry struct {\n\tParent string\n\tPath string\n\tSource string\n\tSrcMap string\n}\n\n//export HeaderBridge\nfunc HeaderBridge(cint C.uintptr_t) C.Sass_Import_List {\n\tidx := int(cint)\n\tentries, ok := globalHeaders.Get(idx).([]ImportEntry)\n\tif !ok {\n\t\tfmt.Printf(\"failed to resolve header slice: %d\\n\", idx)\n\t\treturn C.sass_make_import_list(C.size_t(1))\n\t}\n\n\tcents := C.sass_make_import_list(C.size_t(len(entries)))\n\n\thdr := reflect.SliceHeader{\n\t\tData: uintptr(unsafe.Pointer(cents)),\n\t\tLen: len(entries), Cap: len(entries),\n\t}\n\tgoents := *(*[]C.Sass_Import_Entry)(unsafe.Pointer(&hdr))\n\n\tfor i, ent := range entries {\n\t\t// Each entry needs a unique name\n\t\tcent := C.sass_make_import_entry(\n\t\t\tC.CString(ent.Path),\n\t\t\tC.CString(ent.Source),\n\t\t\tC.CString(ent.SrcMap))\n\t\t// There is a function for modifying an import list, but a proper\n\t\t// slice might be more useful.\n\t\t// C.sass_import_set_list_entry(cents, C.size_t(i), cent)\n\t\tgoents[i] = cent\n\t}\n\n\treturn cents\n}\n\nfunc GetEntry(es []ImportEntry, parent string, path string) (string, error) {\n\tfor _, e := range es {\n\t\tif parent == e.Parent && path == e.Path {\n\t\t\treturn e.Source, nil\n\t\t}\n\t}\n\treturn \"\", errors.New(\"entry not found\")\n}\n\n// ImporterBridge is called by C to pass Importer arguments into Go land. A\n// Sass_Import is returned for libsass to resolve.\n//\n//export ImporterBridge\nfunc ImporterBridge(url *C.char, prev *C.char, cidx C.uintptr_t) C.Sass_Import_List {\n\tvar importResolver ImportResolver\n\n\t// Retrieve the index\n\tidx := int(cidx)\n\timportResolver, ok := globalImports.Get(idx).(ImportResolver)\n\n\tif !ok {\n\t\tfmt.Printf(\"failed to resolve import handler: %d\\n\", idx)\n\t}\n\n\tparent := C.GoString(prev)\n\trel := C.GoString(url)\n\tlist := C.sass_make_import_list(1)\n\thdr := reflect.SliceHeader{\n\t\tData: uintptr(unsafe.Pointer(list)),\n\t\tLen: 1, Cap: 1,\n\t}\n\n\tgolist := *(*[]C.Sass_Import_Entry)(unsafe.Pointer(&hdr))\n\n\tif importResolver != nil {\n\t\tnewURL, body, resolved := importResolver(rel, parent)\n\t\tif resolved {\n\t\t\t// Passing a nil as body is a signal to load the import from the URL.\n\t\t\tvar bodyv *C.char\n\t\t\tif body != \"\" {\n\t\t\t\tbodyv = C.CString(body)\n\t\t\t}\n\t\t\tent := C.sass_make_import_entry(C.CString(newURL), bodyv, nil)\n\t\t\tcent := (C.Sass_Import_Entry)(ent)\n\t\t\tgolist[0] = cent\n\n\t\t\treturn list\n\t\t}\n\t}\n\n\tif strings.HasPrefix(rel, \"compass\") {\n\t\tent := C.sass_make_import_entry(url, C.CString(\"\"), nil)\n\t\tcent := (C.Sass_Import_Entry)(ent)\n\t\tgolist[0] = cent\n\t} else {\n\t\tent := C.sass_make_import_entry(url, nil, nil)\n\t\tcent := (C.Sass_Import_Entry)(ent)\n\t\tgolist[0] = cent\n\t}\n\n\treturn list\n}\n\ntype SassImportList C.Sass_Import_List\n\ntype SassFileContext *C.struct_Sass_File_Context\n\n// SassMakeFileContext maps to C.sass_make_file_context\nfunc SassMakeFileContext(gos string) SassFileContext {\n\ts := C.CString(gos)\n\tfctx := C.sass_make_file_context(s)\n\treturn (SassFileContext)(fctx)\n}\n\n// SassDeleteFileContext frees memory used for a file context\nfunc SassDeleteFileContext(fc SassFileContext) {\n\tC.sass_delete_file_context(fc)\n}\n\ntype SassDataContext *C.struct_Sass_Data_Context\n\n// SassMakeDataContext creates a data context from a source string\nfunc SassMakeDataContext(gos string) SassDataContext {\n\ts := C.CString(gos)\n\tdctx := C.sass_make_data_context(s)\n\treturn (SassDataContext)(dctx)\n}\n\n// SassDeleteDataContext frees the memory used for a data context\nfunc SassDeleteDataContext(dc SassDataContext) {\n\tC.sass_delete_data_context(dc)\n}\n\ntype SassContext *C.struct_Sass_Context\n\n// SassDataContextGetContext returns a context from a data context.\n// These are useful for calling generic methods like compiling.\nfunc SassDataContextGetContext(godc SassDataContext) SassContext {\n\topts := C.sass_data_context_get_context(godc)\n\treturn (SassContext)(opts)\n}\n\n// SassFileContextGetContext returns a context from a file context.\n// These are useful for calling generic methods like compiling.\nfunc SassFileContextGetContext(gofc SassFileContext) SassContext {\n\topts := C.sass_file_context_get_context(gofc)\n\treturn (SassContext)(opts)\n}\n\n// SassOptions is a wrapper to C.struct_Sass_Options\ntype SassOptions *C.struct_Sass_Options\n\n// SassMakeOptions creates a new SassOptions object\nfunc SassMakeOptions() SassOptions {\n\topts := C.sass_make_options()\n\treturn (SassOptions)(opts)\n}\n\n// SassFileContextGetOptions returns the sass options in a file context\nfunc SassFileContextGetOptions(gofc SassFileContext) SassOptions {\n\tfcopts := C.sass_file_context_get_options(gofc)\n\treturn (SassOptions)(fcopts)\n}\n\n// SassFileContextGetOptions sets a sass options to a file context\nfunc SassFileContextSetOptions(gofc SassFileContext, goopts SassOptions) {\n\tC.sass_file_context_set_options(gofc, goopts)\n}\n\n// SassDataContextGetOptions returns the Sass options in a data context\nfunc SassDataContextGetOptions(godc SassDataContext) SassOptions {\n\tdcopts := C.sass_data_context_get_options(godc)\n\treturn (SassOptions)(dcopts)\n}\n\n// SassDataContextGetOptions sets a Sass options to a data context\nfunc SassDataContextSetOptions(godc SassDataContext, goopts SassOptions) {\n\tC.sass_data_context_set_options(godc, goopts)\n}\n\ntype SassCompiler *C.struct_Sass_Compiler\n\n// SassMakeFileCompiler returns a compiler from a file context\nfunc SassMakeFileCompiler(gofc SassFileContext) SassCompiler {\n\tsc := C.sass_make_file_compiler(gofc)\n\treturn (SassCompiler)(sc)\n}\n\n// SassMakeDataCompiler returns a compiler from a data context\nfunc SassMakeDataCompiler(godc SassDataContext) SassCompiler {\n\tdc := C.sass_make_data_compiler(godc)\n\treturn (SassCompiler)(dc)\n}\n\n// SassCompileFileContext compile from file context\nfunc SassCompileFileContext(gofc SassFileContext) int {\n\tcstatus := C.sass_compile_file_context(gofc)\n\treturn int(cstatus)\n}\n\n// SassCompilerParse prepares a compiler for execution\nfunc SassCompilerParse(c SassCompiler) {\n\tC.sass_compiler_parse(c)\n}\n\n// SassCompilerExecute compiles a compiler\nfunc SassCompilerExecute(c SassCompiler) {\n\tC.sass_compiler_execute(c)\n}\n\n// SassDeleteCompiler frees memory for the Sass compiler\nfunc SassDeleteCompiler(c SassCompiler) {\n\tC.sass_delete_compiler(c)\n}\n\n// SassOptionSetCHeaders adds custom C headers to a SassOptions\nfunc SassOptionSetCHeaders(gofc SassOptions, goimp SassImporterList) {\n\tC.sass_option_set_c_headers(gofc, C.Sass_Importer_List(goimp))\n}\n\n// SassContextGetOutputString retrieves the final compiled CSS after\n// compiler parses and executes.\nfunc SassContextGetOutputString(goctx SassContext) string {\n\tcstr := C.sass_context_get_output_string(goctx)\n\tdefer C.free(unsafe.Pointer(cstr))\n\treturn C.GoString(cstr)\n}\n\n// SassContextGetErrorJSON requests an error in JSON format from libsass\nfunc SassContextGetErrorJSON(goctx SassContext) string {\n\tcstr := C.sass_context_get_error_json(goctx)\n\tdefer C.free(unsafe.Pointer(cstr))\n\treturn C.GoString(cstr)\n}\n\n// SassContextGetErrorStatus requests error status\nfunc SassContextGetErrorStatus(goctx SassContext) int {\n\treturn int(C.sass_context_get_error_status(goctx))\n}\n\n// SassOptionGetSourceMapFile retrieves the source map file\nfunc SassOptionGetSourceMapFile(goopts SassOptions) string {\n\tp := C.sass_option_get_source_map_file(goopts)\n\treturn C.GoString(p)\n}\n\n// SassContextGetSourceMapString retrieves the contents of a\n// source map\nfunc SassContextGetSourceMapString(goctx SassContext) string {\n\ts := C.sass_context_get_source_map_string(goctx)\n\treturn C.GoString(s)\n}\n\n// SassOptionSetPrecision sets the precision of floating point math\n// ie. 3.2222px. This is currently bugged and does not work.\nfunc SassOptionSetPrecision(goopts SassOptions, i int) {\n\tC.sass_option_set_precision(goopts, C.int(i))\n}\n\n// SassOptionSetOutputStyle sets the output format of CSS see: http://godoc.org/github.com/wellington/go-libsass#pkg-constants\nfunc SassOptionSetOutputStyle(goopts SassOptions, i int) {\n\tC.sass_option_set_output_style(goopts, uint32(i))\n}\n\n// SassOptionSetSourceComments toggles the output of line comments in CSS\nfunc SassOptionSetSourceComments(goopts SassOptions, b bool) {\n\tC.sass_option_set_source_comments(goopts, C.bool(b))\n}\n\n// SassOptionSetOutputPath is used for output path.\n// Output path is used for source map generating. LibSass will\n// not write to this file, it is just used to create\n// information in source-maps etc.\nfunc SassOptionSetOutputPath(goopts SassOptions, path string) {\n\tC.sass_option_set_output_path(goopts, C.CString(path))\n}\n\n// SassOptionSetInputPath is used for input path.\n// The input path is used for source map generating. It can be used to define\n// something with string compilation or to overload the input file path. It is\n// set to \"stdin\" for data contexts and to the input file on file contexts.\nfunc SassOptionSetInputPath(goopts SassOptions, path string) {\n\tC.sass_option_set_input_path(goopts, C.CString(path))\n}\n\n// SassOptionSetIncludePaths adds additional paths to look for input Sass\nfunc SassOptionSetIncludePath(goopts SassOptions, path string) {\n\tC.sass_option_set_include_path(goopts, C.CString(path))\n}\n\nfunc SassOptionSetSourceMapEmbed(goopts SassOptions, b bool) {\n\tC.sass_option_set_source_map_embed(goopts, C.bool(b))\n}\n\nfunc SassOptionSetSourceMapContents(goopts SassOptions, b bool) {\n\tC.sass_option_set_source_map_contents(goopts, C.bool(b))\n}\n\nfunc SassOptionSetSourceMapFile(goopts SassOptions, path string) {\n\tC.sass_option_set_source_map_file(goopts, C.CString(path))\n}\n\n// SassOptionSetSourceMapRoot sets the sourceRoot in the resulting\n// source map. sourceRoot is prepended to the sources referenced\n// in the map. More Info: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.75yo6yoyk7x5\nfunc SassOptionSetSourceMapRoot(goopts SassOptions, path string) {\n\tC.sass_option_set_source_map_root(goopts, C.CString(path))\n}\n\nfunc SassOptionSetOmitSourceMapURL(goopts SassOptions, b bool) {\n\tC.sass_option_set_omit_source_map_url(goopts, C.bool(b))\n}\n\ntype SassImportEntry C.Sass_Import_Entry\n\n// SassMakeImport creates an import for overriding behavior when\n// certain imports are called.\nfunc SassMakeImport(path string, base string, source string, srcmap string) SassImportEntry {\n\timpent := C.sass_make_import(C.CString(path), C.CString(base),\n\t\tC.CString(source), C.CString(srcmap))\n\treturn (SassImportEntry)(impent)\n}\n\ntype SassImporterFN C.Sass_Importer_Fn\n\nfunc SassImporterGetFunction(goimp SassImporter) SassImporterFN {\n\timpfn := C.sass_importer_get_function(C.Sass_Importer_Entry(goimp))\n\treturn (SassImporterFN)(impfn)\n}\n\nfunc SassImporterGetListEntry() {}\n\n// SassMakeImport attaches a Go pointer to a Sass function. Go will\n// eventually kill this behavior and we should find a new way to do this.\nfunc SassMakeImporter(fn SassImporterFN, priority int, v interface{}) (SassImporter, error) {\n\tvv := reflect.ValueOf(v).Elem()\n\tif !vv.CanAddr() {\n\t\treturn nil, errors.New(\"can not take address of\")\n\t}\n\t// TODO: this will leak memory, the interface must be freed manually\n\tlst := C.sass_make_importer(C.Sass_Importer_Fn(fn), C.double(priority), unsafe.Pointer(vv.Addr().Pointer()))\n\treturn (SassImporter)(lst), nil\n}\n\n// SassImporterSetListEntry updates an import list with a new entry. The\n// index must exist in the importer list.\nfunc SassImporterSetListEntry(golst SassImporterList, idx int, ent SassImporter) {\n\tC.sass_importer_set_list_entry(C.Sass_Importer_List(golst), C.size_t(idx), C.Sass_Importer_Entry(ent))\n}\n\nfunc SassOptionSetCImporters(goopts SassOptions, golst SassImporterList) {\n\tC.sass_option_set_c_importers(goopts, C.Sass_Importer_List(golst))\n}\n\nfunc SassOptionSetCFunctions() {\n\n}\n" }, { "path": "libs/wrap_dev.go", "content": "// +build dev\n\npackage libs\n\n// #cgo CPPFLAGS: -DUSE_LIBSASS\n// #cgo CPPFLAGS: -I../libsass-build -I../libsass-build/include\n// #cgo LDFLAGS: -lsass\n// #cgo darwin linux LDFLAGS: -ldl\n//\nimport \"C\"\n" }, { "path": "libs/wrap_main.go", "content": "// +build !dev\n\npackage libs\n\n// #cgo CFLAGS: -O2 -fPIC\n// #cgo CPPFLAGS: -I../libsass-build -I../libsass-build/include\n// #cgo CXXFLAGS: -g -std=c++0x -O2 -fPIC\n// #cgo LDFLAGS: -lstdc++ -lm\n// #cgo darwin linux LDFLAGS: -ldl\n//\nimport \"C\"\n" }, { "path": "libsass-build/ast.cpp", "content": "#include \"sass.hpp\"\n#include \"ast.hpp\"\n#include \"context.hpp\"\n#include \"node.hpp\"\n#include \"eval.hpp\"\n#include \"extend.hpp\"\n#include \"emitter.hpp\"\n#include \"color_maps.hpp\"\n#include \"ast_fwd_decl.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace Sass {\n\n static Null sass_null(ParserState(\"null\"));\n\n bool Wrapped_Selector::find ( bool (*f)(AST_Node_Obj) )\n {\n // check children first\n if (selector_) {\n if (selector_->find(f)) return true;\n }\n // execute last\n return f(this);\n }\n\n bool Selector_List::find ( bool (*f)(AST_Node_Obj) )\n {\n // check children first\n for (Complex_Selector_Obj sel : elements()) {\n if (sel->find(f)) return true;\n }\n // execute last\n return f(this);\n }\n\n bool Compound_Selector::find ( bool (*f)(AST_Node_Obj) )\n {\n // check children first\n for (Simple_Selector_Obj sel : elements()) {\n if (sel->find(f)) return true;\n }\n // execute last\n return f(this);\n }\n\n bool Complex_Selector::find ( bool (*f)(AST_Node_Obj) )\n {\n // check children first\n if (head_ && head_->find(f)) return true;\n if (tail_ && tail_->find(f)) return true;\n // execute last\n return f(this);\n }\n\n bool Supports_Operator::needs_parens(Supports_Condition_Obj cond) const {\n if (Supports_Operator_Obj op = Cast(cond)) {\n return op->operand() != operand();\n }\n return Cast(cond) != NULL;\n }\n\n bool Supports_Negation::needs_parens(Supports_Condition_Obj cond) const {\n return Cast(cond) ||\n Cast(cond);\n }\n\n void str_rtrim(std::string& str, const std::string& delimiters = \" \\f\\n\\r\\t\\v\")\n {\n str.erase( str.find_last_not_of( delimiters ) + 1 );\n }\n\n void String_Constant::rtrim()\n {\n str_rtrim(value_);\n }\n\n void String_Schema::rtrim()\n {\n if (!empty()) {\n if (String_Ptr str = Cast(last())) str->rtrim();\n }\n }\n\n void Argument::set_delayed(bool delayed)\n {\n if (value_) value_->set_delayed(delayed);\n is_delayed(delayed);\n }\n\n void Arguments::set_delayed(bool delayed)\n {\n for (Argument_Obj arg : elements()) {\n if (arg) arg->set_delayed(delayed);\n }\n is_delayed(delayed);\n }\n\n\n bool At_Root_Query::exclude(std::string str)\n {\n bool with = feature() && unquote(feature()->to_string()).compare(\"with\") == 0;\n List_Ptr l = static_cast(value().ptr());\n std::string v;\n\n if (with)\n {\n if (!l || l->length() == 0) return str.compare(\"rule\") != 0;\n for (size_t i = 0, L = l->length(); i < L; ++i)\n {\n v = unquote((*l)[i]->to_string());\n if (v.compare(\"all\") == 0 || v == str) return false;\n }\n return true;\n }\n else\n {\n if (!l || !l->length()) return str.compare(\"rule\") == 0;\n for (size_t i = 0, L = l->length(); i < L; ++i)\n {\n v = unquote((*l)[i]->to_string());\n if (v.compare(\"all\") == 0 || v == str) return true;\n }\n return false;\n }\n }\n\n void AST_Node::update_pstate(const ParserState& pstate)\n {\n pstate_.offset += pstate - pstate_ + pstate.offset;\n }\n\n bool Simple_Selector::is_ns_eq(const Simple_Selector& r) const\n {\n // https://github.com/sass/sass/issues/2229\n if ((has_ns_ == r.has_ns_) ||\n (has_ns_ && ns_.empty()) ||\n (r.has_ns_ && r.ns_.empty())\n ) {\n if (ns_.empty() && r.ns() == \"*\") return false;\n else if (r.ns().empty() && ns() == \"*\") return false;\n else return ns() == r.ns();\n }\n return false;\n }\n\n bool Compound_Selector::operator< (const Compound_Selector& rhs) const\n {\n size_t L = std::min(length(), rhs.length());\n for (size_t i = 0; i < L; ++i)\n {\n Simple_Selector_Obj l = (*this)[i];\n Simple_Selector_Obj r = rhs[i];\n if (!l && !r) return false;\n else if (!r) return false;\n else if (!l) return true;\n else if (*l != *r)\n { return *l < *r; }\n }\n // just compare the length now\n return length() < rhs.length();\n }\n\n bool Compound_Selector::has_parent_ref() const\n {\n for (Simple_Selector_Obj s : *this) {\n if (s && s->has_parent_ref()) return true;\n }\n return false;\n }\n\n bool Compound_Selector::has_real_parent_ref() const\n {\n for (Simple_Selector_Obj s : *this) {\n if (s && s->has_real_parent_ref()) return true;\n }\n return false;\n }\n\n bool Complex_Selector::has_parent_ref() const\n {\n return (head() && head()->has_parent_ref()) ||\n (tail() && tail()->has_parent_ref());\n }\n\n bool Complex_Selector::has_real_parent_ref() const\n {\n return (head() && head()->has_real_parent_ref()) ||\n (tail() && tail()->has_real_parent_ref());\n }\n\n bool Complex_Selector::operator< (const Complex_Selector& rhs) const\n {\n // const iterators for tails\n Complex_Selector_Ptr_Const l = this;\n Complex_Selector_Ptr_Const r = &rhs;\n Compound_Selector_Ptr l_h = NULL;\n Compound_Selector_Ptr r_h = NULL;\n if (l) l_h = l->head();\n if (r) r_h = r->head();\n // process all tails\n while (true)\n {\n #ifdef DEBUG\n // skip empty ancestor first\n if (l && l->is_empty_ancestor())\n {\n l_h = NULL;\n l = l->tail();\n if(l) l_h = l->head();\n continue;\n }\n // skip empty ancestor first\n if (r && r->is_empty_ancestor())\n {\n r_h = NULL;\n r = r->tail();\n if (r) r_h = r->head();\n continue;\n }\n #endif\n // check for valid selectors\n if (!l) return !!r;\n if (!r) return false;\n // both are null\n else if (!l_h && !r_h)\n {\n // check combinator after heads\n if (l->combinator() != r->combinator())\n { return l->combinator() < r->combinator(); }\n // advance to next tails\n l = l->tail();\n r = r->tail();\n // fetch the next headers\n l_h = NULL; r_h = NULL;\n if (l) l_h = l->head();\n if (r) r_h = r->head();\n }\n // one side is null\n else if (!r_h) return true;\n else if (!l_h) return false;\n // heads ok and equal\n else if (*l_h == *r_h)\n {\n // check combinator after heads\n if (l->combinator() != r->combinator())\n { return l->combinator() < r->combinator(); }\n // advance to next tails\n l = l->tail();\n r = r->tail();\n // fetch the next headers\n l_h = NULL; r_h = NULL;\n if (l) l_h = l->head();\n if (r) r_h = r->head();\n }\n // heads are not equal\n else return *l_h < *r_h;\n }\n }\n\n bool Complex_Selector::operator== (const Complex_Selector& rhs) const\n {\n // const iterators for tails\n Complex_Selector_Ptr_Const l = this;\n Complex_Selector_Ptr_Const r = &rhs;\n Compound_Selector_Ptr l_h = NULL;\n Compound_Selector_Ptr r_h = NULL;\n if (l) l_h = l->head();\n if (r) r_h = r->head();\n // process all tails\n while (true)\n {\n #ifdef DEBUG\n // skip empty ancestor first\n if (l && l->is_empty_ancestor())\n {\n l_h = NULL;\n l = l->tail();\n if (l) l_h = l->head();\n continue;\n }\n // skip empty ancestor first\n if (r && r->is_empty_ancestor())\n {\n r_h = NULL;\n r = r->tail();\n if (r) r_h = r->head();\n continue;\n }\n #endif\n // check the pointers\n if (!r) return !l;\n if (!l) return !r;\n // both are null\n if (!l_h && !r_h)\n {\n // check combinator after heads\n if (l->combinator() != r->combinator())\n { return l->combinator() < r->combinator(); }\n // advance to next tails\n l = l->tail();\n r = r->tail();\n // fetch the next heads\n l_h = NULL; r_h = NULL;\n if (l) l_h = l->head();\n if (r) r_h = r->head();\n }\n // equals if other head is empty\n else if ((!l_h && !r_h) ||\n (!l_h && r_h->empty()) ||\n (!r_h && l_h->empty()) ||\n (l_h && r_h && *l_h == *r_h))\n {\n // check combinator after heads\n if (l->combinator() != r->combinator())\n { return l->combinator() == r->combinator(); }\n // advance to next tails\n l = l->tail();\n r = r->tail();\n // fetch the next heads\n l_h = NULL; r_h = NULL;\n if (l) l_h = l->head();\n if (r) r_h = r->head();\n }\n // abort\n else break;\n }\n // unreachable\n return false;\n }\n\n Compound_Selector_Ptr Compound_Selector::unify_with(Compound_Selector_Ptr rhs)\n {\n if (empty()) return rhs;\n Compound_Selector_Obj unified = SASS_MEMORY_COPY(rhs);\n for (size_t i = 0, L = length(); i < L; ++i)\n {\n if (unified.isNull()) break;\n unified = at(i)->unify_with(unified);\n }\n return unified.detach();\n }\n\n bool Complex_Selector::operator== (const Selector& rhs) const\n {\n if (const Selector_List* sl = Cast(&rhs)) return *this == *sl;\n if (const Simple_Selector* sp = Cast(&rhs)) return *this == *sp;\n if (const Complex_Selector* cs = Cast(&rhs)) return *this == *cs;\n if (const Compound_Selector* ch = Cast(&rhs)) return *this == *ch;\n throw std::runtime_error(\"invalid selector base classes to compare\");\n }\n\n\n bool Complex_Selector::operator< (const Selector& rhs) const\n {\n if (const Selector_List* sl = Cast(&rhs)) return *this < *sl;\n if (const Simple_Selector* sp = Cast(&rhs)) return *this < *sp;\n if (const Complex_Selector* cs = Cast(&rhs)) return *this < *cs;\n if (const Compound_Selector* ch = Cast(&rhs)) return *this < *ch;\n throw std::runtime_error(\"invalid selector base classes to compare\");\n }\n\n bool Compound_Selector::operator== (const Selector& rhs) const\n {\n if (const Selector_List* sl = Cast(&rhs)) return *this == *sl;\n if (const Simple_Selector* sp = Cast(&rhs)) return *this == *sp;\n if (const Complex_Selector* cs = Cast(&rhs)) return *this == *cs;\n if (const Compound_Selector* ch = Cast(&rhs)) return *this == *ch;\n throw std::runtime_error(\"invalid selector base classes to compare\");\n }\n\n bool Compound_Selector::operator< (const Selector& rhs) const\n {\n if (const Selector_List* sl = Cast(&rhs)) return *this < *sl;\n if (const Simple_Selector* sp = Cast(&rhs)) return *this < *sp;\n if (const Complex_Selector* cs = Cast(&rhs)) return *this < *cs;\n if (const Compound_Selector* ch = Cast(&rhs)) return *this < *ch;\n throw std::runtime_error(\"invalid selector base classes to compare\");\n }\n\n bool Selector_Schema::operator== (const Selector& rhs) const\n {\n if (const Selector_List* sl = Cast(&rhs)) return *this == *sl;\n if (const Simple_Selector* sp = Cast(&rhs)) return *this == *sp;\n if (const Complex_Selector* cs = Cast(&rhs)) return *this == *cs;\n if (const Compound_Selector* ch = Cast(&rhs)) return *this == *ch;\n throw std::runtime_error(\"invalid selector base classes to compare\");\n }\n\n bool Selector_Schema::operator< (const Selector& rhs) const\n {\n if (const Selector_List* sl = Cast(&rhs)) return *this < *sl;\n if (const Simple_Selector* sp = Cast(&rhs)) return *this < *sp;\n if (const Complex_Selector* cs = Cast(&rhs)) return *this < *cs;\n if (const Compound_Selector* ch = Cast(&rhs)) return *this < *ch;\n throw std::runtime_error(\"invalid selector base classes to compare\");\n }\n\n bool Simple_Selector::operator== (const Selector& rhs) const\n {\n if (Simple_Selector_Ptr_Const sp = Cast(&rhs)) return *this == *sp;\n return false;\n }\n\n bool Simple_Selector::operator< (const Selector& rhs) const\n {\n if (Simple_Selector_Ptr_Const sp = Cast(&rhs)) return *this < *sp;\n return false;\n }\n\n bool Simple_Selector::operator== (const Simple_Selector& rhs) const\n {\n // solve the double dispatch problem by using RTTI information via dynamic cast\n if (const Pseudo_Selector* lhs = Cast(this)) {return *lhs == rhs; }\n else if (const Wrapped_Selector* lhs = Cast(this)) {return *lhs == rhs; }\n else if (const Element_Selector* lhs = Cast(this)) {return *lhs == rhs; }\n else if (const Attribute_Selector* lhs = Cast(this)) {return *lhs == rhs; }\n else if (name_ == rhs.name_)\n { return is_ns_eq(rhs); }\n else return false;\n }\n\n bool Simple_Selector::operator< (const Simple_Selector& rhs) const\n {\n // solve the double dispatch problem by using RTTI information via dynamic cast\n if (const Pseudo_Selector* lhs = Cast(this)) {return *lhs < rhs; }\n else if (const Wrapped_Selector* lhs = Cast(this)) {return *lhs < rhs; }\n else if (const Element_Selector* lhs = Cast(this)) {return *lhs < rhs; }\n else if (const Attribute_Selector* lhs = Cast(this)) {return *lhs < rhs; }\n if (is_ns_eq(rhs))\n { return name_ < rhs.name_; }\n return ns_ < rhs.ns_;\n }\n\n bool Selector_List::operator== (const Selector& rhs) const\n {\n // solve the double dispatch problem by using RTTI information via dynamic cast\n if (Selector_List_Ptr_Const sl = Cast(&rhs)) { return *this == *sl; }\n else if (Complex_Selector_Ptr_Const cpx = Cast(&rhs)) { return *this == *cpx; }\n else if (Compound_Selector_Ptr_Const cpd = Cast(&rhs)) { return *this == *cpd; }\n // no compare method\n return this == &rhs;\n }\n\n // Selector lists can be compared to comma lists\n bool Selector_List::operator== (const Expression& rhs) const\n {\n // solve the double dispatch problem by using RTTI information via dynamic cast\n if (List_Ptr_Const ls = Cast(&rhs)) { return *ls == *this; }\n if (Selector_Ptr_Const ls = Cast(&rhs)) { return *this == *ls; }\n // compare invalid (maybe we should error?)\n return false;\n }\n\n bool Selector_List::operator== (const Selector_List& rhs) const\n {\n // for array access\n size_t i = 0, n = 0;\n size_t iL = length();\n size_t nL = rhs.length();\n // create temporary vectors and sort them\n std::vector l_lst = this->elements();\n std::vector r_lst = rhs.elements();\n std::sort(l_lst.begin(), l_lst.end(), OrderNodes());\n std::sort(r_lst.begin(), r_lst.end(), OrderNodes());\n // process loop\n while (true)\n {\n // first check for valid index\n if (i == iL) return iL == nL;\n else if (n == nL) return iL == nL;\n // the access the vector items\n Complex_Selector_Obj l = l_lst[i];\n Complex_Selector_Obj r = r_lst[n];\n // skip nulls\n if (!l) ++i;\n else if (!r) ++n;\n // do the check\n else if (*l != *r)\n { return false; }\n // advance\n ++i; ++n;\n }\n // there is no break?!\n }\n\n bool Selector_List::operator< (const Selector& rhs) const\n {\n if (Selector_List_Ptr_Const sp = Cast(&rhs)) return *this < *sp;\n return false;\n }\n\n bool Selector_List::operator< (const Selector_List& rhs) const\n {\n size_t l = rhs.length();\n if (length() < l) l = length();\n for (size_t i = 0; i < l; i ++) {\n if (*at(i) < *rhs.at(i)) return true;\n }\n return false;\n }\n\n Compound_Selector_Ptr Simple_Selector::unify_with(Compound_Selector_Ptr rhs)\n {\n for (size_t i = 0, L = rhs->length(); i < L; ++i)\n { if (to_string() == rhs->at(i)->to_string()) return rhs; }\n\n // check for pseudo elements because they are always last\n size_t i, L;\n bool found = false;\n if (typeid(*this) == typeid(Pseudo_Selector) || typeid(*this) == typeid(Wrapped_Selector) || typeid(*this) == typeid(Attribute_Selector))\n {\n for (i = 0, L = rhs->length(); i < L; ++i)\n {\n if ((Cast((*rhs)[i]) || Cast((*rhs)[i]) || Cast((*rhs)[i])) && (*rhs)[L-1]->is_pseudo_element())\n { found = true; break; }\n }\n }\n else\n {\n for (i = 0, L = rhs->length(); i < L; ++i)\n {\n if (Cast((*rhs)[i]) || Cast((*rhs)[i]) || Cast((*rhs)[i]))\n { found = true; break; }\n }\n }\n if (!found)\n {\n rhs->append(this);\n } else {\n rhs->elements().insert(rhs->elements().begin() + i, this);\n }\n return rhs;\n }\n\n Simple_Selector_Ptr Element_Selector::unify_with(Simple_Selector_Ptr rhs)\n {\n // check if ns can be extended\n // true for no ns or universal\n if (has_universal_ns())\n {\n // but dont extend with universal\n // true for valid ns and universal\n if (!rhs->is_universal_ns())\n {\n // overwrite the name if star is given as name\n if (this->name() == \"*\") { this->name(rhs->name()); }\n // now overwrite the namespace name and flag\n this->ns(rhs->ns()); this->has_ns(rhs->has_ns());\n // return copy\n return this;\n }\n }\n // namespace may changed, check the name now\n // overwrite star (but not with another star)\n if (name() == \"*\" && rhs->name() != \"*\")\n {\n // simply set the new name\n this->name(rhs->name());\n // return copy\n return this;\n }\n // return original\n return this;\n }\n\n Compound_Selector_Ptr Element_Selector::unify_with(Compound_Selector_Ptr rhs)\n {\n // TODO: handle namespaces\n\n // if the rhs is empty, just return a copy of this\n if (rhs->length() == 0) {\n rhs->append(this);\n return rhs;\n }\n\n Simple_Selector_Ptr rhs_0 = rhs->at(0);\n // otherwise, this is a tag name\n if (name() == \"*\")\n {\n if (typeid(*rhs_0) == typeid(Element_Selector))\n {\n // if rhs is universal, just return this tagname + rhs's qualifiers\n Element_Selector_Ptr ts = Cast(rhs_0);\n rhs->at(0) = this->unify_with(ts);\n return rhs;\n }\n else if (Cast(rhs_0) || Cast(rhs_0)) {\n // qualifier is `.class`, so we can prefix with `ns|*.class`\n if (has_ns() && !rhs_0->has_ns()) {\n if (ns() != \"*\") rhs->elements().insert(rhs->begin(), this);\n }\n return rhs;\n }\n\n\n return rhs;\n }\n\n if (typeid(*rhs_0) == typeid(Element_Selector))\n {\n // if rhs is universal, just return this tagname + rhs's qualifiers\n if (rhs_0->name() != \"*\" && rhs_0->ns() != \"*\" && rhs_0->name() != name()) return 0;\n // otherwise create new compound and unify first simple selector\n rhs->at(0) = this->unify_with(rhs_0);\n return rhs;\n\n }\n // else it's a tag name and a bunch of qualifiers -- just append them\n if (name() != \"*\") rhs->elements().insert(rhs->begin(), this);\n return rhs;\n }\n\n Compound_Selector_Ptr Class_Selector::unify_with(Compound_Selector_Ptr rhs)\n {\n rhs->has_line_break(has_line_break());\n return Simple_Selector::unify_with(rhs);\n }\n\n Compound_Selector_Ptr Id_Selector::unify_with(Compound_Selector_Ptr rhs)\n {\n for (size_t i = 0, L = rhs->length(); i < L; ++i)\n {\n if (Id_Selector_Ptr sel = Cast(rhs->at(i))) {\n if (sel->name() != name()) return 0;\n }\n }\n rhs->has_line_break(has_line_break());\n return Simple_Selector::unify_with(rhs);\n }\n\n Compound_Selector_Ptr Pseudo_Selector::unify_with(Compound_Selector_Ptr rhs)\n {\n if (is_pseudo_element())\n {\n for (size_t i = 0, L = rhs->length(); i < L; ++i)\n {\n if (Pseudo_Selector_Ptr sel = Cast(rhs->at(i))) {\n if (sel->is_pseudo_element() && sel->name() != name()) return 0;\n }\n }\n }\n return Simple_Selector::unify_with(rhs);\n }\n\n bool Attribute_Selector::operator< (const Attribute_Selector& rhs) const\n {\n if (is_ns_eq(rhs)) {\n if (name() == rhs.name()) {\n if (matcher() == rhs.matcher()) {\n bool no_lhs_val = value().isNull();\n bool no_rhs_val = rhs.value().isNull();\n if (no_lhs_val && no_rhs_val) return false; // equal\n else if (no_lhs_val) return true; // lhs is null\n else if (no_rhs_val) return false; // rhs is null\n return *value() < *rhs.value(); // both are given\n } else { return matcher() < rhs.matcher(); }\n } else { return name() < rhs.name(); }\n } else { return ns() < rhs.ns(); }\n }\n\n bool Attribute_Selector::operator< (const Simple_Selector& rhs) const\n {\n if (Attribute_Selector_Ptr_Const w = Cast(&rhs))\n {\n return *this < *w;\n }\n if (is_ns_eq(rhs))\n { return name() < rhs.name(); }\n return ns() < rhs.ns();\n }\n\n bool Attribute_Selector::operator== (const Attribute_Selector& rhs) const\n {\n // get optional value state\n bool no_lhs_val = value().isNull();\n bool no_rhs_val = rhs.value().isNull();\n // both are null, therefore equal\n if (no_lhs_val && no_rhs_val) {\n return (name() == rhs.name())\n && (matcher() == rhs.matcher())\n && (is_ns_eq(rhs));\n }\n // both are defined, evaluate\n if (no_lhs_val == no_rhs_val) {\n return (name() == rhs.name())\n && (matcher() == rhs.matcher())\n && (is_ns_eq(rhs))\n && (*value() == *rhs.value());\n }\n // not equal\n return false;\n\n }\n\n bool Attribute_Selector::operator== (const Simple_Selector& rhs) const\n {\n if (Attribute_Selector_Ptr_Const w = Cast(&rhs))\n {\n return is_ns_eq(rhs) &&\n name() == rhs.name() &&\n *this == *w;\n }\n return false;\n }\n\n bool Element_Selector::operator< (const Element_Selector& rhs) const\n {\n if (is_ns_eq(rhs))\n { return name() < rhs.name(); }\n return ns() < rhs.ns();\n }\n\n bool Element_Selector::operator< (const Simple_Selector& rhs) const\n {\n if (Element_Selector_Ptr_Const w = Cast(&rhs))\n {\n return *this < *w;\n }\n if (is_ns_eq(rhs))\n { return name() < rhs.name(); }\n return ns() < rhs.ns();\n }\n\n bool Element_Selector::operator== (const Element_Selector& rhs) const\n {\n return is_ns_eq(rhs) &&\n name() == rhs.name();\n }\n\n bool Element_Selector::operator== (const Simple_Selector& rhs) const\n {\n if (Element_Selector_Ptr_Const w = Cast(&rhs))\n {\n return is_ns_eq(rhs) &&\n name() == rhs.name() &&\n *this == *w;\n }\n return false;\n }\n\n bool Pseudo_Selector::operator== (const Pseudo_Selector& rhs) const\n {\n if (is_ns_eq(rhs) && name() == rhs.name())\n {\n String_Obj lhs_ex = expression();\n String_Obj rhs_ex = rhs.expression();\n if (rhs_ex && lhs_ex) return *lhs_ex == *rhs_ex;\n else return lhs_ex.ptr() == rhs_ex.ptr();\n }\n else return false;\n }\n\n bool Pseudo_Selector::operator== (const Simple_Selector& rhs) const\n {\n if (Pseudo_Selector_Ptr_Const w = Cast(&rhs))\n {\n return *this == *w;\n }\n return is_ns_eq(rhs) &&\n name() == rhs.name();\n }\n\n bool Pseudo_Selector::operator< (const Pseudo_Selector& rhs) const\n {\n if (is_ns_eq(rhs) && name() == rhs.name())\n {\n String_Obj lhs_ex = expression();\n String_Obj rhs_ex = rhs.expression();\n if (rhs_ex && lhs_ex) return *lhs_ex < *rhs_ex;\n else return lhs_ex.ptr() < rhs_ex.ptr();\n }\n if (is_ns_eq(rhs))\n { return name() < rhs.name(); }\n return ns() < rhs.ns();\n }\n\n bool Pseudo_Selector::operator< (const Simple_Selector& rhs) const\n {\n if (Pseudo_Selector_Ptr_Const w = Cast(&rhs))\n {\n return *this < *w;\n }\n if (is_ns_eq(rhs))\n { return name() < rhs.name(); }\n return ns() < rhs.ns();\n }\n\n bool Wrapped_Selector::operator== (const Wrapped_Selector& rhs) const\n {\n if (is_ns_eq(rhs) && name() == rhs.name())\n { return *(selector()) == *(rhs.selector()); }\n else return false;\n }\n\n bool Wrapped_Selector::operator== (const Simple_Selector& rhs) const\n {\n if (Wrapped_Selector_Ptr_Const w = Cast(&rhs))\n {\n return *this == *w;\n }\n return is_ns_eq(rhs) &&\n name() == rhs.name();\n }\n\n bool Wrapped_Selector::operator< (const Wrapped_Selector& rhs) const\n {\n if (is_ns_eq(rhs) && name() == rhs.name())\n { return *(selector()) < *(rhs.selector()); }\n if (is_ns_eq(rhs))\n { return name() < rhs.name(); }\n return ns() < rhs.ns();\n }\n\n bool Wrapped_Selector::operator< (const Simple_Selector& rhs) const\n {\n if (Wrapped_Selector_Ptr_Const w = Cast(&rhs))\n {\n return *this < *w;\n }\n if (is_ns_eq(rhs))\n { return name() < rhs.name(); }\n return ns() < rhs.ns();\n }\n\n bool Wrapped_Selector::is_superselector_of(Wrapped_Selector_Obj sub)\n {\n if (this->name() != sub->name()) return false;\n if (this->name() == \":current\") return false;\n if (Selector_List_Obj rhs_list = Cast(sub->selector())) {\n if (Selector_List_Obj lhs_list = Cast(selector())) {\n return lhs_list->is_superselector_of(rhs_list);\n }\n }\n coreError(\"is_superselector expected a Selector_List\", sub->pstate());\n return false;\n }\n\n bool Compound_Selector::is_superselector_of(Selector_List_Obj rhs, std::string wrapped)\n {\n for (Complex_Selector_Obj item : rhs->elements()) {\n if (is_superselector_of(item, wrapped)) return true;\n }\n return false;\n }\n\n bool Compound_Selector::is_superselector_of(Complex_Selector_Obj rhs, std::string wrapped)\n {\n if (rhs->head()) return is_superselector_of(rhs->head(), wrapped);\n return false;\n }\n\n bool Compound_Selector::is_superselector_of(Compound_Selector_Obj rhs, std::string wrapping)\n {\n Compound_Selector_Ptr lhs = this;\n Simple_Selector_Ptr lbase = lhs->base();\n Simple_Selector_Ptr rbase = rhs->base();\n\n // Check if pseudo-elements are the same between the selectors\n\n std::set lpsuedoset, rpsuedoset;\n for (size_t i = 0, L = length(); i < L; ++i)\n {\n if ((*this)[i]->is_pseudo_element()) {\n std::string pseudo((*this)[i]->to_string());\n pseudo = pseudo.substr(pseudo.find_first_not_of(\":\")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving\n lpsuedoset.insert(pseudo);\n }\n }\n for (size_t i = 0, L = rhs->length(); i < L; ++i)\n {\n if ((*rhs)[i]->is_pseudo_element()) {\n std::string pseudo((*rhs)[i]->to_string());\n pseudo = pseudo.substr(pseudo.find_first_not_of(\":\")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving\n rpsuedoset.insert(pseudo);\n }\n }\n if (lpsuedoset != rpsuedoset) {\n return false;\n }\n\n // would like to replace this without stringification\n // https://github.com/sass/sass/issues/2229\n // SimpleSelectorSet lset, rset;\n std::set lset, rset;\n\n if (lbase && rbase)\n {\n if (lbase->to_string() == rbase->to_string()) {\n for (size_t i = 1, L = length(); i < L; ++i)\n { lset.insert((*this)[i]->to_string()); }\n for (size_t i = 1, L = rhs->length(); i < L; ++i)\n { rset.insert((*rhs)[i]->to_string()); }\n return includes(rset.begin(), rset.end(), lset.begin(), lset.end());\n }\n return false;\n }\n\n for (size_t i = 0, iL = length(); i < iL; ++i)\n {\n Selector_Obj wlhs = (*this)[i];\n // very special case for wrapped matches selector\n if (Wrapped_Selector_Obj wrapped = Cast(wlhs)) {\n if (wrapped->name() == \":not\") {\n if (Selector_List_Obj not_list = Cast(wrapped->selector())) {\n if (not_list->is_superselector_of(rhs, wrapped->name())) return false;\n } else {\n throw std::runtime_error(\"wrapped not selector is not a list\");\n }\n }\n if (wrapped->name() == \":matches\" || wrapped->name() == \":-moz-any\") {\n wlhs = wrapped->selector();\n if (Selector_List_Obj list = Cast(wrapped->selector())) {\n if (Compound_Selector_Obj comp = Cast(rhs)) {\n if (!wrapping.empty() && wrapping != wrapped->name()) return false;\n if (wrapping.empty() || wrapping != wrapped->name()) {;\n if (list->is_superselector_of(comp, wrapped->name())) return true;\n }\n }\n }\n }\n Simple_Selector_Ptr rhs_sel = NULL;\n if (rhs->elements().size() > i) rhs_sel = (*rhs)[i];\n if (Wrapped_Selector_Ptr wrapped_r = Cast(rhs_sel)) {\n if (wrapped->name() == wrapped_r->name()) {\n if (wrapped->is_superselector_of(wrapped_r)) {\n continue;\n }}\n }\n }\n // match from here on as strings\n lset.insert(wlhs->to_string());\n }\n\n for (size_t n = 0, nL = rhs->length(); n < nL; ++n)\n {\n Selector_Obj r = (*rhs)[n];\n if (Wrapped_Selector_Obj wrapped = Cast(r)) {\n if (wrapped->name() == \":not\") {\n if (Selector_List_Obj ls = Cast(wrapped->selector())) {\n ls->remove_parent_selectors();\n if (is_superselector_of(ls, wrapped->name())) return false;\n }\n }\n if (wrapped->name() == \":matches\" || wrapped->name() == \":-moz-any\") {\n if (!wrapping.empty()) {\n if (wrapping != wrapped->name()) return false;\n }\n if (Selector_List_Obj ls = Cast(wrapped->selector())) {\n ls->remove_parent_selectors();\n return (is_superselector_of(ls, wrapped->name()));\n }\n }\n }\n rset.insert(r->to_string());\n }\n\n //for (auto l : lset) { cerr << \"l: \" << l << endl; }\n //for (auto r : rset) { cerr << \"r: \" << r << endl; }\n\n if (lset.empty()) return true;\n // return true if rset contains all the elements of lset\n return includes(rset.begin(), rset.end(), lset.begin(), lset.end());\n\n }\n\n // create complex selector (ancestor of) from compound selector\n Complex_Selector_Obj Compound_Selector::to_complex()\n {\n // create an intermediate complex selector\n return SASS_MEMORY_NEW(Complex_Selector,\n pstate(),\n Complex_Selector::ANCESTOR_OF,\n this,\n 0);\n }\n\n Selector_List_Ptr Complex_Selector::unify_with(Complex_Selector_Ptr other)\n {\n\n // get last tails (on the right side)\n Complex_Selector_Obj l_last = this->last();\n Complex_Selector_Obj r_last = other->last();\n\n // check valid pointers (assertion)\n SASS_ASSERT(l_last, \"lhs is null\");\n SASS_ASSERT(r_last, \"rhs is null\");\n\n // Not sure about this check, but closest way I could check\n // was to see if this is a ruby 'SimpleSequence' equivalent.\n // It seems to do the job correctly as some specs react to this\n if (l_last->combinator() != Combinator::ANCESTOR_OF) return 0;\n if (r_last->combinator() != Combinator::ANCESTOR_OF ) return 0;\n\n // get the headers for the last tails\n Compound_Selector_Obj l_last_head = l_last->head();\n Compound_Selector_Obj r_last_head = r_last->head();\n\n // check valid head pointers (assertion)\n SASS_ASSERT(l_last_head, \"lhs head is null\");\n SASS_ASSERT(r_last_head, \"rhs head is null\");\n\n // get the unification of the last compound selectors\n Compound_Selector_Obj unified = r_last_head->unify_with(l_last_head);\n\n // abort if we could not unify heads\n if (unified == 0) return 0;\n\n // check for universal (star: `*`) selector\n bool is_universal = l_last_head->is_universal() ||\n r_last_head->is_universal();\n\n if (is_universal)\n {\n // move the head\n l_last->head(0);\n r_last->head(unified);\n }\n\n // create nodes from both selectors\n Node lhsNode = complexSelectorToNode(this);\n Node rhsNode = complexSelectorToNode(other);\n\n // overwrite universal base\n if (!is_universal)\n {\n // create some temporaries to convert to node\n Complex_Selector_Obj fake = unified->to_complex();\n Node unified_node = complexSelectorToNode(fake);\n // add to permutate the list?\n rhsNode.plus(unified_node);\n }\n\n // do some magic we inherit from node and extend\n Node node = subweave(lhsNode, rhsNode);\n Selector_List_Obj result = SASS_MEMORY_NEW(Selector_List, pstate());\n NodeDequePtr col = node.collection(); // move from collection to list\n for (NodeDeque::iterator it = col->begin(), end = col->end(); it != end; it++)\n { result->append(nodeToComplexSelector(Node::naiveTrim(*it))); }\n\n // only return if list has some entries\n return result->length() ? result.detach() : 0;\n\n }\n\n bool Compound_Selector::operator== (const Compound_Selector& rhs) const\n {\n // for array access\n size_t i = 0, n = 0;\n size_t iL = length();\n size_t nL = rhs.length();\n // create temporary vectors and sort them\n std::vector l_lst = this->elements();\n std::vector r_lst = rhs.elements();\n std::sort(l_lst.begin(), l_lst.end(), OrderNodes());\n std::sort(r_lst.begin(), r_lst.end(), OrderNodes());\n // process loop\n while (true)\n {\n // first check for valid index\n if (i == iL) return iL == nL;\n else if (n == nL) return iL == nL;\n // the access the vector items\n Simple_Selector_Obj l = l_lst[i];\n Simple_Selector_Obj r = r_lst[n];\n // skip nulls\n if (!l) ++i;\n if (!r) ++n;\n // do the check now\n else if (*l != *r)\n { return false; }\n // advance now\n ++i; ++n;\n }\n // there is no break?!\n }\n\n bool Complex_Selector::is_superselector_of(Compound_Selector_Obj rhs, std::string wrapping)\n {\n return last()->head() && last()->head()->is_superselector_of(rhs, wrapping);\n }\n\n bool Complex_Selector::is_superselector_of(Complex_Selector_Obj rhs, std::string wrapping)\n {\n Complex_Selector_Ptr lhs = this;\n // check for selectors with leading or trailing combinators\n if (!lhs->head() || !rhs->head())\n { return false; }\n Complex_Selector_Obj l_innermost = lhs->innermost();\n if (l_innermost->combinator() != Complex_Selector::ANCESTOR_OF)\n { return false; }\n Complex_Selector_Obj r_innermost = rhs->innermost();\n if (r_innermost->combinator() != Complex_Selector::ANCESTOR_OF)\n { return false; }\n // more complex (i.e., longer) selectors are always more specific\n size_t l_len = lhs->length(), r_len = rhs->length();\n if (l_len > r_len)\n { return false; }\n\n if (l_len == 1)\n { return lhs->head()->is_superselector_of(rhs->last()->head(), wrapping); }\n\n // we have to look one tail deeper, since we cary the\n // combinator around for it (which is important here)\n if (rhs->tail() && lhs->tail() && combinator() != Complex_Selector::ANCESTOR_OF) {\n Complex_Selector_Obj lhs_tail = lhs->tail();\n Complex_Selector_Obj rhs_tail = rhs->tail();\n if (lhs_tail->combinator() != rhs_tail->combinator()) return false;\n if (lhs_tail->head() && !rhs_tail->head()) return false;\n if (!lhs_tail->head() && rhs_tail->head()) return false;\n if (lhs_tail->head() && rhs_tail->head()) {\n if (!lhs_tail->head()->is_superselector_of(rhs_tail->head())) return false;\n }\n }\n\n bool found = false;\n Complex_Selector_Obj marker = rhs;\n for (size_t i = 0, L = rhs->length(); i < L; ++i) {\n if (i == L-1)\n { return false; }\n if (lhs->head() && marker->head() && lhs->head()->is_superselector_of(marker->head(), wrapping))\n { found = true; break; }\n marker = marker->tail();\n }\n if (!found)\n { return false; }\n\n /*\n Hmm, I hope I have the logic right:\n\n if lhs has a combinator:\n if !(marker has a combinator) return false\n if !(lhs.combinator == '~' ? marker.combinator != '>' : lhs.combinator == marker.combinator) return false\n return lhs.tail-without-innermost.is_superselector_of(marker.tail-without-innermost)\n else if marker has a combinator:\n if !(marker.combinator == \">\") return false\n return lhs.tail.is_superselector_of(marker.tail)\n else\n return lhs.tail.is_superselector_of(marker.tail)\n */\n if (lhs->combinator() != Complex_Selector::ANCESTOR_OF)\n {\n if (marker->combinator() == Complex_Selector::ANCESTOR_OF)\n { return false; }\n if (!(lhs->combinator() == Complex_Selector::PRECEDES ? marker->combinator() != Complex_Selector::PARENT_OF : lhs->combinator() == marker->combinator()))\n { return false; }\n return lhs->tail()->is_superselector_of(marker->tail());\n }\n else if (marker->combinator() != Complex_Selector::ANCESTOR_OF)\n {\n if (marker->combinator() != Complex_Selector::PARENT_OF)\n { return false; }\n return lhs->tail()->is_superselector_of(marker->tail());\n }\n return lhs->tail()->is_superselector_of(marker->tail());\n }\n\n size_t Complex_Selector::length() const\n {\n // TODO: make this iterative\n if (!tail()) return 1;\n return 1 + tail()->length();\n }\n\n // append another complex selector at the end\n // check if we need to append some headers\n // then we need to check for the combinator\n // only then we can safely set the new tail\n void Complex_Selector::append(Complex_Selector_Obj ss, Backtraces& traces)\n {\n\n Complex_Selector_Obj t = ss->tail();\n Combinator c = ss->combinator();\n String_Obj r = ss->reference();\n Compound_Selector_Obj h = ss->head();\n\n if (ss->has_line_feed()) has_line_feed(true);\n if (ss->has_line_break()) has_line_break(true);\n\n // append old headers\n if (h && h->length()) {\n if (last()->combinator() != ANCESTOR_OF && c != ANCESTOR_OF) {\n traces.push_back(Backtrace(pstate()));\n throw Exception::InvalidParent(this, traces, ss);\n } else if (last()->head_ && last()->head_->length()) {\n Compound_Selector_Obj rh = last()->head();\n size_t i;\n size_t L = h->length();\n if (Cast(h->first())) {\n if (Class_Selector_Ptr cs = Cast(rh->last())) {\n Class_Selector_Ptr sqs = SASS_MEMORY_COPY(cs);\n sqs->name(sqs->name() + (*h)[0]->name());\n sqs->pstate((*h)[0]->pstate());\n (*rh)[rh->length()-1] = sqs;\n rh->pstate(h->pstate());\n for (i = 1; i < L; ++i) rh->append((*h)[i]);\n } else if (Id_Selector_Ptr is = Cast(rh->last())) {\n Id_Selector_Ptr sqs = SASS_MEMORY_COPY(is);\n sqs->name(sqs->name() + (*h)[0]->name());\n sqs->pstate((*h)[0]->pstate());\n (*rh)[rh->length()-1] = sqs;\n rh->pstate(h->pstate());\n for (i = 1; i < L; ++i) rh->append((*h)[i]);\n } else if (Element_Selector_Ptr ts = Cast(rh->last())) {\n Element_Selector_Ptr tss = SASS_MEMORY_COPY(ts);\n tss->name(tss->name() + (*h)[0]->name());\n tss->pstate((*h)[0]->pstate());\n (*rh)[rh->length()-1] = tss;\n rh->pstate(h->pstate());\n for (i = 1; i < L; ++i) rh->append((*h)[i]);\n } else if (Placeholder_Selector_Ptr ps = Cast(rh->last())) {\n Placeholder_Selector_Ptr pss = SASS_MEMORY_COPY(ps);\n pss->name(pss->name() + (*h)[0]->name());\n pss->pstate((*h)[0]->pstate());\n (*rh)[rh->length()-1] = pss;\n rh->pstate(h->pstate());\n for (i = 1; i < L; ++i) rh->append((*h)[i]);\n } else {\n last()->head_->concat(h);\n }\n } else {\n last()->head_->concat(h);\n }\n } else if (last()->head_) {\n last()->head_->concat(h);\n }\n } else {\n // std::cerr << \"has no or empty head\\n\";\n }\n\n if (last()) {\n if (last()->combinator() != ANCESTOR_OF && c != ANCESTOR_OF) {\n Complex_Selector_Ptr inter = SASS_MEMORY_NEW(Complex_Selector, pstate());\n inter->reference(r);\n inter->combinator(c);\n inter->tail(t);\n last()->tail(inter);\n } else {\n if (last()->combinator() == ANCESTOR_OF) {\n last()->combinator(c);\n last()->reference(r);\n }\n last()->tail(t);\n }\n }\n\n }\n\n Selector_List_Obj Selector_List::eval(Eval& eval)\n {\n Selector_List_Obj list = schema() ?\n eval(schema()) : eval(this);\n list->schema(schema());\n return list;\n }\n\n Selector_List_Ptr Selector_List::resolve_parent_refs(std::vector& pstack, Backtraces& traces, bool implicit_parent)\n {\n if (!this->has_parent_ref()) return this;\n Selector_List_Ptr ss = SASS_MEMORY_NEW(Selector_List, pstate());\n Selector_List_Ptr ps = pstack.back();\n for (size_t pi = 0, pL = ps->length(); pi < pL; ++pi) {\n for (size_t si = 0, sL = this->length(); si < sL; ++si) {\n Selector_List_Obj rv = at(si)->resolve_parent_refs(pstack, traces, implicit_parent);\n ss->concat(rv);\n }\n }\n return ss;\n }\n\n Selector_List_Ptr Complex_Selector::resolve_parent_refs(std::vector& pstack, Backtraces& traces, bool implicit_parent)\n {\n Complex_Selector_Obj tail = this->tail();\n Compound_Selector_Obj head = this->head();\n Selector_List_Ptr parents = pstack.back();\n\n if (!this->has_real_parent_ref() && !implicit_parent) {\n Selector_List_Ptr retval = SASS_MEMORY_NEW(Selector_List, pstate());\n retval->append(this);\n return retval;\n }\n\n // first resolve_parent_refs the tail (which may return an expanded list)\n Selector_List_Obj tails = tail ? tail->resolve_parent_refs(pstack, traces, implicit_parent) : 0;\n\n if (head && head->length() > 0) {\n\n Selector_List_Obj retval;\n // we have a parent selector in a simple compound list\n // mix parent complex selector into the compound list\n if (Cast((*head)[0])) {\n retval = SASS_MEMORY_NEW(Selector_List, pstate());\n\n // it turns out that real parent references reach\n // across @at-root rules, which comes unexpected\n if (parents == NULL && head->has_real_parent_ref()) {\n int i = pstack.size() - 1;\n while (!parents && i > -1) {\n parents = pstack.at(i--);\n }\n }\n\n if (parents && parents->length()) {\n if (tails && tails->length() > 0) {\n for (size_t n = 0, nL = tails->length(); n < nL; ++n) {\n for (size_t i = 0, iL = parents->length(); i < iL; ++i) {\n Complex_Selector_Obj t = (*tails)[n];\n Complex_Selector_Obj parent = (*parents)[i];\n Complex_Selector_Obj s = SASS_MEMORY_CLONE(parent);\n Complex_Selector_Obj ss = SASS_MEMORY_CLONE(this);\n ss->tail(t ? SASS_MEMORY_CLONE(t) : NULL);\n Compound_Selector_Obj h = SASS_MEMORY_COPY(head_);\n // remove parent selector from sequence\n if (h->length()) {\n h->erase(h->begin());\n ss->head(h);\n } else {\n ss->head(NULL);\n }\n // adjust for parent selector (1 char)\n // if (h->length()) {\n // ParserState state(h->at(0)->pstate());\n // state.offset.column += 1;\n // state.column -= 1;\n // (*h)[0]->pstate(state);\n // }\n // keep old parser state\n s->pstate(pstate());\n // append new tail\n s->append(ss, traces);\n retval->append(s);\n }\n }\n }\n // have no tails but parents\n // loop above is inside out\n else {\n for (size_t i = 0, iL = parents->length(); i < iL; ++i) {\n Complex_Selector_Obj parent = (*parents)[i];\n Complex_Selector_Obj s = SASS_MEMORY_CLONE(parent);\n Complex_Selector_Obj ss = SASS_MEMORY_CLONE(this);\n // this is only if valid if the parent has no trailing op\n // otherwise we cannot append more simple selectors to head\n if (parent->last()->combinator() != ANCESTOR_OF) {\n traces.push_back(Backtrace(pstate()));\n throw Exception::InvalidParent(parent, traces, ss);\n }\n ss->tail(tail ? SASS_MEMORY_CLONE(tail) : NULL);\n Compound_Selector_Obj h = SASS_MEMORY_COPY(head_);\n // remove parent selector from sequence\n if (h->length()) {\n h->erase(h->begin());\n ss->head(h);\n } else {\n ss->head(NULL);\n }\n // \\/ IMO ruby sass bug \\/\n ss->has_line_feed(false);\n // adjust for parent selector (1 char)\n // if (h->length()) {\n // ParserState state(h->at(0)->pstate());\n // state.offset.column += 1;\n // state.column -= 1;\n // (*h)[0]->pstate(state);\n // }\n // keep old parser state\n s->pstate(pstate());\n // append new tail\n s->append(ss, traces);\n retval->append(s);\n }\n }\n }\n // have no parent but some tails\n else {\n if (tails && tails->length() > 0) {\n for (size_t n = 0, nL = tails->length(); n < nL; ++n) {\n Complex_Selector_Obj cpy = SASS_MEMORY_CLONE(this);\n cpy->tail(SASS_MEMORY_CLONE(tails->at(n)));\n cpy->head(SASS_MEMORY_NEW(Compound_Selector, head->pstate()));\n for (size_t i = 1, L = this->head()->length(); i < L; ++i)\n cpy->head()->append((*this->head())[i]);\n if (!cpy->head()->length()) cpy->head(0);\n retval->append(cpy->skip_empty_reference());\n }\n }\n // have no parent nor tails\n else {\n Complex_Selector_Obj cpy = SASS_MEMORY_CLONE(this);\n cpy->head(SASS_MEMORY_NEW(Compound_Selector, head->pstate()));\n for (size_t i = 1, L = this->head()->length(); i < L; ++i)\n cpy->head()->append((*this->head())[i]);\n if (!cpy->head()->length()) cpy->head(0);\n retval->append(cpy->skip_empty_reference());\n }\n }\n }\n // no parent selector in head\n else {\n retval = this->tails(tails);\n }\n\n for (Simple_Selector_Obj ss : head->elements()) {\n if (Wrapped_Selector_Ptr ws = Cast(ss)) {\n if (Selector_List_Ptr sl = Cast(ws->selector())) {\n if (parents) ws->selector(sl->resolve_parent_refs(pstack, traces, implicit_parent));\n }\n }\n }\n\n return retval.detach();\n\n }\n // has no head\n return this->tails(tails);\n }\n\n Selector_List_Ptr Complex_Selector::tails(Selector_List_Ptr tails)\n {\n Selector_List_Ptr rv = SASS_MEMORY_NEW(Selector_List, pstate_);\n if (tails && tails->length()) {\n for (size_t i = 0, iL = tails->length(); i < iL; ++i) {\n Complex_Selector_Obj pr = SASS_MEMORY_CLONE(this);\n pr->tail(tails->at(i));\n rv->append(pr);\n }\n }\n else {\n rv->append(this);\n }\n return rv;\n }\n\n // return the last tail that is defined\n Complex_Selector_Obj Complex_Selector::first()\n {\n // declare variables used in loop\n Complex_Selector_Obj cur = this;\n Compound_Selector_Obj head;\n // processing loop\n while (cur)\n {\n // get the head\n head = cur->head_;\n // abort (and return) if it is not a parent selector\n if (!head || head->length() != 1 || !Cast((*head)[0])) {\n break;\n }\n // advance to next\n cur = cur->tail_;\n }\n // result\n return cur;\n }\n\n // return the last tail that is defined\n Complex_Selector_Obj Complex_Selector::last()\n {\n Complex_Selector_Ptr cur = this;\n Complex_Selector_Ptr nxt = cur;\n // loop until last\n while (nxt) {\n cur = nxt;\n nxt = cur->tail();\n }\n return cur;\n }\n\n Complex_Selector::Combinator Complex_Selector::clear_innermost()\n {\n Combinator c;\n if (!tail() || tail()->tail() == 0)\n { c = combinator(); combinator(ANCESTOR_OF); tail(0); }\n else\n { c = tail()->clear_innermost(); }\n return c;\n }\n\n void Complex_Selector::set_innermost(Complex_Selector_Obj val, Combinator c)\n {\n if (!tail())\n { tail(val); combinator(c); }\n else\n { tail()->set_innermost(val, c); }\n }\n\n void Complex_Selector::cloneChildren()\n {\n if (head()) head(SASS_MEMORY_CLONE(head()));\n if (tail()) tail(SASS_MEMORY_CLONE(tail()));\n }\n\n void Compound_Selector::cloneChildren()\n {\n for (size_t i = 0, l = length(); i < l; i++) {\n at(i) = SASS_MEMORY_CLONE(at(i));\n }\n }\n\n void Selector_List::cloneChildren()\n {\n for (size_t i = 0, l = length(); i < l; i++) {\n at(i) = SASS_MEMORY_CLONE(at(i));\n }\n }\n\n void Wrapped_Selector::cloneChildren()\n {\n selector(SASS_MEMORY_CLONE(selector()));\n }\n\n // remove parent selector references\n // basically unwraps parsed selectors\n void Selector_List::remove_parent_selectors()\n {\n // Check every rhs selector against left hand list\n for(size_t i = 0, L = length(); i < L; ++i) {\n if (!(*this)[i]->head()) continue;\n if ((*this)[i]->head()->is_empty_reference()) {\n // simply move to the next tail if we have \"no\" combinator\n if ((*this)[i]->combinator() == Complex_Selector::ANCESTOR_OF) {\n if ((*this)[i]->tail()) {\n if ((*this)[i]->has_line_feed()) {\n (*this)[i]->tail()->has_line_feed(true);\n }\n (*this)[i] = (*this)[i]->tail();\n }\n }\n // otherwise remove the first item from head\n else {\n (*this)[i]->head()->erase((*this)[i]->head()->begin());\n }\n }\n }\n }\n\n size_t Wrapped_Selector::hash()\n {\n if (hash_ == 0) {\n hash_combine(hash_, Simple_Selector::hash());\n if (selector_) hash_combine(hash_, selector_->hash());\n }\n return hash_;\n }\n bool Wrapped_Selector::has_parent_ref() const {\n // if (has_reference()) return true;\n if (!selector()) return false;\n return selector()->has_parent_ref();\n }\n bool Wrapped_Selector::has_real_parent_ref() const {\n // if (has_reference()) return true;\n if (!selector()) return false;\n return selector()->has_real_parent_ref();\n }\n unsigned long Wrapped_Selector::specificity() const\n {\n return selector_ ? selector_->specificity() : 0;\n }\n\n\n bool Selector_List::has_parent_ref() const\n {\n for (Complex_Selector_Obj s : elements()) {\n if (s && s->has_parent_ref()) return true;\n }\n return false;\n }\n\n bool Selector_List::has_real_parent_ref() const\n {\n for (Complex_Selector_Obj s : elements()) {\n if (s && s->has_real_parent_ref()) return true;\n }\n return false;\n }\n\n bool Selector_Schema::has_parent_ref() const\n {\n if (String_Schema_Obj schema = Cast(contents())) {\n return schema->length() > 0 && Cast(schema->at(0)) != NULL;\n }\n return false;\n }\n\n bool Selector_Schema::has_real_parent_ref() const\n {\n if (String_Schema_Obj schema = Cast(contents())) {\n Parent_Selector_Obj p = Cast(schema->at(0));\n return schema->length() > 0 && p && p->is_real_parent_ref();\n }\n return false;\n }\n\n void Selector_List::adjust_after_pushing(Complex_Selector_Obj c)\n {\n // if (c->has_reference()) has_reference(true);\n }\n\n // it's a superselector if every selector of the right side\n // list is a superselector of the given left side selector\n bool Complex_Selector::is_superselector_of(Selector_List_Obj sub, std::string wrapping)\n {\n // Check every rhs selector against left hand list\n for(size_t i = 0, L = sub->length(); i < L; ++i) {\n if (!is_superselector_of((*sub)[i], wrapping)) return false;\n }\n return true;\n }\n\n // it's a superselector if every selector of the right side\n // list is a superselector of the given left side selector\n bool Selector_List::is_superselector_of(Selector_List_Obj sub, std::string wrapping)\n {\n // Check every rhs selector against left hand list\n for(size_t i = 0, L = sub->length(); i < L; ++i) {\n if (!is_superselector_of((*sub)[i], wrapping)) return false;\n }\n return true;\n }\n\n // it's a superselector if every selector on the right side\n // is a superselector of any one of the left side selectors\n bool Selector_List::is_superselector_of(Compound_Selector_Obj sub, std::string wrapping)\n {\n // Check every lhs selector against right hand\n for(size_t i = 0, L = length(); i < L; ++i) {\n if ((*this)[i]->is_superselector_of(sub, wrapping)) return true;\n }\n return false;\n }\n\n // it's a superselector if every selector on the right side\n // is a superselector of any one of the left side selectors\n bool Selector_List::is_superselector_of(Complex_Selector_Obj sub, std::string wrapping)\n {\n // Check every lhs selector against right hand\n for(size_t i = 0, L = length(); i < L; ++i) {\n if ((*this)[i]->is_superselector_of(sub)) return true;\n }\n return false;\n }\n\n Selector_List_Ptr Selector_List::unify_with(Selector_List_Ptr rhs) {\n std::vector unified_complex_selectors;\n // Unify all of children with RHS's children, storing the results in `unified_complex_selectors`\n for (size_t lhs_i = 0, lhs_L = length(); lhs_i < lhs_L; ++lhs_i) {\n Complex_Selector_Obj seq1 = (*this)[lhs_i];\n for(size_t rhs_i = 0, rhs_L = rhs->length(); rhs_i < rhs_L; ++rhs_i) {\n Complex_Selector_Ptr seq2 = rhs->at(rhs_i);\n\n Selector_List_Obj result = seq1->unify_with(seq2);\n if( result ) {\n for(size_t i = 0, L = result->length(); i < L; ++i) {\n unified_complex_selectors.push_back( (*result)[i] );\n }\n }\n }\n }\n\n // Creates the final Selector_List by combining all the complex selectors\n Selector_List_Ptr final_result = SASS_MEMORY_NEW(Selector_List, pstate());\n for (auto itr = unified_complex_selectors.begin(); itr != unified_complex_selectors.end(); ++itr) {\n final_result->append(*itr);\n }\n return final_result;\n }\n\n void Selector_List::populate_extends(Selector_List_Obj extendee, Subset_Map& extends)\n {\n\n Selector_List_Ptr extender = this;\n for (auto complex_sel : extendee->elements()) {\n Complex_Selector_Obj c = complex_sel;\n\n\n // Ignore any parent selectors, until we find the first non Selectorerence head\n Compound_Selector_Obj compound_sel = c->head();\n Complex_Selector_Obj pIter = complex_sel;\n while (pIter) {\n Compound_Selector_Obj pHead = pIter->head();\n if (pHead && Cast(pHead->elements()[0]) == NULL) {\n compound_sel = pHead;\n break;\n }\n\n pIter = pIter->tail();\n }\n\n if (!pIter->head() || pIter->tail()) {\n coreError(\"nested selectors may not be extended\", c->pstate());\n }\n\n compound_sel->is_optional(extendee->is_optional());\n\n for (size_t i = 0, L = extender->length(); i < L; ++i) {\n extends.put(compound_sel, std::make_pair((*extender)[i], compound_sel));\n }\n }\n };\n\n void Compound_Selector::append(Simple_Selector_Ptr element)\n {\n Vectorized::append(element);\n pstate_.offset += element->pstate().offset;\n }\n\n Compound_Selector_Ptr Compound_Selector::minus(Compound_Selector_Ptr rhs)\n {\n Compound_Selector_Ptr result = SASS_MEMORY_NEW(Compound_Selector, pstate());\n // result->has_parent_reference(has_parent_reference());\n\n // not very efficient because it needs to preserve order\n for (size_t i = 0, L = length(); i < L; ++i)\n {\n bool found = false;\n std::string thisSelector((*this)[i]->to_string());\n for (size_t j = 0, M = rhs->length(); j < M; ++j)\n {\n if (thisSelector == (*rhs)[j]->to_string())\n {\n found = true;\n break;\n }\n }\n if (!found) result->append((*this)[i]);\n }\n\n return result;\n }\n\n void Compound_Selector::mergeSources(ComplexSelectorSet& sources)\n {\n for (ComplexSelectorSet::iterator iterator = sources.begin(), endIterator = sources.end(); iterator != endIterator; ++iterator) {\n this->sources_.insert(SASS_MEMORY_CLONE(*iterator));\n }\n }\n\n Argument_Obj Arguments::get_rest_argument()\n {\n if (this->has_rest_argument()) {\n for (Argument_Obj arg : this->elements()) {\n if (arg->is_rest_argument()) {\n return arg;\n }\n }\n }\n return NULL;\n }\n\n Argument_Obj Arguments::get_keyword_argument()\n {\n if (this->has_keyword_argument()) {\n for (Argument_Obj arg : this->elements()) {\n if (arg->is_keyword_argument()) {\n return arg;\n }\n }\n }\n return NULL;\n }\n\n void Arguments::adjust_after_pushing(Argument_Obj a)\n {\n if (!a->name().empty()) {\n if (has_keyword_argument()) {\n coreError(\"named arguments must precede variable-length argument\", a->pstate());\n }\n has_named_arguments(true);\n }\n else if (a->is_rest_argument()) {\n if (has_rest_argument()) {\n coreError(\"functions and mixins may only be called with one variable-length argument\", a->pstate());\n }\n if (has_keyword_argument_) {\n coreError(\"only keyword arguments may follow variable arguments\", a->pstate());\n }\n has_rest_argument(true);\n }\n else if (a->is_keyword_argument()) {\n if (has_keyword_argument()) {\n coreError(\"functions and mixins may only be called with one keyword argument\", a->pstate());\n }\n has_keyword_argument(true);\n }\n else {\n if (has_rest_argument()) {\n coreError(\"ordinal arguments must precede variable-length arguments\", a->pstate());\n }\n if (has_named_arguments()) {\n coreError(\"ordinal arguments must precede named arguments\", a->pstate());\n }\n }\n }\n\n bool Ruleset::is_invisible() const {\n if (Selector_List_Ptr sl = Cast(selector())) {\n for (size_t i = 0, L = sl->length(); i < L; ++i)\n if (!(*sl)[i]->has_placeholder()) return false;\n }\n return true;\n }\n\n bool Media_Block::is_invisible() const {\n for (size_t i = 0, L = block()->length(); i < L; ++i) {\n Statement_Obj stm = block()->at(i);\n if (!stm->is_invisible()) return false;\n }\n return true;\n }\n\n Number::Number(ParserState pstate, double val, std::string u, bool zero)\n : Value(pstate),\n Units(),\n value_(val),\n zero_(zero),\n hash_(0)\n {\n size_t l = 0;\n size_t r;\n if (!u.empty()) {\n bool nominator = true;\n while (true) {\n r = u.find_first_of(\"*/\", l);\n std::string unit(u.substr(l, r == std::string::npos ? r : r - l));\n if (!unit.empty()) {\n if (nominator) numerators.push_back(unit);\n else denominators.push_back(unit);\n }\n if (r == std::string::npos) break;\n // ToDo: should error for multiple slashes\n // if (!nominator && u[r] == '/') error(...)\n if (u[r] == '/')\n nominator = false;\n // strange math parsing?\n // else if (u[r] == '*')\n // nominator = true;\n l = r + 1;\n }\n }\n concrete_type(NUMBER);\n }\n\n // cancel out unnecessary units\n void Number::reduce()\n {\n // apply conversion factor\n value_ *= this->Units::reduce();\n }\n\n void Number::normalize()\n {\n // apply conversion factor\n value_ *= this->Units::normalize();\n }\n\n bool Custom_Warning::operator== (const Expression& rhs) const\n {\n if (Custom_Warning_Ptr_Const r = Cast(&rhs)) {\n return message() == r->message();\n }\n return false;\n }\n\n bool Custom_Error::operator== (const Expression& rhs) const\n {\n if (Custom_Error_Ptr_Const r = Cast(&rhs)) {\n return message() == r->message();\n }\n return false;\n }\n\n bool Number::operator== (const Expression& rhs) const\n {\n if (auto rhsnr = Cast(&rhs)) {\n return *this == *rhsnr;\n }\n return false;\n }\n\n bool Number::operator== (const Number& rhs) const\n {\n Number l(*this), r(rhs); l.reduce(); r.reduce();\n size_t lhs_units = l.numerators.size() + l.denominators.size();\n size_t rhs_units = r.numerators.size() + r.denominators.size();\n // unitless and only having one unit seems equivalent (will change in future)\n if (!lhs_units || !rhs_units) {\n return NEAR_EQUAL(l.value(), r.value());\n }\n l.normalize(); r.normalize();\n Units &lhs_unit = l, &rhs_unit = r;\n return lhs_unit == rhs_unit &&\n NEAR_EQUAL(l.value(), r.value());\n }\n\n bool Number::operator< (const Number& rhs) const\n {\n Number l(*this), r(rhs); l.reduce(); r.reduce();\n size_t lhs_units = l.numerators.size() + l.denominators.size();\n size_t rhs_units = r.numerators.size() + r.denominators.size();\n // unitless and only having one unit seems equivalent (will change in future)\n if (!lhs_units || !rhs_units) {\n return l.value() < r.value();\n }\n l.normalize(); r.normalize();\n Units &lhs_unit = l, &rhs_unit = r;\n if (!(lhs_unit == rhs_unit)) {\n /* ToDo: do we always get usefull backtraces? */\n throw Exception::IncompatibleUnits(rhs, *this);\n }\n return lhs_unit < rhs_unit ||\n l.value() < r.value();\n }\n\n bool String_Quoted::operator== (const Expression& rhs) const\n {\n if (String_Quoted_Ptr_Const qstr = Cast(&rhs)) {\n return (value() == qstr->value());\n } else if (String_Constant_Ptr_Const cstr = Cast(&rhs)) {\n return (value() == cstr->value());\n }\n return false;\n }\n\n bool String_Constant::is_invisible() const {\n return value_.empty() && quote_mark_ == 0;\n }\n\n bool String_Constant::operator== (const Expression& rhs) const\n {\n if (String_Quoted_Ptr_Const qstr = Cast(&rhs)) {\n return (value() == qstr->value());\n } else if (String_Constant_Ptr_Const cstr = Cast(&rhs)) {\n return (value() == cstr->value());\n }\n return false;\n }\n\n bool String_Schema::is_left_interpolant(void) const\n {\n return length() && first()->is_left_interpolant();\n }\n bool String_Schema::is_right_interpolant(void) const\n {\n return length() && last()->is_right_interpolant();\n }\n\n bool String_Schema::operator== (const Expression& rhs) const\n {\n if (String_Schema_Ptr_Const r = Cast(&rhs)) {\n if (length() != r->length()) return false;\n for (size_t i = 0, L = length(); i < L; ++i) {\n Expression_Obj rv = (*r)[i];\n Expression_Obj lv = (*this)[i];\n if (!lv || !rv) return false;\n if (!(*lv == *rv)) return false;\n }\n return true;\n }\n return false;\n }\n\n bool Boolean::operator== (const Expression& rhs) const\n {\n if (Boolean_Ptr_Const r = Cast(&rhs)) {\n return (value() == r->value());\n }\n return false;\n }\n\n bool Color::operator== (const Expression& rhs) const\n {\n if (Color_Ptr_Const r = Cast(&rhs)) {\n return r_ == r->r() &&\n g_ == r->g() &&\n b_ == r->b() &&\n a_ == r->a();\n }\n return false;\n }\n\n bool List::operator== (const Expression& rhs) const\n {\n if (List_Ptr_Const r = Cast(&rhs)) {\n if (length() != r->length()) return false;\n if (separator() != r->separator()) return false;\n if (is_bracketed() != r->is_bracketed()) return false;\n for (size_t i = 0, L = length(); i < L; ++i) {\n Expression_Obj rv = r->at(i);\n Expression_Obj lv = this->at(i);\n if (!lv || !rv) return false;\n if (!(*lv == *rv)) return false;\n }\n return true;\n }\n return false;\n }\n\n bool Map::operator== (const Expression& rhs) const\n {\n if (Map_Ptr_Const r = Cast(&rhs)) {\n if (length() != r->length()) return false;\n for (auto key : keys()) {\n Expression_Obj lv = at(key);\n Expression_Obj rv = r->at(key);\n if (!rv || !lv) return false;\n if (!(*lv == *rv)) return false;\n }\n return true;\n }\n return false;\n }\n\n bool Null::operator== (const Expression& rhs) const\n {\n return rhs.concrete_type() == NULL_VAL;\n }\n\n bool Function::operator== (const Expression& rhs) const\n {\n if (Function_Ptr_Const r = Cast(&rhs)) {\n Definition_Ptr_Const d1 = Cast(definition());\n Definition_Ptr_Const d2 = Cast(r->definition());\n return d1 && d2 && d1 == d2 && is_css() == r->is_css();\n }\n return false;\n }\n\n size_t List::size() const {\n if (!is_arglist_) return length();\n // arglist expects a list of arguments\n // so we need to break before keywords\n for (size_t i = 0, L = length(); i < L; ++i) {\n Expression_Obj obj = this->at(i);\n if (Argument_Ptr arg = Cast(obj)) {\n if (!arg->name().empty()) return i;\n }\n }\n return length();\n }\n\n Expression_Obj Hashed::at(Expression_Obj k) const\n {\n if (elements_.count(k))\n { return elements_.at(k); }\n else { return NULL; }\n }\n\n bool Binary_Expression::is_left_interpolant(void) const\n {\n return is_interpolant() || (left() && left()->is_left_interpolant());\n }\n bool Binary_Expression::is_right_interpolant(void) const\n {\n return is_interpolant() || (right() && right()->is_right_interpolant());\n }\n\n const std::string AST_Node::to_string(Sass_Inspect_Options opt) const\n {\n Sass_Output_Options out(opt);\n Emitter emitter(out);\n Inspect i(emitter);\n i.in_declaration = true;\n // ToDo: inspect should be const\n const_cast(this)->perform(&i);\n return i.get_buffer();\n }\n\n const std::string AST_Node::to_string() const\n {\n return to_string({ NESTED, 5 });\n }\n\n std::string String_Quoted::inspect() const\n {\n return quote(value_, '*');\n }\n\n std::string String_Constant::inspect() const\n {\n return quote(value_, '*');\n }\n\n bool Declaration::is_invisible() const\n {\n if (is_custom_property()) return false;\n\n return !(value_ && value_->concrete_type() != Expression::NULL_VAL);\n }\n\n //////////////////////////////////////////////////////////////////////////////////////////\n // Additional method on Lists to retrieve values directly or from an encompassed Argument.\n //////////////////////////////////////////////////////////////////////////////////////////\n Expression_Obj List::value_at_index(size_t i) {\n Expression_Obj obj = this->at(i);\n if (is_arglist_) {\n if (Argument_Ptr arg = Cast(obj)) {\n return arg->value();\n } else {\n return obj;\n }\n } else {\n return obj;\n }\n }\n\n //////////////////////////////////////////////////////////////////////////////////////////\n // Convert map to (key, value) list.\n //////////////////////////////////////////////////////////////////////////////////////////\n List_Obj Map::to_list(ParserState& pstate) {\n List_Obj ret = SASS_MEMORY_NEW(List, pstate, length(), SASS_COMMA);\n\n for (auto key : keys()) {\n List_Obj l = SASS_MEMORY_NEW(List, pstate, 2);\n l->append(key);\n l->append(at(key));\n ret->append(l);\n }\n\n return ret;\n }\n\n //////////////////////////////////////////////////////////////////////////////////////////\n // Copy implementations\n //////////////////////////////////////////////////////////////////////////////////////////\n\n #ifdef DEBUG_SHARED_PTR\n\n #define IMPLEMENT_AST_OPERATORS(klass) \\\n klass##_Ptr klass::copy(std::string file, size_t line) const { \\\n klass##_Ptr cpy = new klass(this); \\\n cpy->trace(file, line); \\\n return cpy; \\\n } \\\n klass##_Ptr klass::clone(std::string file, size_t line) const { \\\n klass##_Ptr cpy = copy(file, line); \\\n cpy->cloneChildren(); \\\n return cpy; \\\n } \\\n\n #else\n\n #define IMPLEMENT_AST_OPERATORS(klass) \\\n klass##_Ptr klass::copy() const { \\\n return new klass(this); \\\n } \\\n klass##_Ptr klass::clone() const { \\\n klass##_Ptr cpy = copy(); \\\n cpy->cloneChildren(); \\\n return cpy; \\\n } \\\n\n #endif\n\n IMPLEMENT_AST_OPERATORS(Supports_Operator);\n IMPLEMENT_AST_OPERATORS(Supports_Negation);\n IMPLEMENT_AST_OPERATORS(Compound_Selector);\n IMPLEMENT_AST_OPERATORS(Complex_Selector);\n IMPLEMENT_AST_OPERATORS(Element_Selector);\n IMPLEMENT_AST_OPERATORS(Class_Selector);\n IMPLEMENT_AST_OPERATORS(Id_Selector);\n IMPLEMENT_AST_OPERATORS(Pseudo_Selector);\n IMPLEMENT_AST_OPERATORS(Wrapped_Selector);\n IMPLEMENT_AST_OPERATORS(Selector_List);\n IMPLEMENT_AST_OPERATORS(Ruleset);\n IMPLEMENT_AST_OPERATORS(Media_Block);\n IMPLEMENT_AST_OPERATORS(Custom_Warning);\n IMPLEMENT_AST_OPERATORS(Custom_Error);\n IMPLEMENT_AST_OPERATORS(List);\n IMPLEMENT_AST_OPERATORS(Map);\n IMPLEMENT_AST_OPERATORS(Function);\n IMPLEMENT_AST_OPERATORS(Number);\n IMPLEMENT_AST_OPERATORS(Binary_Expression);\n IMPLEMENT_AST_OPERATORS(String_Schema);\n IMPLEMENT_AST_OPERATORS(String_Constant);\n IMPLEMENT_AST_OPERATORS(String_Quoted);\n IMPLEMENT_AST_OPERATORS(Boolean);\n IMPLEMENT_AST_OPERATORS(Color);\n IMPLEMENT_AST_OPERATORS(Null);\n IMPLEMENT_AST_OPERATORS(Parent_Selector);\n IMPLEMENT_AST_OPERATORS(Import);\n IMPLEMENT_AST_OPERATORS(Import_Stub);\n IMPLEMENT_AST_OPERATORS(Function_Call);\n IMPLEMENT_AST_OPERATORS(Directive);\n IMPLEMENT_AST_OPERATORS(At_Root_Block);\n IMPLEMENT_AST_OPERATORS(Supports_Block);\n IMPLEMENT_AST_OPERATORS(While);\n IMPLEMENT_AST_OPERATORS(Each);\n IMPLEMENT_AST_OPERATORS(For);\n IMPLEMENT_AST_OPERATORS(If);\n IMPLEMENT_AST_OPERATORS(Mixin_Call);\n IMPLEMENT_AST_OPERATORS(Extension);\n IMPLEMENT_AST_OPERATORS(Media_Query);\n IMPLEMENT_AST_OPERATORS(Media_Query_Expression);\n IMPLEMENT_AST_OPERATORS(Debug);\n IMPLEMENT_AST_OPERATORS(Error);\n IMPLEMENT_AST_OPERATORS(Warning);\n IMPLEMENT_AST_OPERATORS(Assignment);\n IMPLEMENT_AST_OPERATORS(Return);\n IMPLEMENT_AST_OPERATORS(At_Root_Query);\n IMPLEMENT_AST_OPERATORS(Variable);\n IMPLEMENT_AST_OPERATORS(Comment);\n IMPLEMENT_AST_OPERATORS(Attribute_Selector);\n IMPLEMENT_AST_OPERATORS(Supports_Interpolation);\n IMPLEMENT_AST_OPERATORS(Supports_Declaration);\n IMPLEMENT_AST_OPERATORS(Supports_Condition);\n IMPLEMENT_AST_OPERATORS(Parameters);\n IMPLEMENT_AST_OPERATORS(Parameter);\n IMPLEMENT_AST_OPERATORS(Arguments);\n IMPLEMENT_AST_OPERATORS(Argument);\n IMPLEMENT_AST_OPERATORS(Unary_Expression);\n IMPLEMENT_AST_OPERATORS(Function_Call_Schema);\n IMPLEMENT_AST_OPERATORS(Block);\n IMPLEMENT_AST_OPERATORS(Content);\n IMPLEMENT_AST_OPERATORS(Trace);\n IMPLEMENT_AST_OPERATORS(Keyframe_Rule);\n IMPLEMENT_AST_OPERATORS(Bubble);\n IMPLEMENT_AST_OPERATORS(Selector_Schema);\n IMPLEMENT_AST_OPERATORS(Placeholder_Selector);\n IMPLEMENT_AST_OPERATORS(Definition);\n IMPLEMENT_AST_OPERATORS(Declaration);\n}\n" }, { "path": "libsass-build/ast.hpp", "content": "#ifndef SASS_AST_H\n#define SASS_AST_H\n\n#include \"sass.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"sass/base.h\"\n#include \"ast_fwd_decl.hpp\"\n\n#ifdef DEBUG_SHARED_PTR\n\n#define ATTACH_VIRTUAL_AST_OPERATIONS(klass) \\\n virtual klass##_Ptr copy(std::string, size_t) const = 0; \\\n virtual klass##_Ptr clone(std::string, size_t) const = 0; \\\n\n#define ATTACH_AST_OPERATIONS(klass) \\\n virtual klass##_Ptr copy(std::string, size_t) const; \\\n virtual klass##_Ptr clone(std::string, size_t) const; \\\n\n#else\n\n#define ATTACH_VIRTUAL_AST_OPERATIONS(klass) \\\n virtual klass##_Ptr copy() const = 0; \\\n virtual klass##_Ptr clone() const = 0; \\\n\n#define ATTACH_AST_OPERATIONS(klass) \\\n virtual klass##_Ptr copy() const; \\\n virtual klass##_Ptr clone() const; \\\n\n#endif\n\n#ifdef __clang__\n\n/*\n * There are some overloads used here that trigger the clang overload\n * hiding warning. Specifically:\n *\n * Type type() which hides string type() from Expression\n *\n */\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Woverloaded-virtual\"\n\n#endif\n\n#include \"util.hpp\"\n#include \"units.hpp\"\n#include \"context.hpp\"\n#include \"position.hpp\"\n#include \"constants.hpp\"\n#include \"operation.hpp\"\n#include \"position.hpp\"\n#include \"inspect.hpp\"\n#include \"source_map.hpp\"\n#include \"environment.hpp\"\n#include \"error_handling.hpp\"\n#include \"ast_def_macros.hpp\"\n#include \"ast_fwd_decl.hpp\"\n#include \"source_map.hpp\"\n\n#include \"sass.h\"\n\nnamespace Sass {\n\n // easier to search with name\n const bool DELAYED = true;\n\n // ToDo: should this really be hardcoded\n // Note: most methods follow precision option\n const double NUMBER_EPSILON = 0.00000000000001;\n\n // macro to test if numbers are equal within a small error margin\n #define NEAR_EQUAL(lhs, rhs) std::fabs(lhs - rhs) < NUMBER_EPSILON\n\n // ToDo: where does this fit best?\n // We don't share this with C-API?\n class Operand {\n public:\n Operand(Sass_OP operand, bool ws_before = false, bool ws_after = false)\n : operand(operand), ws_before(ws_before), ws_after(ws_after)\n { }\n public:\n enum Sass_OP operand;\n bool ws_before;\n bool ws_after;\n };\n\n //////////////////////////////////////////////////////////\n // `hash_combine` comes from boost (functional/hash):\n // http://www.boost.org/doc/libs/1_35_0/doc/html/hash/combine.html\n // Boost Software License - Version 1.0\n // http://www.boost.org/users/license.html\n template \n void hash_combine (std::size_t& seed, const T& val)\n {\n seed ^= std::hash()(val) + 0x9e3779b9\n + (seed<<6) + (seed>>2);\n }\n //////////////////////////////////////////////////////////\n\n //////////////////////////////////////////////////////////\n // Abstract base class for all abstract syntax tree nodes.\n //////////////////////////////////////////////////////////\n class AST_Node : public SharedObj {\n ADD_PROPERTY(ParserState, pstate)\n public:\n AST_Node(ParserState pstate)\n : pstate_(pstate)\n { }\n AST_Node(const AST_Node* ptr)\n : pstate_(ptr->pstate_)\n { }\n\n // AST_Node(AST_Node& ptr) = delete;\n\n virtual ~AST_Node() = 0;\n virtual size_t hash() { return 0; }\n ATTACH_VIRTUAL_AST_OPERATIONS(AST_Node);\n virtual std::string inspect() const { return to_string({ INSPECT, 5 }); }\n virtual std::string to_sass() const { return to_string({ TO_SASS, 5 }); }\n virtual const std::string to_string(Sass_Inspect_Options opt) const;\n virtual const std::string to_string() const;\n virtual void cloneChildren() {};\n // generic find function (not fully implemented yet)\n // ToDo: add specific implementions to all children\n virtual bool find ( bool (*f)(AST_Node_Obj) ) { return f(this); };\n public:\n void update_pstate(const ParserState& pstate);\n public:\n Offset off() { return pstate(); }\n Position pos() { return pstate(); }\n ATTACH_OPERATIONS()\n };\n inline AST_Node::~AST_Node() { }\n\n //////////////////////////////////////////////////////////////////////\n // define cast template now (need complete type)\n //////////////////////////////////////////////////////////////////////\n\n template\n T* Cast(AST_Node* ptr) {\n return ptr && typeid(T) == typeid(*ptr) ?\n static_cast(ptr) : NULL;\n };\n\n template\n const T* Cast(const AST_Node* ptr) {\n return ptr && typeid(T) == typeid(*ptr) ?\n static_cast(ptr) : NULL;\n };\n\n //////////////////////////////////////////////////////////////////////\n // Abstract base class for expressions. This side of the AST hierarchy\n // represents elements in value contexts, which exist primarily to be\n // evaluated and returned.\n //////////////////////////////////////////////////////////////////////\n class Expression : public AST_Node {\n public:\n enum Concrete_Type {\n NONE,\n BOOLEAN,\n NUMBER,\n COLOR,\n STRING,\n LIST,\n MAP,\n SELECTOR,\n NULL_VAL,\n FUNCTION_VAL,\n C_WARNING,\n C_ERROR,\n FUNCTION,\n VARIABLE,\n NUM_TYPES\n };\n enum Simple_Type {\n SIMPLE,\n ATTR_SEL,\n PSEUDO_SEL,\n WRAPPED_SEL,\n };\n private:\n // expressions in some contexts shouldn't be evaluated\n ADD_PROPERTY(bool, is_delayed)\n ADD_PROPERTY(bool, is_expanded)\n ADD_PROPERTY(bool, is_interpolant)\n ADD_PROPERTY(Concrete_Type, concrete_type)\n public:\n Expression(ParserState pstate,\n bool d = false, bool e = false, bool i = false, Concrete_Type ct = NONE)\n : AST_Node(pstate),\n is_delayed_(d),\n is_expanded_(e),\n is_interpolant_(i),\n concrete_type_(ct)\n { }\n Expression(const Expression* ptr)\n : AST_Node(ptr),\n is_delayed_(ptr->is_delayed_),\n is_expanded_(ptr->is_expanded_),\n is_interpolant_(ptr->is_interpolant_),\n concrete_type_(ptr->concrete_type_)\n { }\n virtual operator bool() { return true; }\n virtual ~Expression() { }\n virtual std::string type() const { return \"\"; /* TODO: raise an error? */ }\n virtual bool is_invisible() const { return false; }\n static std::string type_name() { return \"\"; }\n virtual bool is_false() { return false; }\n // virtual bool is_true() { return !is_false(); }\n virtual bool operator== (const Expression& rhs) const { return false; }\n virtual bool eq(const Expression& rhs) const { return *this == rhs; };\n virtual void set_delayed(bool delayed) { is_delayed(delayed); }\n virtual bool has_interpolant() const { return is_interpolant(); }\n virtual bool is_left_interpolant() const { return is_interpolant(); }\n virtual bool is_right_interpolant() const { return is_interpolant(); }\n virtual std::string inspect() const { return to_string({ INSPECT, 5 }); }\n virtual std::string to_sass() const { return to_string({ TO_SASS, 5 }); }\n ATTACH_VIRTUAL_AST_OPERATIONS(Expression);\n virtual size_t hash() { return 0; }\n };\n\n //////////////////////////////////////////////////////////////////////\n // Still just an expression, but with a to_string method\n //////////////////////////////////////////////////////////////////////\n class PreValue : public Expression {\n public:\n PreValue(ParserState pstate,\n bool d = false, bool e = false, bool i = false, Concrete_Type ct = NONE)\n : Expression(pstate, d, e, i, ct)\n { }\n PreValue(const PreValue* ptr)\n : Expression(ptr)\n { }\n ATTACH_VIRTUAL_AST_OPERATIONS(PreValue);\n virtual ~PreValue() { }\n };\n\n //////////////////////////////////////////////////////////////////////\n // base class for values that support operations\n //////////////////////////////////////////////////////////////////////\n class Value : public Expression {\n public:\n Value(ParserState pstate,\n bool d = false, bool e = false, bool i = false, Concrete_Type ct = NONE)\n : Expression(pstate, d, e, i, ct)\n { }\n Value(const Value* ptr)\n : Expression(ptr)\n { }\n ATTACH_VIRTUAL_AST_OPERATIONS(Value);\n virtual bool operator== (const Expression& rhs) const = 0;\n };\n}\n\n/////////////////////////////////////////////////////////////////////////////////////\n// Hash method specializations for std::unordered_map to work with Sass::Expression\n/////////////////////////////////////////////////////////////////////////////////////\n\nnamespace std {\n template<>\n struct hash\n {\n size_t operator()(Sass::Expression_Obj s) const\n {\n return s->hash();\n }\n };\n template<>\n struct equal_to\n {\n bool operator()( Sass::Expression_Obj lhs, Sass::Expression_Obj rhs) const\n {\n return lhs->hash() == rhs->hash();\n }\n };\n}\n\nnamespace Sass {\n\n /////////////////////////////////////////////////////////////////////////////\n // Mixin class for AST nodes that should behave like vectors. Uses the\n // \"Template Method\" design pattern to allow subclasses to adjust their flags\n // when certain objects are pushed.\n /////////////////////////////////////////////////////////////////////////////\n template \n class Vectorized {\n std::vector elements_;\n protected:\n size_t hash_;\n void reset_hash() { hash_ = 0; }\n virtual void adjust_after_pushing(T element) { }\n public:\n Vectorized(size_t s = 0) : elements_(std::vector()), hash_(0)\n { elements_.reserve(s); }\n virtual ~Vectorized() = 0;\n size_t length() const { return elements_.size(); }\n bool empty() const { return elements_.empty(); }\n void clear() { return elements_.clear(); }\n T last() const { return elements_.back(); }\n T first() const { return elements_.front(); }\n T& operator[](size_t i) { return elements_[i]; }\n virtual const T& at(size_t i) const { return elements_.at(i); }\n virtual T& at(size_t i) { return elements_.at(i); }\n const T& operator[](size_t i) const { return elements_[i]; }\n virtual void append(T element)\n {\n if (element) {\n reset_hash();\n elements_.push_back(element);\n adjust_after_pushing(element);\n }\n }\n virtual void concat(Vectorized* v)\n {\n for (size_t i = 0, L = v->length(); i < L; ++i) this->append((*v)[i]);\n }\n Vectorized& unshift(T element)\n {\n elements_.insert(elements_.begin(), element);\n return *this;\n }\n std::vector& elements() { return elements_; }\n const std::vector& elements() const { return elements_; }\n std::vector& elements(std::vector& e) { elements_ = e; return elements_; }\n\n virtual size_t hash()\n {\n if (hash_ == 0) {\n for (T& el : elements_) {\n hash_combine(hash_, el->hash());\n }\n }\n return hash_;\n }\n\n typename std::vector::iterator end() { return elements_.end(); }\n typename std::vector::iterator begin() { return elements_.begin(); }\n typename std::vector::const_iterator end() const { return elements_.end(); }\n typename std::vector::const_iterator begin() const { return elements_.begin(); }\n typename std::vector::iterator erase(typename std::vector::iterator el) { return elements_.erase(el); }\n typename std::vector::const_iterator erase(typename std::vector::const_iterator el) { return elements_.erase(el); }\n\n };\n template \n inline Vectorized::~Vectorized() { }\n\n /////////////////////////////////////////////////////////////////////////////\n // Mixin class for AST nodes that should behave like a hash table. Uses an\n // extra internally to maintain insertion order for interation.\n /////////////////////////////////////////////////////////////////////////////\n class Hashed {\n private:\n ExpressionMap elements_;\n std::vector list_;\n protected:\n size_t hash_;\n Expression_Obj duplicate_key_;\n void reset_hash() { hash_ = 0; }\n void reset_duplicate_key() { duplicate_key_ = 0; }\n virtual void adjust_after_pushing(std::pair p) { }\n public:\n Hashed(size_t s = 0)\n : elements_(ExpressionMap(s)),\n list_(std::vector()),\n hash_(0), duplicate_key_(NULL)\n { elements_.reserve(s); list_.reserve(s); }\n virtual ~Hashed();\n size_t length() const { return list_.size(); }\n bool empty() const { return list_.empty(); }\n bool has(Expression_Obj k) const { return elements_.count(k) == 1; }\n Expression_Obj at(Expression_Obj k) const;\n bool has_duplicate_key() const { return duplicate_key_ != 0; }\n Expression_Obj get_duplicate_key() const { return duplicate_key_; }\n const ExpressionMap elements() { return elements_; }\n Hashed& operator<<(std::pair p)\n {\n reset_hash();\n\n if (!has(p.first)) list_.push_back(p.first);\n else if (!duplicate_key_) duplicate_key_ = p.first;\n\n elements_[p.first] = p.second;\n\n adjust_after_pushing(p);\n return *this;\n }\n Hashed& operator+=(Hashed* h)\n {\n if (length() == 0) {\n this->elements_ = h->elements_;\n this->list_ = h->list_;\n return *this;\n }\n\n for (auto key : h->keys()) {\n *this << std::make_pair(key, h->at(key));\n }\n\n reset_duplicate_key();\n return *this;\n }\n const ExpressionMap& pairs() const { return elements_; }\n const std::vector& keys() const { return list_; }\n\n// std::unordered_map::iterator end() { return elements_.end(); }\n// std::unordered_map::iterator begin() { return elements_.begin(); }\n// std::unordered_map::const_iterator end() const { return elements_.end(); }\n// std::unordered_map::const_iterator begin() const { return elements_.begin(); }\n\n };\n inline Hashed::~Hashed() { }\n\n\n /////////////////////////////////////////////////////////////////////////\n // Abstract base class for statements. This side of the AST hierarchy\n // represents elements in expansion contexts, which exist primarily to be\n // rewritten and macro-expanded.\n /////////////////////////////////////////////////////////////////////////\n class Statement : public AST_Node {\n public:\n enum Statement_Type {\n NONE,\n RULESET,\n MEDIA,\n DIRECTIVE,\n SUPPORTS,\n ATROOT,\n BUBBLE,\n CONTENT,\n KEYFRAMERULE,\n DECLARATION,\n ASSIGNMENT,\n IMPORT_STUB,\n IMPORT,\n COMMENT,\n WARNING,\n RETURN,\n EXTEND,\n ERROR,\n DEBUGSTMT,\n WHILE,\n EACH,\n FOR,\n IF\n };\n private:\n ADD_PROPERTY(Statement_Type, statement_type)\n ADD_PROPERTY(size_t, tabs)\n ADD_PROPERTY(bool, group_end)\n public:\n Statement(ParserState pstate, Statement_Type st = NONE, size_t t = 0)\n : AST_Node(pstate), statement_type_(st), tabs_(t), group_end_(false)\n { }\n Statement(const Statement* ptr)\n : AST_Node(ptr),\n statement_type_(ptr->statement_type_),\n tabs_(ptr->tabs_),\n group_end_(ptr->group_end_)\n { }\n virtual ~Statement() = 0;\n // needed for rearranging nested rulesets during CSS emission\n virtual bool is_invisible() const { return false; }\n virtual bool bubbles() { return false; }\n virtual bool has_content()\n {\n return statement_type_ == CONTENT;\n }\n };\n inline Statement::~Statement() { }\n\n ////////////////////////\n // Blocks of statements.\n ////////////////////////\n class Block : public Statement, public Vectorized {\n ADD_PROPERTY(bool, is_root)\n // needed for properly formatted CSS emission\n protected:\n void adjust_after_pushing(Statement_Obj s)\n {\n }\n public:\n Block(ParserState pstate, size_t s = 0, bool r = false)\n : Statement(pstate),\n Vectorized(s),\n is_root_(r)\n { }\n Block(const Block* ptr)\n : Statement(ptr),\n Vectorized(*ptr),\n is_root_(ptr->is_root_)\n { }\n virtual bool has_content()\n {\n for (size_t i = 0, L = elements().size(); i < L; ++i) {\n if (elements()[i]->has_content()) return true;\n }\n return Statement::has_content();\n }\n ATTACH_AST_OPERATIONS(Block)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////////////////////////\n // Abstract base class for statements that contain blocks of statements.\n ////////////////////////////////////////////////////////////////////////\n class Has_Block : public Statement {\n ADD_PROPERTY(Block_Obj, block)\n public:\n Has_Block(ParserState pstate, Block_Obj b)\n : Statement(pstate), block_(b)\n { }\n Has_Block(const Has_Block* ptr)\n : Statement(ptr), block_(ptr->block_)\n { }\n virtual bool has_content()\n {\n return (block_ && block_->has_content()) || Statement::has_content();\n }\n virtual ~Has_Block() = 0;\n };\n inline Has_Block::~Has_Block() { }\n\n /////////////////////////////////////////////////////////////////////////////\n // Rulesets (i.e., sets of styles headed by a selector and containing a block\n // of style declarations.\n /////////////////////////////////////////////////////////////////////////////\n class Ruleset : public Has_Block {\n ADD_PROPERTY(Selector_List_Obj, selector)\n ADD_PROPERTY(bool, is_root);\n public:\n Ruleset(ParserState pstate, Selector_List_Obj s = 0, Block_Obj b = 0)\n : Has_Block(pstate, b), selector_(s), is_root_(false)\n { statement_type(RULESET); }\n Ruleset(const Ruleset* ptr)\n : Has_Block(ptr),\n selector_(ptr->selector_),\n is_root_(ptr->is_root_)\n { statement_type(RULESET); }\n bool is_invisible() const;\n ATTACH_AST_OPERATIONS(Ruleset)\n ATTACH_OPERATIONS()\n };\n\n /////////////////\n // Bubble.\n /////////////////\n class Bubble : public Statement {\n ADD_PROPERTY(Statement_Obj, node)\n ADD_PROPERTY(bool, group_end)\n public:\n Bubble(ParserState pstate, Statement_Obj n, Statement_Obj g = 0, size_t t = 0)\n : Statement(pstate, Statement::BUBBLE, t), node_(n), group_end_(g == 0)\n { }\n Bubble(const Bubble* ptr)\n : Statement(ptr),\n node_(ptr->node_),\n group_end_(ptr->group_end_)\n { }\n bool bubbles() { return true; }\n ATTACH_AST_OPERATIONS(Bubble)\n ATTACH_OPERATIONS()\n };\n\n /////////////////\n // Trace.\n /////////////////\n class Trace : public Has_Block {\n ADD_CONSTREF(char, type)\n ADD_CONSTREF(std::string, name)\n public:\n Trace(ParserState pstate, std::string n, Block_Obj b = 0, char type = 'm')\n : Has_Block(pstate, b), type_(type), name_(n)\n { }\n Trace(const Trace* ptr)\n : Has_Block(ptr),\n type_(ptr->type_),\n name_(ptr->name_)\n { }\n ATTACH_AST_OPERATIONS(Trace)\n ATTACH_OPERATIONS()\n };\n\n /////////////////\n // Media queries.\n /////////////////\n class Media_Block : public Has_Block {\n ADD_PROPERTY(List_Obj, media_queries)\n public:\n Media_Block(ParserState pstate, List_Obj mqs, Block_Obj b)\n : Has_Block(pstate, b), media_queries_(mqs)\n { statement_type(MEDIA); }\n Media_Block(const Media_Block* ptr)\n : Has_Block(ptr), media_queries_(ptr->media_queries_)\n { statement_type(MEDIA); }\n bool bubbles() { return true; }\n bool is_invisible() const;\n ATTACH_AST_OPERATIONS(Media_Block)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////////////////////////////////////////////////////\n // At-rules -- arbitrary directives beginning with \"@\" that may have an\n // optional statement block.\n ///////////////////////////////////////////////////////////////////////\n class Directive : public Has_Block {\n ADD_CONSTREF(std::string, keyword)\n ADD_PROPERTY(Selector_List_Obj, selector)\n ADD_PROPERTY(Expression_Obj, value)\n public:\n Directive(ParserState pstate, std::string kwd, Selector_List_Obj sel = 0, Block_Obj b = 0, Expression_Obj val = 0)\n : Has_Block(pstate, b), keyword_(kwd), selector_(sel), value_(val) // set value manually if needed\n { statement_type(DIRECTIVE); }\n Directive(const Directive* ptr)\n : Has_Block(ptr),\n keyword_(ptr->keyword_),\n selector_(ptr->selector_),\n value_(ptr->value_) // set value manually if needed\n { statement_type(DIRECTIVE); }\n bool bubbles() { return is_keyframes() || is_media(); }\n bool is_media() {\n return keyword_.compare(\"@-webkit-media\") == 0 ||\n keyword_.compare(\"@-moz-media\") == 0 ||\n keyword_.compare(\"@-o-media\") == 0 ||\n keyword_.compare(\"@media\") == 0;\n }\n bool is_keyframes() {\n return keyword_.compare(\"@-webkit-keyframes\") == 0 ||\n keyword_.compare(\"@-moz-keyframes\") == 0 ||\n keyword_.compare(\"@-o-keyframes\") == 0 ||\n keyword_.compare(\"@keyframes\") == 0;\n }\n ATTACH_AST_OPERATIONS(Directive)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////////////////////////////////////////////////////\n // Keyframe-rules -- the child blocks of \"@keyframes\" nodes.\n ///////////////////////////////////////////////////////////////////////\n class Keyframe_Rule : public Has_Block {\n // according to css spec, this should be \n // = | \n ADD_PROPERTY(Selector_List_Obj, name)\n public:\n Keyframe_Rule(ParserState pstate, Block_Obj b)\n : Has_Block(pstate, b), name_()\n { statement_type(KEYFRAMERULE); }\n Keyframe_Rule(const Keyframe_Rule* ptr)\n : Has_Block(ptr), name_(ptr->name_)\n { statement_type(KEYFRAMERULE); }\n ATTACH_AST_OPERATIONS(Keyframe_Rule)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////////////////////////\n // Declarations -- style rules consisting of a property name and values.\n ////////////////////////////////////////////////////////////////////////\n class Declaration : public Has_Block {\n ADD_PROPERTY(String_Obj, property)\n ADD_PROPERTY(Expression_Obj, value)\n ADD_PROPERTY(bool, is_important)\n ADD_PROPERTY(bool, is_custom_property)\n ADD_PROPERTY(bool, is_indented)\n public:\n Declaration(ParserState pstate,\n String_Obj prop, Expression_Obj val, bool i = false, bool c = false, Block_Obj b = 0)\n : Has_Block(pstate, b), property_(prop), value_(val), is_important_(i), is_custom_property_(c), is_indented_(false)\n { statement_type(DECLARATION); }\n Declaration(const Declaration* ptr)\n : Has_Block(ptr),\n property_(ptr->property_),\n value_(ptr->value_),\n is_important_(ptr->is_important_),\n is_custom_property_(ptr->is_custom_property_),\n is_indented_(ptr->is_indented_)\n { statement_type(DECLARATION); }\n virtual bool is_invisible() const;\n ATTACH_AST_OPERATIONS(Declaration)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////////////////\n // Assignments -- variable and value.\n /////////////////////////////////////\n class Assignment : public Statement {\n ADD_CONSTREF(std::string, variable)\n ADD_PROPERTY(Expression_Obj, value)\n ADD_PROPERTY(bool, is_default)\n ADD_PROPERTY(bool, is_global)\n public:\n Assignment(ParserState pstate,\n std::string var, Expression_Obj val,\n bool is_default = false,\n bool is_global = false)\n : Statement(pstate), variable_(var), value_(val), is_default_(is_default), is_global_(is_global)\n { statement_type(ASSIGNMENT); }\n Assignment(const Assignment* ptr)\n : Statement(ptr),\n variable_(ptr->variable_),\n value_(ptr->value_),\n is_default_(ptr->is_default_),\n is_global_(ptr->is_global_)\n { statement_type(ASSIGNMENT); }\n ATTACH_AST_OPERATIONS(Assignment)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////////////////////////////\n // Import directives. CSS and Sass import lists can be intermingled, so it's\n // necessary to store a list of each in an Import node.\n ////////////////////////////////////////////////////////////////////////////\n class Import : public Statement {\n std::vector urls_;\n std::vector incs_;\n ADD_PROPERTY(List_Obj, import_queries);\n public:\n Import(ParserState pstate)\n : Statement(pstate),\n urls_(std::vector()),\n incs_(std::vector()),\n import_queries_()\n { statement_type(IMPORT); }\n Import(const Import* ptr)\n : Statement(ptr),\n urls_(ptr->urls_),\n incs_(ptr->incs_),\n import_queries_(ptr->import_queries_)\n { statement_type(IMPORT); }\n std::vector& urls() { return urls_; }\n std::vector& incs() { return incs_; }\n ATTACH_AST_OPERATIONS(Import)\n ATTACH_OPERATIONS()\n };\n\n // not yet resolved single import\n // so far we only know requested name\n class Import_Stub : public Statement {\n Include resource_;\n public:\n std::string abs_path() { return resource_.abs_path; };\n std::string imp_path() { return resource_.imp_path; };\n Include resource() { return resource_; };\n\n Import_Stub(ParserState pstate, Include res)\n : Statement(pstate), resource_(res)\n { statement_type(IMPORT_STUB); }\n Import_Stub(const Import_Stub* ptr)\n : Statement(ptr), resource_(ptr->resource_)\n { statement_type(IMPORT_STUB); }\n ATTACH_AST_OPERATIONS(Import_Stub)\n ATTACH_OPERATIONS()\n };\n\n //////////////////////////////\n // The Sass `@warn` directive.\n //////////////////////////////\n class Warning : public Statement {\n ADD_PROPERTY(Expression_Obj, message)\n public:\n Warning(ParserState pstate, Expression_Obj msg)\n : Statement(pstate), message_(msg)\n { statement_type(WARNING); }\n Warning(const Warning* ptr)\n : Statement(ptr), message_(ptr->message_)\n { statement_type(WARNING); }\n ATTACH_AST_OPERATIONS(Warning)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////////////\n // The Sass `@error` directive.\n ///////////////////////////////\n class Error : public Statement {\n ADD_PROPERTY(Expression_Obj, message)\n public:\n Error(ParserState pstate, Expression_Obj msg)\n : Statement(pstate), message_(msg)\n { statement_type(ERROR); }\n Error(const Error* ptr)\n : Statement(ptr), message_(ptr->message_)\n { statement_type(ERROR); }\n ATTACH_AST_OPERATIONS(Error)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////////////\n // The Sass `@debug` directive.\n ///////////////////////////////\n class Debug : public Statement {\n ADD_PROPERTY(Expression_Obj, value)\n public:\n Debug(ParserState pstate, Expression_Obj val)\n : Statement(pstate), value_(val)\n { statement_type(DEBUGSTMT); }\n Debug(const Debug* ptr)\n : Statement(ptr), value_(ptr->value_)\n { statement_type(DEBUGSTMT); }\n ATTACH_AST_OPERATIONS(Debug)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////////////////////////\n // CSS comments. These may be interpolated.\n ///////////////////////////////////////////\n class Comment : public Statement {\n ADD_PROPERTY(String_Obj, text)\n ADD_PROPERTY(bool, is_important)\n public:\n Comment(ParserState pstate, String_Obj txt, bool is_important)\n : Statement(pstate), text_(txt), is_important_(is_important)\n { statement_type(COMMENT); }\n Comment(const Comment* ptr)\n : Statement(ptr),\n text_(ptr->text_),\n is_important_(ptr->is_important_)\n { statement_type(COMMENT); }\n virtual bool is_invisible() const\n { return /* is_important() == */ false; }\n ATTACH_AST_OPERATIONS(Comment)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////\n // The Sass `@if` control directive.\n ////////////////////////////////////\n class If : public Has_Block {\n ADD_PROPERTY(Expression_Obj, predicate)\n ADD_PROPERTY(Block_Obj, alternative)\n public:\n If(ParserState pstate, Expression_Obj pred, Block_Obj con, Block_Obj alt = 0)\n : Has_Block(pstate, con), predicate_(pred), alternative_(alt)\n { statement_type(IF); }\n If(const If* ptr)\n : Has_Block(ptr),\n predicate_(ptr->predicate_),\n alternative_(ptr->alternative_)\n { statement_type(IF); }\n virtual bool has_content()\n {\n return Has_Block::has_content() || (alternative_ && alternative_->has_content());\n }\n ATTACH_AST_OPERATIONS(If)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////////////////\n // The Sass `@for` control directive.\n /////////////////////////////////////\n class For : public Has_Block {\n ADD_CONSTREF(std::string, variable)\n ADD_PROPERTY(Expression_Obj, lower_bound)\n ADD_PROPERTY(Expression_Obj, upper_bound)\n ADD_PROPERTY(bool, is_inclusive)\n public:\n For(ParserState pstate,\n std::string var, Expression_Obj lo, Expression_Obj hi, Block_Obj b, bool inc)\n : Has_Block(pstate, b),\n variable_(var), lower_bound_(lo), upper_bound_(hi), is_inclusive_(inc)\n { statement_type(FOR); }\n For(const For* ptr)\n : Has_Block(ptr),\n variable_(ptr->variable_),\n lower_bound_(ptr->lower_bound_),\n upper_bound_(ptr->upper_bound_),\n is_inclusive_(ptr->is_inclusive_)\n { statement_type(FOR); }\n ATTACH_AST_OPERATIONS(For)\n ATTACH_OPERATIONS()\n };\n\n //////////////////////////////////////\n // The Sass `@each` control directive.\n //////////////////////////////////////\n class Each : public Has_Block {\n ADD_PROPERTY(std::vector, variables)\n ADD_PROPERTY(Expression_Obj, list)\n public:\n Each(ParserState pstate, std::vector vars, Expression_Obj lst, Block_Obj b)\n : Has_Block(pstate, b), variables_(vars), list_(lst)\n { statement_type(EACH); }\n Each(const Each* ptr)\n : Has_Block(ptr), variables_(ptr->variables_), list_(ptr->list_)\n { statement_type(EACH); }\n ATTACH_AST_OPERATIONS(Each)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////////////////////\n // The Sass `@while` control directive.\n ///////////////////////////////////////\n class While : public Has_Block {\n ADD_PROPERTY(Expression_Obj, predicate)\n public:\n While(ParserState pstate, Expression_Obj pred, Block_Obj b)\n : Has_Block(pstate, b), predicate_(pred)\n { statement_type(WHILE); }\n While(const While* ptr)\n : Has_Block(ptr), predicate_(ptr->predicate_)\n { statement_type(WHILE); }\n ATTACH_AST_OPERATIONS(While)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////////////////////////////////////////\n // The @return directive for use inside SassScript functions.\n /////////////////////////////////////////////////////////////\n class Return : public Statement {\n ADD_PROPERTY(Expression_Obj, value)\n public:\n Return(ParserState pstate, Expression_Obj val)\n : Statement(pstate), value_(val)\n { statement_type(RETURN); }\n Return(const Return* ptr)\n : Statement(ptr), value_(ptr->value_)\n { statement_type(RETURN); }\n ATTACH_AST_OPERATIONS(Return)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////\n // The Sass `@extend` directive.\n ////////////////////////////////\n class Extension : public Statement {\n ADD_PROPERTY(Selector_List_Obj, selector)\n public:\n Extension(ParserState pstate, Selector_List_Obj s)\n : Statement(pstate), selector_(s)\n { statement_type(EXTEND); }\n Extension(const Extension* ptr)\n : Statement(ptr), selector_(ptr->selector_)\n { statement_type(EXTEND); }\n ATTACH_AST_OPERATIONS(Extension)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////////////////////////////////////////////////////////\n // Definitions for both mixins and functions. The two cases are distinguished\n // by a type tag.\n /////////////////////////////////////////////////////////////////////////////\n struct Backtrace;\n typedef const char* Signature;\n typedef Expression_Ptr (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtraces, std::vector);\n class Definition : public Has_Block {\n public:\n enum Type { MIXIN, FUNCTION };\n ADD_CONSTREF(std::string, name)\n ADD_PROPERTY(Parameters_Obj, parameters)\n ADD_PROPERTY(Env*, environment)\n ADD_PROPERTY(Type, type)\n ADD_PROPERTY(Native_Function, native_function)\n ADD_PROPERTY(Sass_Function_Entry, c_function)\n ADD_PROPERTY(void*, cookie)\n ADD_PROPERTY(bool, is_overload_stub)\n ADD_PROPERTY(Signature, signature)\n public:\n Definition(const Definition* ptr)\n : Has_Block(ptr),\n name_(ptr->name_),\n parameters_(ptr->parameters_),\n environment_(ptr->environment_),\n type_(ptr->type_),\n native_function_(ptr->native_function_),\n c_function_(ptr->c_function_),\n cookie_(ptr->cookie_),\n is_overload_stub_(ptr->is_overload_stub_),\n signature_(ptr->signature_)\n { }\n\n Definition(ParserState pstate,\n std::string n,\n Parameters_Obj params,\n Block_Obj b,\n Type t)\n : Has_Block(pstate, b),\n name_(n),\n parameters_(params),\n environment_(0),\n type_(t),\n native_function_(0),\n c_function_(0),\n cookie_(0),\n is_overload_stub_(false),\n signature_(0)\n { }\n Definition(ParserState pstate,\n Signature sig,\n std::string n,\n Parameters_Obj params,\n Native_Function func_ptr,\n bool overload_stub = false)\n : Has_Block(pstate, 0),\n name_(n),\n parameters_(params),\n environment_(0),\n type_(FUNCTION),\n native_function_(func_ptr),\n c_function_(0),\n cookie_(0),\n is_overload_stub_(overload_stub),\n signature_(sig)\n { }\n Definition(ParserState pstate,\n Signature sig,\n std::string n,\n Parameters_Obj params,\n Sass_Function_Entry c_func,\n bool whatever,\n bool whatever2)\n : Has_Block(pstate, 0),\n name_(n),\n parameters_(params),\n environment_(0),\n type_(FUNCTION),\n native_function_(0),\n c_function_(c_func),\n cookie_(sass_function_get_cookie(c_func)),\n is_overload_stub_(false),\n signature_(sig)\n { }\n ATTACH_AST_OPERATIONS(Definition)\n ATTACH_OPERATIONS()\n };\n\n //////////////////////////////////////\n // Mixin calls (i.e., `@include ...`).\n //////////////////////////////////////\n class Mixin_Call : public Has_Block {\n ADD_CONSTREF(std::string, name)\n ADD_PROPERTY(Arguments_Obj, arguments)\n public:\n Mixin_Call(ParserState pstate, std::string n, Arguments_Obj args, Block_Obj b = 0)\n : Has_Block(pstate, b), name_(n), arguments_(args)\n { }\n Mixin_Call(const Mixin_Call* ptr)\n : Has_Block(ptr),\n name_(ptr->name_),\n arguments_(ptr->arguments_)\n { }\n ATTACH_AST_OPERATIONS(Mixin_Call)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////////////////////////////////\n // The @content directive for mixin content blocks.\n ///////////////////////////////////////////////////\n class Content : public Statement {\n ADD_PROPERTY(Media_Block_Ptr, media_block)\n public:\n Content(ParserState pstate)\n : Statement(pstate),\n media_block_(NULL)\n { statement_type(CONTENT); }\n Content(const Content* ptr)\n : Statement(ptr),\n media_block_(ptr->media_block_)\n { statement_type(CONTENT); }\n ATTACH_AST_OPERATIONS(Content)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////////////////////////////////////////////////////\n // Lists of values, both comma- and space-separated (distinguished by a\n // type-tag.) Also used to represent variable-length argument lists.\n ///////////////////////////////////////////////////////////////////////\n class List : public Value, public Vectorized {\n void adjust_after_pushing(Expression_Obj e) { is_expanded(false); }\n private:\n ADD_PROPERTY(enum Sass_Separator, separator)\n ADD_PROPERTY(bool, is_arglist)\n ADD_PROPERTY(bool, is_bracketed)\n ADD_PROPERTY(bool, from_selector)\n public:\n List(ParserState pstate,\n size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false, bool bracket = false)\n : Value(pstate),\n Vectorized(size),\n separator_(sep),\n is_arglist_(argl),\n is_bracketed_(bracket),\n from_selector_(false)\n { concrete_type(LIST); }\n List(const List* ptr)\n : Value(ptr),\n Vectorized(*ptr),\n separator_(ptr->separator_),\n is_arglist_(ptr->is_arglist_),\n is_bracketed_(ptr->is_bracketed_),\n from_selector_(ptr->from_selector_)\n { concrete_type(LIST); }\n std::string type() const { return is_arglist_ ? \"arglist\" : \"list\"; }\n static std::string type_name() { return \"list\"; }\n const char* sep_string(bool compressed = false) const {\n return separator() == SASS_SPACE ?\n \" \" : (compressed ? \",\" : \", \");\n }\n bool is_invisible() const { return empty() && !is_bracketed(); }\n Expression_Obj value_at_index(size_t i);\n\n virtual size_t size() const;\n\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_ = std::hash()(sep_string());\n hash_combine(hash_, std::hash()(is_bracketed()));\n for (size_t i = 0, L = length(); i < L; ++i)\n hash_combine(hash_, (elements()[i])->hash());\n }\n return hash_;\n }\n\n virtual void set_delayed(bool delayed)\n {\n is_delayed(delayed);\n // don't set children\n }\n\n virtual bool operator== (const Expression& rhs) const;\n\n ATTACH_AST_OPERATIONS(List)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////////////////////////////////////////////////////\n // Key value paris.\n ///////////////////////////////////////////////////////////////////////\n class Map : public Value, public Hashed {\n void adjust_after_pushing(std::pair p) { is_expanded(false); }\n public:\n Map(ParserState pstate,\n size_t size = 0)\n : Value(pstate),\n Hashed(size)\n { concrete_type(MAP); }\n Map(const Map* ptr)\n : Value(ptr),\n Hashed(*ptr)\n { concrete_type(MAP); }\n std::string type() const { return \"map\"; }\n static std::string type_name() { return \"map\"; }\n bool is_invisible() const { return empty(); }\n List_Obj to_list(ParserState& pstate);\n\n virtual size_t hash()\n {\n if (hash_ == 0) {\n for (auto key : keys()) {\n hash_combine(hash_, key->hash());\n hash_combine(hash_, at(key)->hash());\n }\n }\n\n return hash_;\n }\n\n virtual bool operator== (const Expression& rhs) const;\n\n ATTACH_AST_OPERATIONS(Map)\n ATTACH_OPERATIONS()\n };\n\n inline static const std::string sass_op_to_name(enum Sass_OP op) {\n switch (op) {\n case AND: return \"and\";\n case OR: return \"or\";\n case EQ: return \"eq\";\n case NEQ: return \"neq\";\n case GT: return \"gt\";\n case GTE: return \"gte\";\n case LT: return \"lt\";\n case LTE: return \"lte\";\n case ADD: return \"plus\";\n case SUB: return \"sub\";\n case MUL: return \"times\";\n case DIV: return \"div\";\n case MOD: return \"mod\";\n // this is only used internally!\n case NUM_OPS: return \"[OPS]\";\n default: return \"invalid\";\n }\n }\n\n inline static const std::string sass_op_separator(enum Sass_OP op) {\n switch (op) {\n case AND: return \"&&\";\n case OR: return \"||\";\n case EQ: return \"==\";\n case NEQ: return \"!=\";\n case GT: return \">\";\n case GTE: return \">=\";\n case LT: return \"<\";\n case LTE: return \"<=\";\n case ADD: return \"+\";\n case SUB: return \"-\";\n case MUL: return \"*\";\n case DIV: return \"/\";\n case MOD: return \"%\";\n // this is only used internally!\n case NUM_OPS: return \"[OPS]\";\n default: return \"invalid\";\n }\n }\n\n //////////////////////////////////////////////////////////////////////////\n // Binary expressions. Represents logical, relational, and arithmetic\n // operations. Templatized to avoid large switch statements and repetitive\n // subclassing.\n //////////////////////////////////////////////////////////////////////////\n class Binary_Expression : public PreValue {\n private:\n HASH_PROPERTY(Operand, op)\n HASH_PROPERTY(Expression_Obj, left)\n HASH_PROPERTY(Expression_Obj, right)\n size_t hash_;\n public:\n Binary_Expression(ParserState pstate,\n Operand op, Expression_Obj lhs, Expression_Obj rhs)\n : PreValue(pstate), op_(op), left_(lhs), right_(rhs), hash_(0)\n { }\n Binary_Expression(const Binary_Expression* ptr)\n : PreValue(ptr),\n op_(ptr->op_),\n left_(ptr->left_),\n right_(ptr->right_),\n hash_(ptr->hash_)\n { }\n const std::string type_name() {\n return sass_op_to_name(optype());\n }\n const std::string separator() {\n return sass_op_separator(optype());\n }\n bool is_left_interpolant(void) const;\n bool is_right_interpolant(void) const;\n bool has_interpolant() const\n {\n return is_left_interpolant() ||\n is_right_interpolant();\n }\n virtual void set_delayed(bool delayed)\n {\n right()->set_delayed(delayed);\n left()->set_delayed(delayed);\n is_delayed(delayed);\n }\n virtual bool operator==(const Expression& rhs) const\n {\n try\n {\n Binary_Expression_Ptr_Const m = Cast(&rhs);\n if (m == 0) return false;\n return type() == m->type() &&\n *left() == *m->left() &&\n *right() == *m->right();\n }\n catch (std::bad_cast&)\n {\n return false;\n }\n catch (...) { throw; }\n }\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_ = std::hash()(optype());\n hash_combine(hash_, left()->hash());\n hash_combine(hash_, right()->hash());\n }\n return hash_;\n }\n enum Sass_OP optype() const { return op_.operand; }\n ATTACH_AST_OPERATIONS(Binary_Expression)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////////////////////////////\n // Arithmetic negation (logical negation is just an ordinary function call).\n ////////////////////////////////////////////////////////////////////////////\n class Unary_Expression : public Expression {\n public:\n enum Type { PLUS, MINUS, NOT, SLASH };\n private:\n HASH_PROPERTY(Type, optype)\n HASH_PROPERTY(Expression_Obj, operand)\n size_t hash_;\n public:\n Unary_Expression(ParserState pstate, Type t, Expression_Obj o)\n : Expression(pstate), optype_(t), operand_(o), hash_(0)\n { }\n Unary_Expression(const Unary_Expression* ptr)\n : Expression(ptr),\n optype_(ptr->optype_),\n operand_(ptr->operand_),\n hash_(ptr->hash_)\n { }\n const std::string type_name() {\n switch (optype_) {\n case PLUS: return \"plus\";\n case MINUS: return \"minus\";\n case SLASH: return \"slash\";\n case NOT: return \"not\";\n default: return \"invalid\";\n }\n }\n virtual bool operator==(const Expression& rhs) const\n {\n try\n {\n Unary_Expression_Ptr_Const m = Cast(&rhs);\n if (m == 0) return false;\n return type() == m->type() &&\n *operand() == *m->operand();\n }\n catch (std::bad_cast&)\n {\n return false;\n }\n catch (...) { throw; }\n }\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_ = std::hash()(optype_);\n hash_combine(hash_, operand()->hash());\n };\n return hash_;\n }\n ATTACH_AST_OPERATIONS(Unary_Expression)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////////////\n // Individual argument objects for mixin and function calls.\n ////////////////////////////////////////////////////////////\n class Argument : public Expression {\n HASH_PROPERTY(Expression_Obj, value)\n HASH_CONSTREF(std::string, name)\n ADD_PROPERTY(bool, is_rest_argument)\n ADD_PROPERTY(bool, is_keyword_argument)\n size_t hash_;\n public:\n Argument(ParserState pstate, Expression_Obj val, std::string n = \"\", bool rest = false, bool keyword = false)\n : Expression(pstate), value_(val), name_(n), is_rest_argument_(rest), is_keyword_argument_(keyword), hash_(0)\n {\n if (!name_.empty() && is_rest_argument_) {\n coreError(\"variable-length argument may not be passed by name\", pstate_);\n }\n }\n Argument(const Argument* ptr)\n : Expression(ptr),\n value_(ptr->value_),\n name_(ptr->name_),\n is_rest_argument_(ptr->is_rest_argument_),\n is_keyword_argument_(ptr->is_keyword_argument_),\n hash_(ptr->hash_)\n {\n if (!name_.empty() && is_rest_argument_) {\n coreError(\"variable-length argument may not be passed by name\", pstate_);\n }\n }\n\n virtual void set_delayed(bool delayed);\n virtual bool operator==(const Expression& rhs) const\n {\n try\n {\n Argument_Ptr_Const m = Cast(&rhs);\n if (!(m && name() == m->name())) return false;\n return *value() == *m->value();\n }\n catch (std::bad_cast&)\n {\n return false;\n }\n catch (...) { throw; }\n }\n\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_ = std::hash()(name());\n hash_combine(hash_, value()->hash());\n }\n return hash_;\n }\n\n ATTACH_AST_OPERATIONS(Argument)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////////////////////////\n // Argument lists -- in their own class to facilitate context-sensitive\n // error checking (e.g., ensuring that all ordinal arguments precede all\n // named arguments).\n ////////////////////////////////////////////////////////////////////////\n class Arguments : public Expression, public Vectorized {\n ADD_PROPERTY(bool, has_named_arguments)\n ADD_PROPERTY(bool, has_rest_argument)\n ADD_PROPERTY(bool, has_keyword_argument)\n protected:\n void adjust_after_pushing(Argument_Obj a);\n public:\n Arguments(ParserState pstate)\n : Expression(pstate),\n Vectorized(),\n has_named_arguments_(false),\n has_rest_argument_(false),\n has_keyword_argument_(false)\n { }\n Arguments(const Arguments* ptr)\n : Expression(ptr),\n Vectorized(*ptr),\n has_named_arguments_(ptr->has_named_arguments_),\n has_rest_argument_(ptr->has_rest_argument_),\n has_keyword_argument_(ptr->has_keyword_argument_)\n { }\n\n virtual void set_delayed(bool delayed);\n\n Argument_Obj get_rest_argument();\n Argument_Obj get_keyword_argument();\n\n ATTACH_AST_OPERATIONS(Arguments)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////\n // Function reference.\n ////////////////////////////////////////////////////\n class Function : public Value {\n public:\n ADD_PROPERTY(Definition_Obj, definition)\n ADD_PROPERTY(bool, is_css)\n public:\n Function(ParserState pstate, Definition_Obj def, bool css)\n : Value(pstate), definition_(def), is_css_(css)\n { concrete_type(FUNCTION_VAL); }\n Function(const Function* ptr)\n : Value(ptr), definition_(ptr->definition_), is_css_(ptr->is_css_)\n { concrete_type(FUNCTION_VAL); }\n\n std::string type() const { return \"function\"; }\n static std::string type_name() { return \"function\"; }\n bool is_invisible() const { return true; }\n\n std::string name() {\n if (definition_) {\n return definition_->name();\n }\n return \"\";\n }\n\n virtual bool operator== (const Expression& rhs) const;\n\n ATTACH_AST_OPERATIONS(Function)\n ATTACH_OPERATIONS()\n };\n\n //////////////////\n // Function calls.\n //////////////////\n class Function_Call : public PreValue {\n HASH_CONSTREF(std::string, name)\n HASH_PROPERTY(Arguments_Obj, arguments)\n HASH_PROPERTY(Function_Obj, func)\n ADD_PROPERTY(bool, via_call)\n ADD_PROPERTY(void*, cookie)\n size_t hash_;\n public:\n Function_Call(ParserState pstate, std::string n, Arguments_Obj args, void* cookie)\n : PreValue(pstate), name_(n), arguments_(args), func_(0), via_call_(false), cookie_(cookie), hash_(0)\n { concrete_type(FUNCTION); }\n Function_Call(ParserState pstate, std::string n, Arguments_Obj args, Function_Obj func)\n : PreValue(pstate), name_(n), arguments_(args), func_(func), via_call_(false), cookie_(0), hash_(0)\n { concrete_type(FUNCTION); }\n Function_Call(ParserState pstate, std::string n, Arguments_Obj args)\n : PreValue(pstate), name_(n), arguments_(args), via_call_(false), cookie_(0), hash_(0)\n { concrete_type(FUNCTION); }\n Function_Call(const Function_Call* ptr)\n : PreValue(ptr),\n name_(ptr->name_),\n arguments_(ptr->arguments_),\n func_(ptr->func_),\n via_call_(ptr->via_call_),\n cookie_(ptr->cookie_),\n hash_(ptr->hash_)\n { concrete_type(FUNCTION); }\n\n bool is_css() {\n if (func_) return func_->is_css();\n return false;\n }\n\n virtual bool operator==(const Expression& rhs) const\n {\n try\n {\n Function_Call_Ptr_Const m = Cast(&rhs);\n if (!(m && name() == m->name())) return false;\n if (!(m && arguments()->length() == m->arguments()->length())) return false;\n for (size_t i =0, L = arguments()->length(); i < L; ++i)\n if (!(*(*arguments())[i] == *(*m->arguments())[i])) return false;\n return true;\n }\n catch (std::bad_cast&)\n {\n return false;\n }\n catch (...) { throw; }\n }\n\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_ = std::hash()(name());\n for (auto argument : arguments()->elements())\n hash_combine(hash_, argument->hash());\n }\n return hash_;\n }\n ATTACH_AST_OPERATIONS(Function_Call)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////\n // Function call schemas.\n /////////////////////////\n class Function_Call_Schema : public Expression {\n ADD_PROPERTY(String_Obj, name)\n ADD_PROPERTY(Arguments_Obj, arguments)\n public:\n Function_Call_Schema(ParserState pstate, String_Obj n, Arguments_Obj args)\n : Expression(pstate), name_(n), arguments_(args)\n { concrete_type(STRING); }\n Function_Call_Schema(const Function_Call_Schema* ptr)\n : Expression(ptr),\n name_(ptr->name_),\n arguments_(ptr->arguments_)\n { concrete_type(STRING); }\n ATTACH_AST_OPERATIONS(Function_Call_Schema)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////\n // Variable references.\n ///////////////////////\n class Variable : public PreValue {\n ADD_CONSTREF(std::string, name)\n public:\n Variable(ParserState pstate, std::string n)\n : PreValue(pstate), name_(n)\n { concrete_type(VARIABLE); }\n Variable(const Variable* ptr)\n : PreValue(ptr), name_(ptr->name_)\n { concrete_type(VARIABLE); }\n\n virtual bool operator==(const Expression& rhs) const\n {\n try\n {\n Variable_Ptr_Const e = Cast(&rhs);\n return e && name() == e->name();\n }\n catch (std::bad_cast&)\n {\n return false;\n }\n catch (...) { throw; }\n }\n\n virtual size_t hash()\n {\n return std::hash()(name());\n }\n\n ATTACH_AST_OPERATIONS(Variable)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////\n // Numbers, percentages, dimensions, and colors.\n ////////////////////////////////////////////////\n class Number : public Value, public Units {\n HASH_PROPERTY(double, value)\n ADD_PROPERTY(bool, zero)\n size_t hash_;\n public:\n Number(ParserState pstate, double val, std::string u = \"\", bool zero = true);\n\n Number(const Number* ptr)\n : Value(ptr),\n Units(ptr),\n value_(ptr->value_), zero_(ptr->zero_),\n hash_(ptr->hash_)\n { concrete_type(NUMBER); }\n\n bool zero() { return zero_; }\n std::string type() const { return \"number\"; }\n static std::string type_name() { return \"number\"; }\n\n void reduce();\n void normalize();\n\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_ = std::hash()(value_);\n for (const auto numerator : numerators)\n hash_combine(hash_, std::hash()(numerator));\n for (const auto denominator : denominators)\n hash_combine(hash_, std::hash()(denominator));\n }\n return hash_;\n }\n\n virtual bool operator< (const Number& rhs) const;\n virtual bool operator== (const Number& rhs) const;\n virtual bool operator== (const Expression& rhs) const;\n ATTACH_AST_OPERATIONS(Number)\n ATTACH_OPERATIONS()\n };\n\n //////////\n // Colors.\n //////////\n class Color : public Value {\n HASH_PROPERTY(double, r)\n HASH_PROPERTY(double, g)\n HASH_PROPERTY(double, b)\n HASH_PROPERTY(double, a)\n ADD_CONSTREF(std::string, disp)\n size_t hash_;\n public:\n Color(ParserState pstate, double r, double g, double b, double a = 1, const std::string disp = \"\")\n : Value(pstate), r_(r), g_(g), b_(b), a_(a), disp_(disp),\n hash_(0)\n { concrete_type(COLOR); }\n Color(const Color* ptr)\n : Value(ptr),\n r_(ptr->r_),\n g_(ptr->g_),\n b_(ptr->b_),\n a_(ptr->a_),\n disp_(ptr->disp_),\n hash_(ptr->hash_)\n { concrete_type(COLOR); }\n std::string type() const { return \"color\"; }\n static std::string type_name() { return \"color\"; }\n\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_ = std::hash()(a_);\n hash_combine(hash_, std::hash()(r_));\n hash_combine(hash_, std::hash()(g_));\n hash_combine(hash_, std::hash()(b_));\n }\n return hash_;\n }\n\n virtual bool operator== (const Expression& rhs) const;\n\n ATTACH_AST_OPERATIONS(Color)\n ATTACH_OPERATIONS()\n };\n\n //////////////////////////////\n // Errors from Sass_Values.\n //////////////////////////////\n class Custom_Error : public Value {\n ADD_CONSTREF(std::string, message)\n public:\n Custom_Error(ParserState pstate, std::string msg)\n : Value(pstate), message_(msg)\n { concrete_type(C_ERROR); }\n Custom_Error(const Custom_Error* ptr)\n : Value(ptr), message_(ptr->message_)\n { concrete_type(C_ERROR); }\n virtual bool operator== (const Expression& rhs) const;\n ATTACH_AST_OPERATIONS(Custom_Error)\n ATTACH_OPERATIONS()\n };\n\n //////////////////////////////\n // Warnings from Sass_Values.\n //////////////////////////////\n class Custom_Warning : public Value {\n ADD_CONSTREF(std::string, message)\n public:\n Custom_Warning(ParserState pstate, std::string msg)\n : Value(pstate), message_(msg)\n { concrete_type(C_WARNING); }\n Custom_Warning(const Custom_Warning* ptr)\n : Value(ptr), message_(ptr->message_)\n { concrete_type(C_WARNING); }\n virtual bool operator== (const Expression& rhs) const;\n ATTACH_AST_OPERATIONS(Custom_Warning)\n ATTACH_OPERATIONS()\n };\n\n ////////////\n // Booleans.\n ////////////\n class Boolean : public Value {\n HASH_PROPERTY(bool, value)\n size_t hash_;\n public:\n Boolean(ParserState pstate, bool val)\n : Value(pstate), value_(val),\n hash_(0)\n { concrete_type(BOOLEAN); }\n Boolean(const Boolean* ptr)\n : Value(ptr),\n value_(ptr->value_),\n hash_(ptr->hash_)\n { concrete_type(BOOLEAN); }\n virtual operator bool() { return value_; }\n std::string type() const { return \"bool\"; }\n static std::string type_name() { return \"bool\"; }\n virtual bool is_false() { return !value_; }\n\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_ = std::hash()(value_);\n }\n return hash_;\n }\n\n virtual bool operator== (const Expression& rhs) const;\n\n ATTACH_AST_OPERATIONS(Boolean)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////////////////////////\n // Abstract base class for Sass string values. Includes interpolated and\n // \"flat\" strings.\n ////////////////////////////////////////////////////////////////////////\n class String : public Value {\n public:\n String(ParserState pstate, bool delayed = false)\n : Value(pstate, delayed)\n { concrete_type(STRING); }\n String(const String* ptr)\n : Value(ptr)\n { concrete_type(STRING); }\n static std::string type_name() { return \"string\"; }\n virtual ~String() = 0;\n virtual void rtrim() = 0;\n virtual bool operator==(const Expression& rhs) const = 0;\n virtual bool operator<(const Expression& rhs) const {\n return this->to_string() < rhs.to_string();\n };\n ATTACH_VIRTUAL_AST_OPERATIONS(String);\n ATTACH_OPERATIONS()\n };\n inline String::~String() { };\n\n ///////////////////////////////////////////////////////////////////////\n // Interpolated strings. Meant to be reduced to flat strings during the\n // evaluation phase.\n ///////////////////////////////////////////////////////////////////////\n class String_Schema : public String, public Vectorized {\n ADD_PROPERTY(bool, css)\n size_t hash_;\n public:\n String_Schema(ParserState pstate, size_t size = 0, bool css = true)\n : String(pstate), Vectorized(size), css_(css), hash_(0)\n { concrete_type(STRING); }\n String_Schema(const String_Schema* ptr)\n : String(ptr),\n Vectorized(*ptr),\n css_(ptr->css_),\n hash_(ptr->hash_)\n { concrete_type(STRING); }\n\n std::string type() const { return \"string\"; }\n static std::string type_name() { return \"string\"; }\n\n bool is_left_interpolant(void) const;\n bool is_right_interpolant(void) const;\n // void has_interpolants(bool tc) { }\n bool has_interpolants() {\n for (auto el : elements()) {\n if (el->is_interpolant()) return true;\n }\n return false;\n }\n virtual void rtrim();\n\n virtual size_t hash()\n {\n if (hash_ == 0) {\n for (auto string : elements())\n hash_combine(hash_, string->hash());\n }\n return hash_;\n }\n\n virtual void set_delayed(bool delayed) {\n is_delayed(delayed);\n }\n\n virtual bool operator==(const Expression& rhs) const;\n ATTACH_AST_OPERATIONS(String_Schema)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////////\n // Flat strings -- the lowest level of raw textual data.\n ////////////////////////////////////////////////////////\n class String_Constant : public String {\n ADD_PROPERTY(char, quote_mark)\n ADD_PROPERTY(bool, can_compress_whitespace)\n HASH_CONSTREF(std::string, value)\n protected:\n size_t hash_;\n public:\n String_Constant(const String_Constant* ptr)\n : String(ptr),\n quote_mark_(ptr->quote_mark_),\n can_compress_whitespace_(ptr->can_compress_whitespace_),\n value_(ptr->value_),\n hash_(ptr->hash_)\n { }\n String_Constant(ParserState pstate, std::string val, bool css = true)\n : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(val, css)), hash_(0)\n { }\n String_Constant(ParserState pstate, const char* beg, bool css = true)\n : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(std::string(beg), css)), hash_(0)\n { }\n String_Constant(ParserState pstate, const char* beg, const char* end, bool css = true)\n : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(std::string(beg, end-beg), css)), hash_(0)\n { }\n String_Constant(ParserState pstate, const Token& tok, bool css = true)\n : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(std::string(tok.begin, tok.end), css)), hash_(0)\n { }\n std::string type() const { return \"string\"; }\n static std::string type_name() { return \"string\"; }\n virtual bool is_invisible() const;\n virtual void rtrim();\n\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_ = std::hash()(value_);\n }\n return hash_;\n }\n\n virtual bool operator==(const Expression& rhs) const;\n virtual std::string inspect() const; // quotes are forced on inspection\n\n // static char auto_quote() { return '*'; }\n static char double_quote() { return '\"'; }\n static char single_quote() { return '\\''; }\n\n ATTACH_AST_OPERATIONS(String_Constant)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////////\n // Possibly quoted string (unquote on instantiation)\n ////////////////////////////////////////////////////////\n class String_Quoted : public String_Constant {\n public:\n String_Quoted(ParserState pstate, std::string val, char q = 0,\n bool keep_utf8_escapes = false, bool skip_unquoting = false,\n bool strict_unquoting = true, bool css = true)\n : String_Constant(pstate, val, css)\n {\n if (skip_unquoting == false) {\n value_ = unquote(value_, "e_mark_, keep_utf8_escapes, strict_unquoting);\n }\n if (q && quote_mark_) quote_mark_ = q;\n }\n String_Quoted(const String_Quoted* ptr)\n : String_Constant(ptr)\n { }\n virtual bool operator==(const Expression& rhs) const;\n virtual std::string inspect() const; // quotes are forced on inspection\n ATTACH_AST_OPERATIONS(String_Quoted)\n ATTACH_OPERATIONS()\n };\n\n /////////////////\n // Media queries.\n /////////////////\n class Media_Query : public Expression,\n public Vectorized {\n ADD_PROPERTY(String_Obj, media_type)\n ADD_PROPERTY(bool, is_negated)\n ADD_PROPERTY(bool, is_restricted)\n public:\n Media_Query(ParserState pstate,\n String_Obj t = 0, size_t s = 0, bool n = false, bool r = false)\n : Expression(pstate), Vectorized(s),\n media_type_(t), is_negated_(n), is_restricted_(r)\n { }\n Media_Query(const Media_Query* ptr)\n : Expression(ptr),\n Vectorized(*ptr),\n media_type_(ptr->media_type_),\n is_negated_(ptr->is_negated_),\n is_restricted_(ptr->is_restricted_)\n { }\n ATTACH_AST_OPERATIONS(Media_Query)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////\n // Media expressions (for use inside media queries).\n ////////////////////////////////////////////////////\n class Media_Query_Expression : public Expression {\n ADD_PROPERTY(Expression_Obj, feature)\n ADD_PROPERTY(Expression_Obj, value)\n ADD_PROPERTY(bool, is_interpolated)\n public:\n Media_Query_Expression(ParserState pstate,\n Expression_Obj f, Expression_Obj v, bool i = false)\n : Expression(pstate), feature_(f), value_(v), is_interpolated_(i)\n { }\n Media_Query_Expression(const Media_Query_Expression* ptr)\n : Expression(ptr),\n feature_(ptr->feature_),\n value_(ptr->value_),\n is_interpolated_(ptr->is_interpolated_)\n { }\n ATTACH_AST_OPERATIONS(Media_Query_Expression)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////\n // `@supports` rule.\n ////////////////////\n class Supports_Block : public Has_Block {\n ADD_PROPERTY(Supports_Condition_Obj, condition)\n public:\n Supports_Block(ParserState pstate, Supports_Condition_Obj condition, Block_Obj block = 0)\n : Has_Block(pstate, block), condition_(condition)\n { statement_type(SUPPORTS); }\n Supports_Block(const Supports_Block* ptr)\n : Has_Block(ptr), condition_(ptr->condition_)\n { statement_type(SUPPORTS); }\n bool bubbles() { return true; }\n ATTACH_AST_OPERATIONS(Supports_Block)\n ATTACH_OPERATIONS()\n };\n\n //////////////////////////////////////////////////////\n // The abstract superclass of all Supports conditions.\n //////////////////////////////////////////////////////\n class Supports_Condition : public Expression {\n public:\n Supports_Condition(ParserState pstate)\n : Expression(pstate)\n { }\n Supports_Condition(const Supports_Condition* ptr)\n : Expression(ptr)\n { }\n virtual bool needs_parens(Supports_Condition_Obj cond) const { return false; }\n ATTACH_AST_OPERATIONS(Supports_Condition)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////////////\n // An operator condition (e.g. `CONDITION1 and CONDITION2`).\n ////////////////////////////////////////////////////////////\n class Supports_Operator : public Supports_Condition {\n public:\n enum Operand { AND, OR };\n private:\n ADD_PROPERTY(Supports_Condition_Obj, left);\n ADD_PROPERTY(Supports_Condition_Obj, right);\n ADD_PROPERTY(Operand, operand);\n public:\n Supports_Operator(ParserState pstate, Supports_Condition_Obj l, Supports_Condition_Obj r, Operand o)\n : Supports_Condition(pstate), left_(l), right_(r), operand_(o)\n { }\n Supports_Operator(const Supports_Operator* ptr)\n : Supports_Condition(ptr),\n left_(ptr->left_),\n right_(ptr->right_),\n operand_(ptr->operand_)\n { }\n virtual bool needs_parens(Supports_Condition_Obj cond) const;\n ATTACH_AST_OPERATIONS(Supports_Operator)\n ATTACH_OPERATIONS()\n };\n\n //////////////////////////////////////////\n // A negation condition (`not CONDITION`).\n //////////////////////////////////////////\n class Supports_Negation : public Supports_Condition {\n private:\n ADD_PROPERTY(Supports_Condition_Obj, condition);\n public:\n Supports_Negation(ParserState pstate, Supports_Condition_Obj c)\n : Supports_Condition(pstate), condition_(c)\n { }\n Supports_Negation(const Supports_Negation* ptr)\n : Supports_Condition(ptr), condition_(ptr->condition_)\n { }\n virtual bool needs_parens(Supports_Condition_Obj cond) const;\n ATTACH_AST_OPERATIONS(Supports_Negation)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////////////////////////////////\n // A declaration condition (e.g. `(feature: value)`).\n /////////////////////////////////////////////////////\n class Supports_Declaration : public Supports_Condition {\n private:\n ADD_PROPERTY(Expression_Obj, feature);\n ADD_PROPERTY(Expression_Obj, value);\n public:\n Supports_Declaration(ParserState pstate, Expression_Obj f, Expression_Obj v)\n : Supports_Condition(pstate), feature_(f), value_(v)\n { }\n Supports_Declaration(const Supports_Declaration* ptr)\n : Supports_Condition(ptr),\n feature_(ptr->feature_),\n value_(ptr->value_)\n { }\n virtual bool needs_parens(Supports_Condition_Obj cond) const { return false; }\n ATTACH_AST_OPERATIONS(Supports_Declaration)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////////////////////////////\n // An interpolation condition (e.g. `#{$var}`).\n ///////////////////////////////////////////////\n class Supports_Interpolation : public Supports_Condition {\n private:\n ADD_PROPERTY(Expression_Obj, value);\n public:\n Supports_Interpolation(ParserState pstate, Expression_Obj v)\n : Supports_Condition(pstate), value_(v)\n { }\n Supports_Interpolation(const Supports_Interpolation* ptr)\n : Supports_Condition(ptr),\n value_(ptr->value_)\n { }\n virtual bool needs_parens(Supports_Condition_Obj cond) const { return false; }\n ATTACH_AST_OPERATIONS(Supports_Interpolation)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////////////////////////////\n // At root expressions (for use inside @at-root).\n /////////////////////////////////////////////////\n class At_Root_Query : public Expression {\n private:\n ADD_PROPERTY(Expression_Obj, feature)\n ADD_PROPERTY(Expression_Obj, value)\n public:\n At_Root_Query(ParserState pstate, Expression_Obj f = 0, Expression_Obj v = 0, bool i = false)\n : Expression(pstate), feature_(f), value_(v)\n { }\n At_Root_Query(const At_Root_Query* ptr)\n : Expression(ptr),\n feature_(ptr->feature_),\n value_(ptr->value_)\n { }\n bool exclude(std::string str);\n ATTACH_AST_OPERATIONS(At_Root_Query)\n ATTACH_OPERATIONS()\n };\n\n ///////////\n // At-root.\n ///////////\n class At_Root_Block : public Has_Block {\n ADD_PROPERTY(At_Root_Query_Obj, expression)\n public:\n At_Root_Block(ParserState pstate, Block_Obj b = 0, At_Root_Query_Obj e = 0)\n : Has_Block(pstate, b), expression_(e)\n { statement_type(ATROOT); }\n At_Root_Block(const At_Root_Block* ptr)\n : Has_Block(ptr), expression_(ptr->expression_)\n { statement_type(ATROOT); }\n bool bubbles() { return true; }\n bool exclude_node(Statement_Obj s) {\n if (expression() == 0)\n {\n return s->statement_type() == Statement::RULESET;\n }\n\n if (s->statement_type() == Statement::DIRECTIVE)\n {\n if (Directive_Obj dir = Cast(s))\n {\n std::string keyword(dir->keyword());\n if (keyword.length() > 0) keyword.erase(0, 1);\n return expression()->exclude(keyword);\n }\n }\n if (s->statement_type() == Statement::MEDIA)\n {\n return expression()->exclude(\"media\");\n }\n if (s->statement_type() == Statement::RULESET)\n {\n return expression()->exclude(\"rule\");\n }\n if (s->statement_type() == Statement::SUPPORTS)\n {\n return expression()->exclude(\"supports\");\n }\n if (Directive_Obj dir = Cast(s))\n {\n if (dir->is_keyframes()) return expression()->exclude(\"keyframes\");\n }\n return false;\n }\n ATTACH_AST_OPERATIONS(At_Root_Block)\n ATTACH_OPERATIONS()\n };\n\n //////////////////\n // The null value.\n //////////////////\n class Null : public Value {\n public:\n Null(ParserState pstate) : Value(pstate) { concrete_type(NULL_VAL); }\n Null(const Null* ptr) : Value(ptr) { concrete_type(NULL_VAL); }\n std::string type() const { return \"null\"; }\n static std::string type_name() { return \"null\"; }\n bool is_invisible() const { return true; }\n operator bool() { return false; }\n bool is_false() { return true; }\n\n virtual size_t hash()\n {\n return -1;\n }\n\n virtual bool operator== (const Expression& rhs) const;\n\n ATTACH_AST_OPERATIONS(Null)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////////////\n // Thunks for delayed evaluation.\n /////////////////////////////////\n class Thunk : public Expression {\n ADD_PROPERTY(Expression_Obj, expression)\n ADD_PROPERTY(Env*, environment)\n public:\n Thunk(ParserState pstate, Expression_Obj exp, Env* env = 0)\n : Expression(pstate), expression_(exp), environment_(env)\n { }\n };\n\n /////////////////////////////////////////////////////////\n // Individual parameter objects for mixins and functions.\n /////////////////////////////////////////////////////////\n class Parameter : public AST_Node {\n ADD_CONSTREF(std::string, name)\n ADD_PROPERTY(Expression_Obj, default_value)\n ADD_PROPERTY(bool, is_rest_parameter)\n public:\n Parameter(ParserState pstate,\n std::string n, Expression_Obj def = 0, bool rest = false)\n : AST_Node(pstate), name_(n), default_value_(def), is_rest_parameter_(rest)\n {\n // tried to come up with a spec test for this, but it does no longer\n // get past the parser (it error out earlier). A spec test was added!\n // if (default_value_ && is_rest_parameter_) {\n // error(\"variable-length parameter may not have a default value\", pstate_);\n // }\n }\n Parameter(const Parameter* ptr)\n : AST_Node(ptr),\n name_(ptr->name_),\n default_value_(ptr->default_value_),\n is_rest_parameter_(ptr->is_rest_parameter_)\n {\n // tried to come up with a spec test for this, but it does no longer\n // get past the parser (it error out earlier). A spec test was added!\n // if (default_value_ && is_rest_parameter_) {\n // error(\"variable-length parameter may not have a default value\", pstate_);\n // }\n }\n ATTACH_AST_OPERATIONS(Parameter)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////////////////////////////////////////////////////\n // Parameter lists -- in their own class to facilitate context-sensitive\n // error checking (e.g., ensuring that all optional parameters follow all\n // required parameters).\n /////////////////////////////////////////////////////////////////////////\n class Parameters : public AST_Node, public Vectorized {\n ADD_PROPERTY(bool, has_optional_parameters)\n ADD_PROPERTY(bool, has_rest_parameter)\n protected:\n void adjust_after_pushing(Parameter_Obj p)\n {\n if (p->default_value()) {\n if (has_rest_parameter()) {\n coreError(\"optional parameters may not be combined with variable-length parameters\", p->pstate());\n }\n has_optional_parameters(true);\n }\n else if (p->is_rest_parameter()) {\n if (has_rest_parameter()) {\n coreError(\"functions and mixins cannot have more than one variable-length parameter\", p->pstate());\n }\n has_rest_parameter(true);\n }\n else {\n if (has_rest_parameter()) {\n coreError(\"required parameters must precede variable-length parameters\", p->pstate());\n }\n if (has_optional_parameters()) {\n coreError(\"required parameters must precede optional parameters\", p->pstate());\n }\n }\n }\n public:\n Parameters(ParserState pstate)\n : AST_Node(pstate),\n Vectorized(),\n has_optional_parameters_(false),\n has_rest_parameter_(false)\n { }\n Parameters(const Parameters* ptr)\n : AST_Node(ptr),\n Vectorized(*ptr),\n has_optional_parameters_(ptr->has_optional_parameters_),\n has_rest_parameter_(ptr->has_rest_parameter_)\n { }\n ATTACH_AST_OPERATIONS(Parameters)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////////////////////\n // Abstract base class for CSS selectors.\n /////////////////////////////////////////\n class Selector : public Expression {\n // ADD_PROPERTY(bool, has_reference)\n // line break before list separator\n ADD_PROPERTY(bool, has_line_feed)\n // line break after list separator\n ADD_PROPERTY(bool, has_line_break)\n // maybe we have optional flag\n ADD_PROPERTY(bool, is_optional)\n // parent block pointers\n\n // must not be a reference counted object\n // otherwise we create circular references\n ADD_PROPERTY(Media_Block_Ptr, media_block)\n protected:\n size_t hash_;\n public:\n Selector(ParserState pstate)\n : Expression(pstate),\n has_line_feed_(false),\n has_line_break_(false),\n is_optional_(false),\n media_block_(0),\n hash_(0)\n { concrete_type(SELECTOR); }\n Selector(const Selector* ptr)\n : Expression(ptr),\n // has_reference_(ptr->has_reference_),\n has_line_feed_(ptr->has_line_feed_),\n has_line_break_(ptr->has_line_break_),\n is_optional_(ptr->is_optional_),\n media_block_(ptr->media_block_),\n hash_(ptr->hash_)\n { concrete_type(SELECTOR); }\n virtual ~Selector() = 0;\n virtual size_t hash() = 0;\n virtual unsigned long specificity() const = 0;\n virtual void set_media_block(Media_Block_Ptr mb) {\n media_block(mb);\n }\n virtual bool has_parent_ref() const {\n return false;\n }\n virtual bool has_real_parent_ref() const {\n return false;\n }\n // dispatch to correct handlers\n virtual bool operator<(const Selector& rhs) const = 0;\n virtual bool operator==(const Selector& rhs) const = 0;\n ATTACH_VIRTUAL_AST_OPERATIONS(Selector);\n };\n inline Selector::~Selector() { }\n\n /////////////////////////////////////////////////////////////////////////\n // Interpolated selectors -- the interpolated String will be expanded and\n // re-parsed into a normal selector class.\n /////////////////////////////////////////////////////////////////////////\n class Selector_Schema : public AST_Node {\n ADD_PROPERTY(String_Obj, contents)\n ADD_PROPERTY(bool, connect_parent);\n // must not be a reference counted object\n // otherwise we create circular references\n ADD_PROPERTY(Media_Block_Ptr, media_block)\n // store computed hash\n size_t hash_;\n public:\n Selector_Schema(ParserState pstate, String_Obj c)\n : AST_Node(pstate),\n contents_(c),\n connect_parent_(true),\n media_block_(NULL),\n hash_(0)\n { }\n Selector_Schema(const Selector_Schema* ptr)\n : AST_Node(ptr),\n contents_(ptr->contents_),\n connect_parent_(ptr->connect_parent_),\n media_block_(ptr->media_block_),\n hash_(ptr->hash_)\n { }\n virtual bool has_parent_ref() const;\n virtual bool has_real_parent_ref() const;\n virtual bool operator<(const Selector& rhs) const;\n virtual bool operator==(const Selector& rhs) const;\n // selector schema is not yet a final selector, so we do not\n // have a specificity for it yet. We need to\n virtual unsigned long specificity() const { return 0; }\n virtual size_t hash() {\n if (hash_ == 0) {\n hash_combine(hash_, contents_->hash());\n }\n return hash_;\n }\n ATTACH_AST_OPERATIONS(Selector_Schema)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////\n // Abstract base class for simple selectors.\n ////////////////////////////////////////////\n class Simple_Selector : public Selector {\n ADD_CONSTREF(std::string, ns)\n ADD_CONSTREF(std::string, name)\n ADD_PROPERTY(Simple_Type, simple_type)\n ADD_PROPERTY(bool, has_ns)\n public:\n Simple_Selector(ParserState pstate, std::string n = \"\")\n : Selector(pstate), ns_(\"\"), name_(n), has_ns_(false)\n {\n simple_type(SIMPLE);\n size_t pos = n.find('|');\n // found some namespace\n if (pos != std::string::npos) {\n has_ns_ = true;\n ns_ = n.substr(0, pos);\n name_ = n.substr(pos + 1);\n }\n }\n Simple_Selector(const Simple_Selector* ptr)\n : Selector(ptr),\n ns_(ptr->ns_),\n name_(ptr->name_),\n has_ns_(ptr->has_ns_)\n { simple_type(SIMPLE); }\n virtual std::string ns_name() const\n {\n std::string name(\"\");\n if (has_ns_)\n name += ns_ + \"|\";\n return name + name_;\n }\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_combine(hash_, std::hash()(SELECTOR));\n hash_combine(hash_, std::hash()(ns()));\n hash_combine(hash_, std::hash()(name()));\n }\n return hash_;\n }\n // namespace compare functions\n bool is_ns_eq(const Simple_Selector& r) const;\n // namespace query functions\n bool is_universal_ns() const\n {\n return has_ns_ && ns_ == \"*\";\n }\n bool has_universal_ns() const\n {\n return !has_ns_ || ns_ == \"*\";\n }\n bool is_empty_ns() const\n {\n return !has_ns_ || ns_ == \"\";\n }\n bool has_empty_ns() const\n {\n return has_ns_ && ns_ == \"\";\n }\n bool has_qualified_ns() const\n {\n return has_ns_ && ns_ != \"\" && ns_ != \"*\";\n }\n // name query functions\n bool is_universal() const\n {\n return name_ == \"*\";\n }\n\n virtual bool has_placeholder() {\n return false;\n }\n\n virtual ~Simple_Selector() = 0;\n virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr);\n virtual bool has_parent_ref() const { return false; };\n virtual bool has_real_parent_ref() const { return false; };\n virtual bool is_pseudo_element() const { return false; }\n\n virtual bool is_superselector_of(Compound_Selector_Obj sub) { return false; }\n\n virtual bool operator==(const Selector& rhs) const;\n virtual bool operator==(const Simple_Selector& rhs) const;\n inline bool operator!=(const Simple_Selector& rhs) const { return !(*this == rhs); }\n\n bool operator<(const Selector& rhs) const;\n bool operator<(const Simple_Selector& rhs) const;\n // default implementation should work for most of the simple selectors (otherwise overload)\n ATTACH_VIRTUAL_AST_OPERATIONS(Simple_Selector);\n ATTACH_OPERATIONS();\n };\n inline Simple_Selector::~Simple_Selector() { }\n\n\n //////////////////////////////////\n // The Parent Selector Expression.\n //////////////////////////////////\n // parent selectors can occur in selectors but also\n // inside strings in declarations (Compound_Selector).\n // only one simple parent selector means the first case.\n class Parent_Selector : public Simple_Selector {\n ADD_PROPERTY(bool, real)\n public:\n Parent_Selector(ParserState pstate, bool r = true)\n : Simple_Selector(pstate, \"&\"), real_(r)\n { /* has_reference(true); */ }\n Parent_Selector(const Parent_Selector* ptr)\n : Simple_Selector(ptr), real_(ptr->real_)\n { /* has_reference(true); */ }\n bool is_real_parent_ref() const { return real(); };\n virtual bool has_parent_ref() const { return true; };\n virtual bool has_real_parent_ref() const { return is_real_parent_ref(); };\n virtual unsigned long specificity() const\n {\n return 0;\n }\n std::string type() const { return \"selector\"; }\n static std::string type_name() { return \"selector\"; }\n ATTACH_AST_OPERATIONS(Parent_Selector)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////////////////////////////////////////////////////\n // Placeholder selectors (e.g., \"%foo\") for use in extend-only selectors.\n /////////////////////////////////////////////////////////////////////////\n class Placeholder_Selector : public Simple_Selector {\n public:\n Placeholder_Selector(ParserState pstate, std::string n)\n : Simple_Selector(pstate, n)\n { }\n Placeholder_Selector(const Placeholder_Selector* ptr)\n : Simple_Selector(ptr)\n { }\n virtual unsigned long specificity() const\n {\n return Constants::Specificity_Base;\n }\n virtual bool has_placeholder() {\n return true;\n }\n virtual ~Placeholder_Selector() {};\n ATTACH_AST_OPERATIONS(Placeholder_Selector)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////////////////////////////////////////////////\n // Element selectors (and the universal selector) -- e.g., div, span, *.\n /////////////////////////////////////////////////////////////////////\n class Element_Selector : public Simple_Selector {\n public:\n Element_Selector(ParserState pstate, std::string n)\n : Simple_Selector(pstate, n)\n { }\n Element_Selector(const Element_Selector* ptr)\n : Simple_Selector(ptr)\n { }\n virtual unsigned long specificity() const\n {\n if (name() == \"*\") return 0;\n else return Constants::Specificity_Element;\n }\n virtual Simple_Selector_Ptr unify_with(Simple_Selector_Ptr);\n virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr);\n virtual bool operator==(const Simple_Selector& rhs) const;\n virtual bool operator==(const Element_Selector& rhs) const;\n virtual bool operator<(const Simple_Selector& rhs) const;\n virtual bool operator<(const Element_Selector& rhs) const;\n ATTACH_AST_OPERATIONS(Element_Selector)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////\n // Class selectors -- i.e., .foo.\n ////////////////////////////////////////////////\n class Class_Selector : public Simple_Selector {\n public:\n Class_Selector(ParserState pstate, std::string n)\n : Simple_Selector(pstate, n)\n { }\n Class_Selector(const Class_Selector* ptr)\n : Simple_Selector(ptr)\n { }\n virtual unsigned long specificity() const\n {\n return Constants::Specificity_Class;\n }\n virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr);\n ATTACH_AST_OPERATIONS(Class_Selector)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////\n // ID selectors -- i.e., #foo.\n ////////////////////////////////////////////////\n class Id_Selector : public Simple_Selector {\n public:\n Id_Selector(ParserState pstate, std::string n)\n : Simple_Selector(pstate, n)\n { }\n Id_Selector(const Id_Selector* ptr)\n : Simple_Selector(ptr)\n { }\n virtual unsigned long specificity() const\n {\n return Constants::Specificity_ID;\n }\n virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr);\n ATTACH_AST_OPERATIONS(Id_Selector)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////////////////////////////////\n // Attribute selectors -- e.g., [src*=\".jpg\"], etc.\n ///////////////////////////////////////////////////\n class Attribute_Selector : public Simple_Selector {\n ADD_CONSTREF(std::string, matcher)\n // this cannot be changed to obj atm!!!!!!????!!!!!!!\n ADD_PROPERTY(String_Obj, value) // might be interpolated\n ADD_PROPERTY(char, modifier);\n public:\n Attribute_Selector(ParserState pstate, std::string n, std::string m, String_Obj v, char o = 0)\n : Simple_Selector(pstate, n), matcher_(m), value_(v), modifier_(o)\n { simple_type(ATTR_SEL); }\n Attribute_Selector(const Attribute_Selector* ptr)\n : Simple_Selector(ptr),\n matcher_(ptr->matcher_),\n value_(ptr->value_),\n modifier_(ptr->modifier_)\n { simple_type(ATTR_SEL); }\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_combine(hash_, Simple_Selector::hash());\n hash_combine(hash_, std::hash()(matcher()));\n if (value_) hash_combine(hash_, value_->hash());\n }\n return hash_;\n }\n virtual unsigned long specificity() const\n {\n return Constants::Specificity_Attr;\n }\n virtual bool operator==(const Simple_Selector& rhs) const;\n virtual bool operator==(const Attribute_Selector& rhs) const;\n virtual bool operator<(const Simple_Selector& rhs) const;\n virtual bool operator<(const Attribute_Selector& rhs) const;\n ATTACH_AST_OPERATIONS(Attribute_Selector)\n ATTACH_OPERATIONS()\n };\n\n //////////////////////////////////////////////////////////////////\n // Pseudo selectors -- e.g., :first-child, :nth-of-type(...), etc.\n //////////////////////////////////////////////////////////////////\n /* '::' starts a pseudo-element, ':' a pseudo-class */\n /* Except :first-line, :first-letter, :before and :after */\n /* Note that pseudo-elements are restricted to one per selector */\n /* and occur only in the last simple_selector_sequence. */\n inline bool is_pseudo_class_element(const std::string& name)\n {\n return name == \":before\" ||\n name == \":after\" ||\n name == \":first-line\" ||\n name == \":first-letter\";\n }\n\n // Pseudo Selector cannot have any namespace?\n class Pseudo_Selector : public Simple_Selector {\n ADD_PROPERTY(String_Obj, expression)\n public:\n Pseudo_Selector(ParserState pstate, std::string n, String_Obj expr = 0)\n : Simple_Selector(pstate, n), expression_(expr)\n { simple_type(PSEUDO_SEL); }\n Pseudo_Selector(const Pseudo_Selector* ptr)\n : Simple_Selector(ptr), expression_(ptr->expression_)\n { simple_type(PSEUDO_SEL); }\n\n // A pseudo-element is made of two colons (::) followed by the name.\n // The `::` notation is introduced by the current document in order to\n // establish a discrimination between pseudo-classes and pseudo-elements.\n // For compatibility with existing style sheets, user agents must also\n // accept the previous one-colon notation for pseudo-elements introduced\n // in CSS levels 1 and 2 (namely, :first-line, :first-letter, :before and\n // :after). This compatibility is not allowed for the new pseudo-elements\n // introduced in this specification.\n virtual bool is_pseudo_element() const\n {\n return (name_[0] == ':' && name_[1] == ':')\n || is_pseudo_class_element(name_);\n }\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_combine(hash_, Simple_Selector::hash());\n if (expression_) hash_combine(hash_, expression_->hash());\n }\n return hash_;\n }\n virtual unsigned long specificity() const\n {\n if (is_pseudo_element())\n return Constants::Specificity_Element;\n return Constants::Specificity_Pseudo;\n }\n virtual bool operator==(const Simple_Selector& rhs) const;\n virtual bool operator==(const Pseudo_Selector& rhs) const;\n virtual bool operator<(const Simple_Selector& rhs) const;\n virtual bool operator<(const Pseudo_Selector& rhs) const;\n virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr);\n ATTACH_AST_OPERATIONS(Pseudo_Selector)\n ATTACH_OPERATIONS()\n };\n\n /////////////////////////////////////////////////\n // Wrapped selector -- pseudo selector that takes a list of selectors as argument(s) e.g., :not(:first-of-type), :-moz-any(ol p.blah, ul, menu, dir)\n /////////////////////////////////////////////////\n class Wrapped_Selector : public Simple_Selector {\n ADD_PROPERTY(Selector_List_Obj, selector)\n public:\n Wrapped_Selector(ParserState pstate, std::string n, Selector_List_Obj sel)\n : Simple_Selector(pstate, n), selector_(sel)\n { simple_type(WRAPPED_SEL); }\n Wrapped_Selector(const Wrapped_Selector* ptr)\n : Simple_Selector(ptr), selector_(ptr->selector_)\n { simple_type(WRAPPED_SEL); }\n virtual bool is_superselector_of(Wrapped_Selector_Obj sub);\n // Selectors inside the negation pseudo-class are counted like any\n // other, but the negation itself does not count as a pseudo-class.\n virtual size_t hash();\n virtual bool has_parent_ref() const;\n virtual bool has_real_parent_ref() const;\n virtual unsigned long specificity() const;\n virtual bool find ( bool (*f)(AST_Node_Obj) );\n virtual bool operator==(const Simple_Selector& rhs) const;\n virtual bool operator==(const Wrapped_Selector& rhs) const;\n virtual bool operator<(const Simple_Selector& rhs) const;\n virtual bool operator<(const Wrapped_Selector& rhs) const;\n virtual void cloneChildren();\n ATTACH_AST_OPERATIONS(Wrapped_Selector)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////////////////////////////\n // Simple selector sequences. Maintains flags indicating whether it contains\n // any parent references or placeholders, to simplify expansion.\n ////////////////////////////////////////////////////////////////////////////\n class Compound_Selector : public Selector, public Vectorized {\n private:\n ComplexSelectorSet sources_;\n ADD_PROPERTY(bool, extended);\n ADD_PROPERTY(bool, has_parent_reference);\n protected:\n void adjust_after_pushing(Simple_Selector_Obj s)\n {\n // if (s->has_reference()) has_reference(true);\n // if (s->has_placeholder()) has_placeholder(true);\n }\n public:\n Compound_Selector(ParserState pstate, size_t s = 0)\n : Selector(pstate),\n Vectorized(s),\n extended_(false),\n has_parent_reference_(false)\n { }\n Compound_Selector(const Compound_Selector* ptr)\n : Selector(ptr),\n Vectorized(*ptr),\n extended_(ptr->extended_),\n has_parent_reference_(ptr->has_parent_reference_)\n { }\n bool contains_placeholder() {\n for (size_t i = 0, L = length(); i < L; ++i) {\n if ((*this)[i]->has_placeholder()) return true;\n }\n return false;\n };\n\n void append(Simple_Selector_Ptr element);\n\n bool is_universal() const\n {\n return length() == 1 && (*this)[0]->is_universal();\n }\n\n Complex_Selector_Obj to_complex();\n Compound_Selector_Ptr unify_with(Compound_Selector_Ptr rhs);\n // virtual Placeholder_Selector_Ptr find_placeholder();\n virtual bool has_parent_ref() const;\n virtual bool has_real_parent_ref() const;\n Simple_Selector_Ptr base() const {\n if (length() == 0) return 0;\n // ToDo: why is this needed?\n if (Cast((*this)[0]))\n return (*this)[0];\n return 0;\n }\n virtual bool is_superselector_of(Compound_Selector_Obj sub, std::string wrapped = \"\");\n virtual bool is_superselector_of(Complex_Selector_Obj sub, std::string wrapped = \"\");\n virtual bool is_superselector_of(Selector_List_Obj sub, std::string wrapped = \"\");\n virtual size_t hash()\n {\n if (Selector::hash_ == 0) {\n hash_combine(Selector::hash_, std::hash()(SELECTOR));\n if (length()) hash_combine(Selector::hash_, Vectorized::hash());\n }\n return Selector::hash_;\n }\n virtual unsigned long specificity() const\n {\n int sum = 0;\n for (size_t i = 0, L = length(); i < L; ++i)\n { sum += (*this)[i]->specificity(); }\n return sum;\n }\n\n virtual bool has_placeholder()\n {\n if (length() == 0) return false;\n if (Simple_Selector_Obj ss = elements().front()) {\n if (ss->has_placeholder()) return true;\n }\n return false;\n }\n\n bool is_empty_reference()\n {\n return length() == 1 &&\n Cast((*this)[0]);\n }\n\n virtual bool find ( bool (*f)(AST_Node_Obj) );\n virtual bool operator<(const Selector& rhs) const;\n virtual bool operator==(const Selector& rhs) const;\n virtual bool operator<(const Compound_Selector& rhs) const;\n virtual bool operator==(const Compound_Selector& rhs) const;\n inline bool operator!=(const Compound_Selector& rhs) const { return !(*this == rhs); }\n\n ComplexSelectorSet& sources() { return sources_; }\n void clearSources() { sources_.clear(); }\n void mergeSources(ComplexSelectorSet& sources);\n\n Compound_Selector_Ptr minus(Compound_Selector_Ptr rhs);\n virtual void cloneChildren();\n ATTACH_AST_OPERATIONS(Compound_Selector)\n ATTACH_OPERATIONS()\n };\n\n ////////////////////////////////////////////////////////////////////////////\n // General selectors -- i.e., simple sequences combined with one of the four\n // CSS selector combinators (\">\", \"+\", \"~\", and whitespace). Essentially a\n // linked list.\n ////////////////////////////////////////////////////////////////////////////\n class Complex_Selector : public Selector {\n public:\n enum Combinator { ANCESTOR_OF, PARENT_OF, PRECEDES, ADJACENT_TO, REFERENCE };\n private:\n HASH_CONSTREF(Combinator, combinator)\n HASH_PROPERTY(Compound_Selector_Obj, head)\n HASH_PROPERTY(Complex_Selector_Obj, tail)\n HASH_PROPERTY(String_Obj, reference);\n public:\n bool contains_placeholder() {\n if (head() && head()->contains_placeholder()) return true;\n if (tail() && tail()->contains_placeholder()) return true;\n return false;\n };\n Complex_Selector(ParserState pstate,\n Combinator c = ANCESTOR_OF,\n Compound_Selector_Obj h = 0,\n Complex_Selector_Obj t = 0,\n String_Obj r = 0)\n : Selector(pstate),\n combinator_(c),\n head_(h), tail_(t),\n reference_(r)\n {}\n Complex_Selector(const Complex_Selector* ptr)\n : Selector(ptr),\n combinator_(ptr->combinator_),\n head_(ptr->head_), tail_(ptr->tail_),\n reference_(ptr->reference_)\n {};\n virtual bool has_parent_ref() const;\n virtual bool has_real_parent_ref() const;\n\n Complex_Selector_Obj skip_empty_reference()\n {\n if ((!head_ || !head_->length() || head_->is_empty_reference()) &&\n combinator() == Combinator::ANCESTOR_OF)\n {\n if (!tail_) return 0;\n tail_->has_line_feed_ = this->has_line_feed_;\n // tail_->has_line_break_ = this->has_line_break_;\n return tail_->skip_empty_reference();\n }\n return this;\n }\n\n // can still have a tail\n bool is_empty_ancestor() const\n {\n return (!head() || head()->length() == 0) &&\n combinator() == Combinator::ANCESTOR_OF;\n }\n\n Selector_List_Ptr tails(Selector_List_Ptr tails);\n\n // front returns the first real tail\n // skips over parent and empty ones\n Complex_Selector_Obj first();\n // last returns the last real tail\n Complex_Selector_Obj last();\n\n // some shortcuts that should be removed\n Complex_Selector_Obj innermost() { return last(); };\n\n size_t length() const;\n Selector_List_Ptr resolve_parent_refs(std::vector& pstack, Backtraces& traces, bool implicit_parent = true);\n virtual bool is_superselector_of(Compound_Selector_Obj sub, std::string wrapping = \"\");\n virtual bool is_superselector_of(Complex_Selector_Obj sub, std::string wrapping = \"\");\n virtual bool is_superselector_of(Selector_List_Obj sub, std::string wrapping = \"\");\n Selector_List_Ptr unify_with(Complex_Selector_Ptr rhs);\n Combinator clear_innermost();\n void append(Complex_Selector_Obj, Backtraces& traces);\n void set_innermost(Complex_Selector_Obj, Combinator);\n virtual size_t hash()\n {\n if (hash_ == 0) {\n hash_combine(hash_, std::hash()(SELECTOR));\n hash_combine(hash_, std::hash()(combinator_));\n if (head_) hash_combine(hash_, head_->hash());\n if (tail_) hash_combine(hash_, tail_->hash());\n }\n return hash_;\n }\n virtual unsigned long specificity() const\n {\n int sum = 0;\n if (head()) sum += head()->specificity();\n if (tail()) sum += tail()->specificity();\n return sum;\n }\n virtual void set_media_block(Media_Block_Ptr mb) {\n media_block(mb);\n if (tail_) tail_->set_media_block(mb);\n if (head_) head_->set_media_block(mb);\n }\n virtual bool has_placeholder() {\n if (head_ && head_->has_placeholder()) return true;\n if (tail_ && tail_->has_placeholder()) return true;\n return false;\n }\n virtual bool find ( bool (*f)(AST_Node_Obj) );\n virtual bool operator<(const Selector& rhs) const;\n virtual bool operator==(const Selector& rhs) const;\n virtual bool operator<(const Complex_Selector& rhs) const;\n virtual bool operator==(const Complex_Selector& rhs) const;\n inline bool operator!=(const Complex_Selector& rhs) const { return !(*this == rhs); }\n const ComplexSelectorSet sources()\n {\n //s = Set.new\n //seq.map {|sseq_or_op| s.merge sseq_or_op.sources if sseq_or_op.is_a?(SimpleSequence)}\n //s\n\n ComplexSelectorSet srcs;\n\n Compound_Selector_Obj pHead = head();\n Complex_Selector_Obj pTail = tail();\n\n if (pHead) {\n const ComplexSelectorSet& headSources = pHead->sources();\n srcs.insert(headSources.begin(), headSources.end());\n }\n\n if (pTail) {\n const ComplexSelectorSet& tailSources = pTail->sources();\n srcs.insert(tailSources.begin(), tailSources.end());\n }\n\n return srcs;\n }\n void addSources(ComplexSelectorSet& sources) {\n // members.map! {|m| m.is_a?(SimpleSequence) ? m.with_more_sources(sources) : m}\n Complex_Selector_Ptr pIter = this;\n while (pIter) {\n Compound_Selector_Ptr pHead = pIter->head();\n\n if (pHead) {\n pHead->mergeSources(sources);\n }\n\n pIter = pIter->tail();\n }\n }\n void clearSources() {\n Complex_Selector_Ptr pIter = this;\n while (pIter) {\n Compound_Selector_Ptr pHead = pIter->head();\n\n if (pHead) {\n pHead->clearSources();\n }\n\n pIter = pIter->tail();\n }\n }\n\n virtual void cloneChildren();\n ATTACH_AST_OPERATIONS(Complex_Selector)\n ATTACH_OPERATIONS()\n };\n\n ///////////////////////////////////\n // Comma-separated selector groups.\n ///////////////////////////////////\n class Selector_List : public Selector, public Vectorized {\n ADD_PROPERTY(Selector_Schema_Obj, schema)\n ADD_CONSTREF(std::vector, wspace)\n protected:\n void adjust_after_pushing(Complex_Selector_Obj c);\n public:\n Selector_List(ParserState pstate, size_t s = 0)\n : Selector(pstate),\n Vectorized(s),\n schema_(NULL),\n wspace_(0)\n { }\n Selector_List(const Selector_List* ptr)\n : Selector(ptr),\n Vectorized(*ptr),\n schema_(ptr->schema_),\n wspace_(ptr->wspace_)\n { }\n std::string type() const { return \"list\"; }\n // remove parent selector references\n // basically unwraps parsed selectors\n virtual bool has_parent_ref() const;\n virtual bool has_real_parent_ref() const;\n void remove_parent_selectors();\n Selector_List_Ptr resolve_parent_refs(std::vector& pstack, Backtraces& traces, bool implicit_parent = true);\n virtual bool is_superselector_of(Compound_Selector_Obj sub, std::string wrapping = \"\");\n virtual bool is_superselector_of(Complex_Selector_Obj sub, std::string wrapping = \"\");\n virtual bool is_superselector_of(Selector_List_Obj sub, std::string wrapping = \"\");\n Selector_List_Ptr unify_with(Selector_List_Ptr);\n void populate_extends(Selector_List_Obj, Subset_Map&);\n Selector_List_Obj eval(Eval& eval);\n virtual size_t hash()\n {\n if (Selector::hash_ == 0) {\n hash_combine(Selector::hash_, std::hash()(SELECTOR));\n hash_combine(Selector::hash_, Vectorized::hash());\n }\n return Selector::hash_;\n }\n virtual unsigned long specificity() const\n {\n unsigned long sum = 0;\n unsigned long specificity;\n for (size_t i = 0, L = length(); i < L; ++i)\n {\n specificity = (*this)[i]->specificity();\n if (sum < specificity) sum = specificity;\n }\n return sum;\n }\n virtual void set_media_block(Media_Block_Ptr mb) {\n media_block(mb);\n for (Complex_Selector_Obj cs : elements()) {\n cs->set_media_block(mb);\n }\n }\n virtual bool has_placeholder() {\n for (Complex_Selector_Obj cs : elements()) {\n if (cs->has_placeholder()) return true;\n }\n return false;\n }\n virtual bool find ( bool (*f)(AST_Node_Obj) );\n virtual bool operator<(const Selector& rhs) const;\n virtual bool operator==(const Selector& rhs) const;\n virtual bool operator<(const Selector_List& rhs) const;\n virtual bool operator==(const Selector_List& rhs) const;\n // Selector Lists can be compared to comma lists\n virtual bool operator==(const Expression& rhs) const;\n virtual void cloneChildren();\n ATTACH_AST_OPERATIONS(Selector_List)\n ATTACH_OPERATIONS()\n };\n\n // compare function for sorting and probably other other uses\n struct cmp_complex_selector { inline bool operator() (const Complex_Selector_Obj l, const Complex_Selector_Obj r) { return (*l < *r); } };\n struct cmp_compound_selector { inline bool operator() (const Compound_Selector_Obj l, const Compound_Selector_Obj r) { return (*l < *r); } };\n struct cmp_simple_selector { inline bool operator() (const Simple_Selector_Obj l, const Simple_Selector_Obj r) { return (*l < *r); } };\n\n}\n\n#ifdef __clang__\n\n#pragma clang diagnostic pop\n\n#endif\n\n#endif\n" }, { "path": "libsass-build/ast_def_macros.hpp", "content": "#ifndef SASS_AST_DEF_MACROS_H\n#define SASS_AST_DEF_MACROS_H\n\n// Helper class to switch a flag and revert once we go out of scope\ntemplate \nclass LocalOption {\n private:\n T* var; // pointer to original variable\n T orig; // copy of the original option\n public:\n LocalOption(T& var)\n {\n this->var = &var;\n this->orig = var;\n }\n LocalOption(T& var, T orig)\n {\n this->var = &var;\n this->orig = var;\n *(this->var) = orig;\n }\n void reset()\n {\n *(this->var) = this->orig;\n }\n ~LocalOption() {\n *(this->var) = this->orig;\n }\n};\n\n#define LOCAL_FLAG(name,opt) LocalOption flag_##name(name, opt)\n#define LOCAL_COUNT(name,opt) LocalOption cnt_##name(name, opt)\n\n#define NESTING_GUARD(name) \\\n LocalOption cnt_##name(name, name + 1); \\\n if (name > MAX_NESTING) throw Exception::NestingLimitError(pstate, traces); \\\n\n#define ATTACH_OPERATIONS()\\\nvirtual void perform(Operation* op) { (*op)(this); }\\\nvirtual AST_Node_Ptr perform(Operation* op) { return (*op)(this); }\\\nvirtual Statement_Ptr perform(Operation* op) { return (*op)(this); }\\\nvirtual Expression_Ptr perform(Operation* op) { return (*op)(this); }\\\nvirtual Selector_Ptr perform(Operation* op) { return (*op)(this); }\\\nvirtual std::string perform(Operation* op) { return (*op)(this); }\\\nvirtual union Sass_Value* perform(Operation* op) { return (*op)(this); }\\\nvirtual Value_Ptr perform(Operation* op) { return (*op)(this); }\n\n#define ADD_PROPERTY(type, name)\\\nprotected:\\\n type name##_;\\\npublic:\\\n type name() const { return name##_; }\\\n type name(type name##__) { return name##_ = name##__; }\\\nprivate:\n\n#define HASH_PROPERTY(type, name)\\\nprotected:\\\n type name##_;\\\npublic:\\\n type name() const { return name##_; }\\\n type name(type name##__) { hash_ = 0; return name##_ = name##__; }\\\nprivate:\n\n#define ADD_CONSTREF(type, name) \\\nprotected: \\\n type name##_; \\\npublic: \\\n const type& name() const { return name##_; } \\\n void name(type name##__) { name##_ = name##__; } \\\nprivate:\n\n#define HASH_CONSTREF(type, name) \\\nprotected: \\\n type name##_; \\\npublic: \\\n const type& name() const { return name##_; } \\\n void name(type name##__) { hash_ = 0; name##_ = name##__; } \\\nprivate:\n\n#endif\n" }, { "path": "libsass-build/ast_fwd_decl.cpp", "content": "#include \"ast.hpp\"\n\nnamespace Sass {\n\n #define IMPLEMENT_BASE_CAST(T) \\\n template<> \\\n T* Cast(AST_Node* ptr) { \\\n return dynamic_cast(ptr); \\\n }; \\\n \\\n template<> \\\n const T* Cast(const AST_Node* ptr) { \\\n return dynamic_cast(ptr); \\\n }; \\\n\n IMPLEMENT_BASE_CAST(AST_Node)\n IMPLEMENT_BASE_CAST(Expression)\n IMPLEMENT_BASE_CAST(Statement)\n IMPLEMENT_BASE_CAST(Has_Block)\n IMPLEMENT_BASE_CAST(PreValue)\n IMPLEMENT_BASE_CAST(Value)\n IMPLEMENT_BASE_CAST(List)\n IMPLEMENT_BASE_CAST(String)\n IMPLEMENT_BASE_CAST(String_Constant)\n IMPLEMENT_BASE_CAST(Supports_Condition)\n IMPLEMENT_BASE_CAST(Selector)\n IMPLEMENT_BASE_CAST(Simple_Selector)\n\n}\n" }, { "path": "libsass-build/ast_fwd_decl.hpp", "content": "#ifndef SASS_AST_FWD_DECL_H\n#define SASS_AST_FWD_DECL_H\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"memory/SharedPtr.hpp\"\n#include \"sass/functions.h\"\n\n/////////////////////////////////////////////\n// Forward declarations for the AST visitors.\n/////////////////////////////////////////////\nnamespace Sass {\n\n class AST_Node;\n typedef AST_Node* AST_Node_Ptr;\n typedef AST_Node const* AST_Node_Ptr_Const;\n\n class Has_Block;\n typedef Has_Block* Has_Block_Ptr;\n typedef Has_Block const* Has_Block_Ptr_Const;\n\n class Simple_Selector;\n typedef Simple_Selector* Simple_Selector_Ptr;\n typedef Simple_Selector const* Simple_Selector_Ptr_Const;\n\n class PreValue;\n typedef PreValue* PreValue_Ptr;\n typedef PreValue const* PreValue_Ptr_Const;\n class Thunk;\n typedef Thunk* Thunk_Ptr;\n typedef Thunk const* Thunk_Ptr_Const;\n class Block;\n typedef Block* Block_Ptr;\n typedef Block const* Block_Ptr_Const;\n class Expression;\n typedef Expression* Expression_Ptr;\n typedef Expression const* Expression_Ptr_Const;\n class Statement;\n typedef Statement* Statement_Ptr;\n typedef Statement const* Statement_Ptr_Const;\n class Value;\n typedef Value* Value_Ptr;\n typedef Value const* Value_Ptr_Const;\n class Declaration;\n typedef Declaration* Declaration_Ptr;\n typedef Declaration const* Declaration_Ptr_Const;\n class Ruleset;\n typedef Ruleset* Ruleset_Ptr;\n typedef Ruleset const* Ruleset_Ptr_Const;\n class Bubble;\n typedef Bubble* Bubble_Ptr;\n typedef Bubble const* Bubble_Ptr_Const;\n class Trace;\n typedef Trace* Trace_Ptr;\n typedef Trace const* Trace_Ptr_Const;\n\n class Media_Block;\n typedef Media_Block* Media_Block_Ptr;\n typedef Media_Block const* Media_Block_Ptr_Const;\n class Supports_Block;\n typedef Supports_Block* Supports_Block_Ptr;\n typedef Supports_Block const* Supports_Block_Ptr_Const;\n class Directive;\n typedef Directive* Directive_Ptr;\n typedef Directive const* Directive_Ptr_Const;\n\n\n class Keyframe_Rule;\n typedef Keyframe_Rule* Keyframe_Rule_Ptr;\n typedef Keyframe_Rule const* Keyframe_Rule_Ptr_Const;\n class At_Root_Block;\n typedef At_Root_Block* At_Root_Block_Ptr;\n typedef At_Root_Block const* At_Root_Block_Ptr_Const;\n class Assignment;\n typedef Assignment* Assignment_Ptr;\n typedef Assignment const* Assignment_Ptr_Const;\n\n class Import;\n typedef Import* Import_Ptr;\n typedef Import const* Import_Ptr_Const;\n class Import_Stub;\n typedef Import_Stub* Import_Stub_Ptr;\n typedef Import_Stub const* Import_Stub_Ptr_Const;\n class Warning;\n typedef Warning* Warning_Ptr;\n typedef Warning const* Warning_Ptr_Const;\n\n class Error;\n typedef Error* Error_Ptr;\n typedef Error const* Error_Ptr_Const;\n class Debug;\n typedef Debug* Debug_Ptr;\n typedef Debug const* Debug_Ptr_Const;\n class Comment;\n typedef Comment* Comment_Ptr;\n typedef Comment const* Comment_Ptr_Const;\n\n class If;\n typedef If* If_Ptr;\n typedef If const* If_Ptr_Const;\n class For;\n typedef For* For_Ptr;\n typedef For const* For_Ptr_Const;\n class Each;\n typedef Each* Each_Ptr;\n typedef Each const* Each_Ptr_Const;\n class While;\n typedef While* While_Ptr;\n typedef While const* While_Ptr_Const;\n class Return;\n typedef Return* Return_Ptr;\n typedef Return const* Return_Ptr_Const;\n class Content;\n typedef Content* Content_Ptr;\n typedef Content const* Content_Ptr_Const;\n class Extension;\n typedef Extension* Extension_Ptr;\n typedef Extension const* Extension_Ptr_Const;\n class Definition;\n typedef Definition* Definition_Ptr;\n typedef Definition const* Definition_Ptr_Const;\n\n class List;\n typedef List* List_Ptr;\n typedef List const* List_Ptr_Const;\n class Map;\n typedef Map* Map_Ptr;\n typedef Map const* Map_Ptr_Const;\n class Function;\n typedef Function* Function_Ptr;\n typedef Function const* Function_Ptr_Const;\n\n class Mixin_Call;\n typedef Mixin_Call* Mixin_Call_Ptr;\n typedef Mixin_Call const* Mixin_Call_Ptr_Const;\n class Binary_Expression;\n typedef Binary_Expression* Binary_Expression_Ptr;\n typedef Binary_Expression const* Binary_Expression_Ptr_Const;\n class Unary_Expression;\n typedef Unary_Expression* Unary_Expression_Ptr;\n typedef Unary_Expression const* Unary_Expression_Ptr_Const;\n class Function_Call;\n typedef Function_Call* Function_Call_Ptr;\n typedef Function_Call const* Function_Call_Ptr_Const;\n class Function_Call_Schema;\n typedef Function_Call_Schema* Function_Call_Schema_Ptr;\n typedef Function_Call_Schema const* Function_Call_Schema_Ptr_Const;\n class Custom_Warning;\n typedef Custom_Warning* Custom_Warning_Ptr;\n typedef Custom_Warning const* Custom_Warning_Ptr_Const;\n class Custom_Error;\n typedef Custom_Error* Custom_Error_Ptr;\n typedef Custom_Error const* Custom_Error_Ptr_Const;\n\n class Variable;\n typedef Variable* Variable_Ptr;\n typedef Variable const* Variable_Ptr_Const;\n class Number;\n typedef Number* Number_Ptr;\n typedef Number const* Number_Ptr_Const;\n class Color;\n typedef Color* Color_Ptr;\n typedef Color const* Color_Ptr_Const;\n class Boolean;\n typedef Boolean* Boolean_Ptr;\n typedef Boolean const* Boolean_Ptr_Const;\n class String;\n typedef String* String_Ptr;\n typedef String const* String_Ptr_Const;\n\n class String_Schema;\n typedef String_Schema* String_Schema_Ptr;\n typedef String_Schema const* String_Schema_Ptr_Const;\n class String_Constant;\n typedef String_Constant* String_Constant_Ptr;\n typedef String_Constant const* String_Constant_Ptr_Const;\n class String_Quoted;\n typedef String_Quoted* String_Quoted_Ptr;\n typedef String_Quoted const* String_Quoted_Ptr_Const;\n\n class Media_Query;\n typedef Media_Query* Media_Query_Ptr;\n typedef Media_Query const* Media_Query_Ptr_Const;\n class Media_Query_Expression;\n typedef Media_Query_Expression* Media_Query_Expression_Ptr;\n typedef Media_Query_Expression const* Media_Query_Expression_Ptr_Const;\n class Supports_Condition;\n typedef Supports_Condition* Supports_Condition_Ptr;\n typedef Supports_Condition const* Supports_Condition_Ptr_Const;\n class Supports_Operator;\n typedef Supports_Operator* Supports_Operator_Ptr;\n typedef Supports_Operator const* Supports_Operator_Ptr_Const;\n class Supports_Negation;\n typedef Supports_Negation* Supports_Negation_Ptr;\n typedef Supports_Negation const* Supports_Negation_Ptr_Const;\n class Supports_Declaration;\n typedef Supports_Declaration* Supports_Declaration_Ptr;\n typedef Supports_Declaration const* Supports_Declaration_Ptr_Const;\n class Supports_Interpolation;\n typedef Supports_Interpolation* Supports_Interpolation_Ptr;\n typedef Supports_Interpolation const* Supports_Interpolation_Ptr_Const;\n\n\n class Null;\n typedef Null* Null_Ptr;\n typedef Null const* Null_Ptr_Const;\n\n class At_Root_Query;\n typedef At_Root_Query* At_Root_Query_Ptr;\n typedef At_Root_Query const* At_Root_Query_Ptr_Const;\n class Parent_Selector;\n typedef Parent_Selector* Parent_Selector_Ptr;\n typedef Parent_Selector const* Parent_Selector_Ptr_Const;\n class Parameter;\n typedef Parameter* Parameter_Ptr;\n typedef Parameter const* Parameter_Ptr_Const;\n class Parameters;\n typedef Parameters* Parameters_Ptr;\n typedef Parameters const* Parameters_Ptr_Const;\n class Argument;\n typedef Argument* Argument_Ptr;\n typedef Argument const* Argument_Ptr_Const;\n class Arguments;\n typedef Arguments* Arguments_Ptr;\n typedef Arguments const* Arguments_Ptr_Const;\n class Selector;\n typedef Selector* Selector_Ptr;\n typedef Selector const* Selector_Ptr_Const;\n\n\n class Selector_Schema;\n typedef Selector_Schema* Selector_Schema_Ptr;\n typedef Selector_Schema const* Selector_Schema_Ptr_Const;\n class Placeholder_Selector;\n typedef Placeholder_Selector* Placeholder_Selector_Ptr;\n typedef Placeholder_Selector const* Placeholder_Selector_Ptr_Const;\n class Element_Selector;\n typedef Element_Selector* Element_Selector_Ptr;\n typedef Element_Selector const* Element_Selector_Ptr_Const;\n class Class_Selector;\n typedef Class_Selector* Class_Selector_Ptr;\n typedef Class_Selector const* Class_Selector_Ptr_Const;\n class Id_Selector;\n typedef Id_Selector* Id_Selector_Ptr;\n typedef Id_Selector const* Id_Selector_Ptr_Const;\n class Attribute_Selector;\n typedef Attribute_Selector* Attribute_Selector_Ptr;\n typedef Attribute_Selector const* Attribute_Selector_Ptr_Const;\n\n class Pseudo_Selector;\n typedef Pseudo_Selector* Pseudo_Selector_Ptr;\n typedef Pseudo_Selector const * Pseudo_Selector_Ptr_Const;\n class Wrapped_Selector;\n typedef Wrapped_Selector* Wrapped_Selector_Ptr;\n typedef Wrapped_Selector const * Wrapped_Selector_Ptr_Const;\n class Compound_Selector;\n typedef Compound_Selector* Compound_Selector_Ptr;\n typedef Compound_Selector const * Compound_Selector_Ptr_Const;\n class Complex_Selector;\n typedef Complex_Selector* Complex_Selector_Ptr;\n typedef Complex_Selector const * Complex_Selector_Ptr_Const;\n class Selector_List;\n typedef Selector_List* Selector_List_Ptr;\n typedef Selector_List const * Selector_List_Ptr_Const;\n\n\n // common classes\n class Context;\n class Expand;\n class Eval;\n\n // declare classes that are instances of memory nodes\n // #define IMPL_MEM_OBJ(type) using type##_Obj = SharedImpl\n #define IMPL_MEM_OBJ(type) typedef SharedImpl type##_Obj\n\n IMPL_MEM_OBJ(AST_Node);\n IMPL_MEM_OBJ(Statement);\n IMPL_MEM_OBJ(Block);\n IMPL_MEM_OBJ(Ruleset);\n IMPL_MEM_OBJ(Bubble);\n IMPL_MEM_OBJ(Trace);\n IMPL_MEM_OBJ(Media_Block);\n IMPL_MEM_OBJ(Supports_Block);\n IMPL_MEM_OBJ(Directive);\n IMPL_MEM_OBJ(Keyframe_Rule);\n IMPL_MEM_OBJ(At_Root_Block);\n IMPL_MEM_OBJ(Declaration);\n IMPL_MEM_OBJ(Assignment);\n IMPL_MEM_OBJ(Import);\n IMPL_MEM_OBJ(Import_Stub);\n IMPL_MEM_OBJ(Warning);\n IMPL_MEM_OBJ(Error);\n IMPL_MEM_OBJ(Debug);\n IMPL_MEM_OBJ(Comment);\n IMPL_MEM_OBJ(PreValue);\n IMPL_MEM_OBJ(Has_Block);\n IMPL_MEM_OBJ(Thunk);\n IMPL_MEM_OBJ(If);\n IMPL_MEM_OBJ(For);\n IMPL_MEM_OBJ(Each);\n IMPL_MEM_OBJ(While);\n IMPL_MEM_OBJ(Return);\n IMPL_MEM_OBJ(Content);\n IMPL_MEM_OBJ(Extension);\n IMPL_MEM_OBJ(Definition);\n IMPL_MEM_OBJ(Mixin_Call);\n IMPL_MEM_OBJ(Value);\n IMPL_MEM_OBJ(Expression);\n IMPL_MEM_OBJ(List);\n IMPL_MEM_OBJ(Map);\n IMPL_MEM_OBJ(Function);\n IMPL_MEM_OBJ(Binary_Expression);\n IMPL_MEM_OBJ(Unary_Expression);\n IMPL_MEM_OBJ(Function_Call);\n IMPL_MEM_OBJ(Function_Call_Schema);\n IMPL_MEM_OBJ(Custom_Warning);\n IMPL_MEM_OBJ(Custom_Error);\n IMPL_MEM_OBJ(Variable);\n IMPL_MEM_OBJ(Number);\n IMPL_MEM_OBJ(Color);\n IMPL_MEM_OBJ(Boolean);\n IMPL_MEM_OBJ(String_Schema);\n IMPL_MEM_OBJ(String);\n IMPL_MEM_OBJ(String_Constant);\n IMPL_MEM_OBJ(String_Quoted);\n IMPL_MEM_OBJ(Media_Query);\n IMPL_MEM_OBJ(Media_Query_Expression);\n IMPL_MEM_OBJ(Supports_Condition);\n IMPL_MEM_OBJ(Supports_Operator);\n IMPL_MEM_OBJ(Supports_Negation);\n IMPL_MEM_OBJ(Supports_Declaration);\n IMPL_MEM_OBJ(Supports_Interpolation);\n IMPL_MEM_OBJ(At_Root_Query);\n IMPL_MEM_OBJ(Null);\n IMPL_MEM_OBJ(Parent_Selector);\n IMPL_MEM_OBJ(Parameter);\n IMPL_MEM_OBJ(Parameters);\n IMPL_MEM_OBJ(Argument);\n IMPL_MEM_OBJ(Arguments);\n IMPL_MEM_OBJ(Selector);\n IMPL_MEM_OBJ(Selector_Schema);\n IMPL_MEM_OBJ(Simple_Selector);\n IMPL_MEM_OBJ(Placeholder_Selector);\n IMPL_MEM_OBJ(Element_Selector);\n IMPL_MEM_OBJ(Class_Selector);\n IMPL_MEM_OBJ(Id_Selector);\n IMPL_MEM_OBJ(Attribute_Selector);\n IMPL_MEM_OBJ(Pseudo_Selector);\n IMPL_MEM_OBJ(Wrapped_Selector);\n IMPL_MEM_OBJ(Compound_Selector);\n IMPL_MEM_OBJ(Complex_Selector);\n IMPL_MEM_OBJ(Selector_List);\n\n // ###########################################################################\n // Implement compare, order and hashing operations for AST Nodes\n // ###########################################################################\n\n struct HashNodes {\n template \n size_t operator() (const T& ex) const {\n return ex.isNull() ? 0 : ex->hash();\n }\n };\n struct OrderNodes {\n template \n bool operator() (const T& lhs, const T& rhs) const {\n return !lhs.isNull() && !rhs.isNull() && *lhs < *rhs;\n }\n };\n struct CompareNodes {\n template \n bool operator() (const T& lhs, const T& rhs) const {\n // code around sass logic issue. 1px == 1 is true\n // but both items are still different keys in maps\n if (dynamic_cast(lhs.ptr()))\n if (dynamic_cast(rhs.ptr()))\n return lhs->hash() == rhs->hash();\n return !lhs.isNull() && !rhs.isNull() && *lhs == *rhs;\n }\n };\n\n // ###########################################################################\n // some often used typedefs\n // ###########################################################################\n\n typedef std::unordered_map<\n Expression_Obj, // key\n Expression_Obj, // value\n HashNodes, // hasher\n CompareNodes // compare\n > ExpressionMap;\n typedef std::unordered_set<\n Expression_Obj, // value\n HashNodes, // hasher\n CompareNodes // compare\n > ExpressionSet;\n\n typedef std::string SubSetMapKey;\n typedef std::vector SubSetMapKeys;\n\n typedef std::pair SubSetMapPair;\n typedef std::pair SubSetMapLookup;\n typedef std::vector SubSetMapPairs;\n typedef std::vector SubSetMapLookups;\n\n typedef std::pair SubSetMapResult;\n typedef std::vector SubSetMapResults;\n\n typedef std::deque ComplexSelectorDeque;\n typedef std::set SimpleSelectorSet;\n typedef std::set ComplexSelectorSet;\n typedef std::set CompoundSelectorSet;\n typedef std::unordered_set SimpleSelectorDict;\n\n typedef std::vector* ImporterStack;\n\n // only to switch implementations for testing\n #define environment_map std::map\n\n // ###########################################################################\n // explicit type conversion functions\n // ###########################################################################\n\n template\n T* Cast(AST_Node* ptr);\n\n template\n const T* Cast(const AST_Node* ptr);\n\n // sometimes you know the class you want to cast to is final\n // in this case a simple typeid check is faster and safe to use\n\n #define DECLARE_BASE_CAST(T) \\\n template<> T* Cast(AST_Node* ptr); \\\n template<> const T* Cast(const AST_Node* ptr); \\\n\n // ###########################################################################\n // implement specialization for final classes\n // ###########################################################################\n\n DECLARE_BASE_CAST(AST_Node)\n DECLARE_BASE_CAST(Expression)\n DECLARE_BASE_CAST(Statement)\n DECLARE_BASE_CAST(Has_Block)\n DECLARE_BASE_CAST(PreValue)\n DECLARE_BASE_CAST(Value)\n DECLARE_BASE_CAST(List)\n DECLARE_BASE_CAST(String)\n DECLARE_BASE_CAST(String_Constant)\n DECLARE_BASE_CAST(Supports_Condition)\n DECLARE_BASE_CAST(Selector)\n DECLARE_BASE_CAST(Simple_Selector)\n\n}\n\n#endif\n" }, { "path": "libsass-build/b64/cencode.h", "content": "/*\ncencode.h - c header for a base64 encoding algorithm\n\nThis is part of the libb64 project, and has been placed in the public domain.\nFor details, see http://sourceforge.net/projects/libb64\n*/\n\n#ifndef BASE64_CENCODE_H\n#define BASE64_CENCODE_H\n\ntypedef enum\n{\n step_A, step_B, step_C\n} base64_encodestep;\n\ntypedef struct\n{\n\tbase64_encodestep step;\n\tchar result;\n\tint stepcount;\n} base64_encodestate;\n\nvoid base64_init_encodestate(base64_encodestate* state_in);\n\nchar base64_encode_value(char value_in);\n\nint base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in);\n\nint base64_encode_blockend(char* code_out, base64_encodestate* state_in);\n\n#endif /* BASE64_CENCODE_H */\n\n" }, { "path": "libsass-build/b64/encode.h", "content": "// :mode=c++:\n/*\nencode.h - c++ wrapper for a base64 encoding algorithm\n\nThis is part of the libb64 project, and has been placed in the public domain.\nFor details, see http://sourceforge.net/projects/libb64\n*/\n#ifndef BASE64_ENCODE_H\n#define BASE64_ENCODE_H\n\n#include \n\nnamespace base64\n{\n\textern \"C\"\n\t{\n\t\t#include \"cencode.h\"\n\t}\n\n\tstruct encoder\n\t{\n\t\tbase64_encodestate _state;\n\t\tint _buffersize;\n\n\t\tencoder(int buffersize_in = BUFFERSIZE)\n\t\t: _buffersize(buffersize_in)\n\t\t{\n\t\t\tbase64_init_encodestate(&_state);\n\t\t}\n\n\t\tint encode(char value_in)\n\t\t{\n\t\t\treturn base64_encode_value(value_in);\n\t\t}\n\n\t\tint encode(const char* code_in, const int length_in, char* plaintext_out)\n\t\t{\n\t\t\treturn base64_encode_block(code_in, length_in, plaintext_out, &_state);\n\t\t}\n\n\t\tint encode_end(char* plaintext_out)\n\t\t{\n\t\t\treturn base64_encode_blockend(plaintext_out, &_state);\n\t\t}\n\n\t\tvoid encode(std::istream& istream_in, std::ostream& ostream_in)\n\t\t{\n\t\t\tbase64_init_encodestate(&_state);\n\t\t\t//\n\t\t\tconst int N = _buffersize;\n\t\t\tchar* plaintext = new char[N];\n\t\t\tchar* code = new char[2*N];\n\t\t\tint plainlength;\n\t\t\tint codelength;\n\n\t\t\tdo\n\t\t\t{\n\t\t\t\tistream_in.read(plaintext, N);\n\t\t\t\tplainlength = static_cast(istream_in.gcount());\n\t\t\t\t//\n\t\t\t\tcodelength = encode(plaintext, plainlength, code);\n\t\t\t\tostream_in.write(code, codelength);\n\t\t\t}\n\t\t\twhile (istream_in.good() && plainlength > 0);\n\n\t\t\tcodelength = encode_end(code);\n\t\t\tostream_in.write(code, codelength);\n\t\t\t//\n\t\t\tbase64_init_encodestate(&_state);\n\n\t\t\tdelete [] code;\n\t\t\tdelete [] plaintext;\n\t\t}\n\t};\n\n} // namespace base64\n\n#endif // BASE64_ENCODE_H\n\n" }, { "path": "libsass-build/backtrace.cpp", "content": "#include \"backtrace.hpp\"\n\nnamespace Sass {\n\n const std::string traces_to_string(Backtraces traces, std::string indent) {\n\n std::stringstream ss;\n std::string cwd(File::get_cwd());\n\n bool first = true;\n size_t i_beg = traces.size() - 1;\n size_t i_end = std::string::npos;\n for (size_t i = i_beg; i != i_end; i --) {\n\n const Backtrace& trace = traces[i];\n\n // make path relative to the current directory\n std::string rel_path(File::abs2rel(trace.pstate.path, cwd, cwd));\n\n // skip functions on error cases (unsure why ruby sass does this)\n // if (trace.caller.substr(0, 6) == \", in f\") continue;\n\n if (first) {\n ss << indent;\n ss << \"on line \";\n ss << trace.pstate.line + 1;\n ss << \" of \" << rel_path;\n // ss << trace.caller;\n first = false;\n } else {\n ss << trace.caller;\n ss << std::endl;\n ss << indent;\n ss << \"from line \";\n ss << trace.pstate.line + 1;\n ss << \" of \" << rel_path;\n }\n\n }\n\n ss << std::endl;\n return ss.str();\n\n }\n\n};\n" }, { "path": "libsass-build/backtrace.hpp", "content": "#ifndef SASS_BACKTRACE_H\n#define SASS_BACKTRACE_H\n\n#include \n#include \n#include \"file.hpp\"\n#include \"position.hpp\"\n\nnamespace Sass {\n\n struct Backtrace {\n\n ParserState pstate;\n std::string caller;\n\n Backtrace(ParserState pstate, std::string c = \"\")\n : pstate(pstate),\n caller(c)\n { }\n\n };\n\n typedef std::vector Backtraces;\n\n const std::string traces_to_string(Backtraces traces, std::string indent = \"\\t\");\n\n}\n\n#endif\n" }, { "path": "libsass-build/base64vlq.cpp", "content": "#include \"sass.hpp\"\n#include \"base64vlq.hpp\"\n\nnamespace Sass {\n\n std::string Base64VLQ::encode(const int number) const\n {\n std::string encoded = \"\";\n\n int vlq = to_vlq_signed(number);\n\n do {\n int digit = vlq & VLQ_BASE_MASK;\n vlq >>= VLQ_BASE_SHIFT;\n if (vlq > 0) {\n digit |= VLQ_CONTINUATION_BIT;\n }\n encoded += base64_encode(digit);\n } while (vlq > 0);\n\n return encoded;\n }\n\n char Base64VLQ::base64_encode(const int number) const\n {\n int index = number;\n if (index < 0) index = 0;\n if (index > 63) index = 63;\n return CHARACTERS[index];\n }\n\n int Base64VLQ::to_vlq_signed(const int number) const\n {\n return (number < 0) ? ((-number) << 1) + 1 : (number << 1) + 0;\n }\n\n const char* Base64VLQ::CHARACTERS = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\n const int Base64VLQ::VLQ_BASE_SHIFT = 5;\n const int Base64VLQ::VLQ_BASE = 1 << VLQ_BASE_SHIFT;\n const int Base64VLQ::VLQ_BASE_MASK = VLQ_BASE - 1;\n const int Base64VLQ::VLQ_CONTINUATION_BIT = VLQ_BASE;\n\n}\n" }, { "path": "libsass-build/base64vlq.hpp", "content": "#ifndef SASS_BASE64VLQ_H\n#define SASS_BASE64VLQ_H\n\n#include \n\nnamespace Sass {\n\n class Base64VLQ {\n\n public:\n\n std::string encode(const int number) const;\n\n private:\n\n char base64_encode(const int number) const;\n\n int to_vlq_signed(const int number) const;\n\n static const char* CHARACTERS;\n\n static const int VLQ_BASE_SHIFT;\n static const int VLQ_BASE;\n static const int VLQ_BASE_MASK;\n static const int VLQ_CONTINUATION_BIT;\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/bind.cpp", "content": "#include \"sass.hpp\"\n#include \"bind.hpp\"\n#include \"ast.hpp\"\n#include \"context.hpp\"\n#include \"expand.hpp\"\n#include \"eval.hpp\"\n#include \n#include \n#include \n\nnamespace Sass {\n\n void bind(std::string type, std::string name, Parameters_Obj ps, Arguments_Obj as, Context* ctx, Env* env, Eval* eval)\n {\n std::string callee(type + \" \" + name);\n\n std::map param_map;\n List_Obj varargs = SASS_MEMORY_NEW(List, as->pstate());\n varargs->is_arglist(true); // enable keyword size handling\n\n for (size_t i = 0, L = as->length(); i < L; ++i) {\n if (auto str = Cast((*as)[i]->value())) {\n // force optional quotes (only if needed)\n if (str->quote_mark()) {\n str->quote_mark('*');\n }\n }\n }\n\n // Set up a map to ensure named arguments refer to actual parameters. Also\n // eval each default value left-to-right, wrt env, populating env as we go.\n for (size_t i = 0, L = ps->length(); i < L; ++i) {\n Parameter_Obj p = ps->at(i);\n param_map[p->name()] = p;\n // if (p->default_value()) {\n // env->local_frame()[p->name()] = p->default_value()->perform(eval->with(env));\n // }\n }\n\n // plug in all args; if we have leftover params, deal with it later\n size_t ip = 0, LP = ps->length();\n size_t ia = 0, LA = as->length();\n while (ia < LA) {\n Argument_Obj a = as->at(ia);\n if (ip >= LP) {\n // skip empty rest arguments\n if (a->is_rest_argument()) {\n if (List_Obj l = Cast(a->value())) {\n if (l->length() == 0) {\n ++ ia; continue;\n }\n }\n }\n std::stringstream msg;\n msg << \"wrong number of arguments (\" << LA << \" for \" << LP << \")\";\n msg << \" for `\" << name << \"'\";\n return error(msg.str(), as->pstate(), eval->exp.traces);\n }\n Parameter_Obj p = ps->at(ip);\n\n // If the current parameter is the rest parameter, process and break the loop\n if (p->is_rest_parameter()) {\n // The next argument by coincidence provides a rest argument\n if (a->is_rest_argument()) {\n\n // We should always get a list for rest arguments\n if (List_Obj rest = Cast(a->value())) {\n // create a new list object for wrapped items\n List_Ptr arglist = SASS_MEMORY_NEW(List,\n p->pstate(),\n 0,\n rest->separator(),\n true);\n // wrap each item from list as an argument\n for (Expression_Obj item : rest->elements()) {\n if (Argument_Obj arg = Cast(item)) {\n arglist->append(SASS_MEMORY_COPY(arg)); // copy\n } else {\n arglist->append(SASS_MEMORY_NEW(Argument,\n item->pstate(),\n item,\n \"\",\n false,\n false));\n }\n }\n // assign new arglist to environment\n env->local_frame()[p->name()] = arglist;\n }\n // invalid state\n else {\n throw std::runtime_error(\"invalid state\");\n }\n } else if (a->is_keyword_argument()) {\n\n // expand keyword arguments into their parameters\n List_Ptr arglist = SASS_MEMORY_NEW(List, p->pstate(), 0, SASS_COMMA, true);\n env->local_frame()[p->name()] = arglist;\n Map_Obj argmap = Cast(a->value());\n for (auto key : argmap->keys()) {\n if (String_Constant_Obj str = Cast(key)) {\n std::string param = unquote(str->value());\n arglist->append(SASS_MEMORY_NEW(Argument,\n key->pstate(),\n argmap->at(key),\n \"$\" + param,\n false,\n false));\n } else {\n eval->exp.traces.push_back(Backtrace(key->pstate()));\n throw Exception::InvalidVarKwdType(key->pstate(), eval->exp.traces, key->inspect(), a);\n }\n }\n\n } else {\n\n // create a new list object for wrapped items\n List_Obj arglist = SASS_MEMORY_NEW(List,\n p->pstate(),\n 0,\n SASS_COMMA,\n true);\n // consume the next args\n while (ia < LA) {\n // get and post inc\n a = (*as)[ia++];\n // maybe we have another list as argument\n List_Obj ls = Cast(a->value());\n // skip any list completely if empty\n if (ls && ls->empty() && a->is_rest_argument()) continue;\n\n Expression_Obj value = a->value();\n if (Argument_Obj arg = Cast(value)) {\n arglist->append(arg);\n }\n // check if we have rest argument\n else if (a->is_rest_argument()) {\n // preserve the list separator from rest args\n if (List_Obj rest = Cast(a->value())) {\n arglist->separator(rest->separator());\n\n for (size_t i = 0, L = rest->length(); i < L; ++i) {\n Expression_Obj obj = rest->value_at_index(i);\n arglist->append(SASS_MEMORY_NEW(Argument,\n obj->pstate(),\n obj,\n \"\",\n false,\n false));\n }\n }\n // no more arguments\n break;\n }\n // wrap all other value types into Argument\n else {\n arglist->append(SASS_MEMORY_NEW(Argument,\n a->pstate(),\n a->value(),\n a->name(),\n false,\n false));\n }\n }\n // assign new arglist to environment\n env->local_frame()[p->name()] = arglist;\n }\n // consumed parameter\n ++ip;\n // no more paramaters\n break;\n }\n\n // If the current argument is the rest argument, extract a value for processing\n else if (a->is_rest_argument()) {\n // normal param and rest arg\n List_Obj arglist = Cast(a->value());\n if (!arglist) {\n if (Expression_Obj arg = Cast(a->value())) {\n arglist = SASS_MEMORY_NEW(List, a->pstate(), 1);\n arglist->append(arg);\n }\n }\n\n // empty rest arg - treat all args as default values\n if (!arglist || !arglist->length()) {\n break;\n } else {\n if (arglist->length() > LP - ip && !ps->has_rest_parameter()) {\n size_t arg_count = (arglist->length() + LA - 1);\n std::stringstream msg;\n msg << callee << \" takes \" << LP;\n msg << (LP == 1 ? \" argument\" : \" arguments\");\n msg << \" but \" << arg_count;\n msg << (arg_count == 1 ? \" was passed\" : \" were passed.\");\n deprecated_bind(msg.str(), as->pstate());\n\n while (arglist->length() > LP - ip) {\n arglist->elements().erase(arglist->elements().end() - 1);\n }\n }\n }\n // otherwise move one of the rest args into the param, converting to argument if necessary\n Expression_Obj obj = arglist->at(0);\n if (!(a = Cast(obj))) {\n Expression_Ptr a_to_convert = obj;\n a = SASS_MEMORY_NEW(Argument,\n a_to_convert->pstate(),\n a_to_convert,\n \"\",\n false,\n false);\n }\n arglist->elements().erase(arglist->elements().begin());\n if (!arglist->length() || (!arglist->is_arglist() && ip + 1 == LP)) {\n ++ia;\n }\n\n } else if (a->is_keyword_argument()) {\n Map_Obj argmap = Cast(a->value());\n\n for (auto key : argmap->keys()) {\n String_Constant_Ptr val = Cast(key);\n if (val == NULL) {\n eval->exp.traces.push_back(Backtrace(key->pstate()));\n throw Exception::InvalidVarKwdType(key->pstate(), eval->exp.traces, key->inspect(), a);\n }\n std::string param = \"$\" + unquote(val->value());\n\n if (!param_map.count(param)) {\n std::stringstream msg;\n msg << callee << \" has no parameter named \" << param;\n error(msg.str(), a->pstate(), eval->exp.traces);\n }\n env->local_frame()[param] = argmap->at(key);\n }\n ++ia;\n continue;\n } else {\n ++ia;\n }\n\n if (a->name().empty()) {\n if (env->has_local(p->name())) {\n std::stringstream msg;\n msg << \"parameter \" << p->name()\n << \" provided more than once in call to \" << callee;\n error(msg.str(), a->pstate(), eval->exp.traces);\n }\n // ordinal arg -- bind it to the next param\n env->local_frame()[p->name()] = a->value();\n ++ip;\n }\n else {\n // named arg -- bind it to the appropriately named param\n if (!param_map.count(a->name())) {\n if (ps->has_rest_parameter()) {\n varargs->append(a);\n } else {\n std::stringstream msg;\n msg << callee << \" has no parameter named \" << a->name();\n error(msg.str(), a->pstate(), eval->exp.traces);\n }\n }\n if (param_map[a->name()]) {\n if (param_map[a->name()]->is_rest_parameter()) {\n std::stringstream msg;\n msg << \"argument \" << a->name() << \" of \" << callee\n << \"cannot be used as named argument\";\n error(msg.str(), a->pstate(), eval->exp.traces);\n }\n }\n if (env->has_local(a->name())) {\n std::stringstream msg;\n msg << \"parameter \" << p->name()\n << \"provided more than once in call to \" << callee;\n error(msg.str(), a->pstate(), eval->exp.traces);\n }\n env->local_frame()[a->name()] = a->value();\n }\n }\n // EO while ia\n\n // If we make it here, we're out of args but may have leftover params.\n // That's only okay if they have default values, or were already bound by\n // named arguments, or if it's a single rest-param.\n for (size_t i = ip; i < LP; ++i) {\n Parameter_Obj leftover = ps->at(i);\n // cerr << \"env for default params:\" << endl;\n // env->print();\n // cerr << \"********\" << endl;\n if (!env->has_local(leftover->name())) {\n if (leftover->is_rest_parameter()) {\n env->local_frame()[leftover->name()] = varargs;\n }\n else if (leftover->default_value()) {\n Expression_Ptr dv = leftover->default_value()->perform(eval);\n env->local_frame()[leftover->name()] = dv;\n }\n else {\n // param is unbound and has no default value -- error\n throw Exception::MissingArgument(as->pstate(), eval->exp.traces, name, leftover->name(), type);\n }\n }\n }\n\n return;\n }\n\n\n}\n" }, { "path": "libsass-build/bind.hpp", "content": "#ifndef SASS_BIND_H\n#define SASS_BIND_H\n\n#include \n#include \"environment.hpp\"\n#include \"ast_fwd_decl.hpp\"\n\nnamespace Sass {\n\n void bind(std::string type, std::string name, Parameters_Obj, Arguments_Obj, Context*, Env*, Eval*);\n}\n\n#endif\n" }, { "path": "libsass-build/c99func.c", "content": "/*\n Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com)\n All rights reserved.\n\n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n THE SOFTWARE.\n*/\n\n#if defined(_MSC_VER) && _MSC_VER < 1900\n\n#include \n#include \n#include \n\nstatic int c99_vsnprintf(char* str, size_t size, const char* format, va_list ap)\n{\n int count = -1;\n\n if (size != 0)\n count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);\n if (count == -1)\n count = _vscprintf(format, ap);\n\n return count;\n}\n\nint snprintf(char* str, size_t size, const char* format, ...)\n{\n int count;\n va_list ap;\n\n va_start(ap, format);\n count = c99_vsnprintf(str, size, format, ap);\n va_end(ap);\n\n return count;\n}\n\n#endif\n" }, { "path": "libsass-build/cencode.c", "content": "/*\ncencoder.c - c source to a base64 encoding algorithm implementation\n\nThis is part of the libb64 project, and has been placed in the public domain.\nFor details, see http://sourceforge.net/projects/libb64\n*/\n\n#include \"b64/cencode.h\"\n\nvoid base64_init_encodestate(base64_encodestate* state_in)\n{\n\tstate_in->step = step_A;\n\tstate_in->result = 0;\n\tstate_in->stepcount = 0;\n}\n\nchar base64_encode_value(char value_in)\n{\n\tstatic const char* encoding = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\tif (value_in > 63) return '=';\n\treturn encoding[(int)value_in];\n}\n\nint base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)\n{\n\tconst char* plainchar = plaintext_in;\n\tconst char* const plaintextend = plaintext_in + length_in;\n\tchar* codechar = code_out;\n\tchar result;\n\tchar fragment;\n\n\tresult = state_in->result;\n\n\tswitch (state_in->step)\n\t{\n\t\twhile (1)\n\t\t{\n\tcase step_A:\n\t\t\tif (plainchar == plaintextend)\n\t\t\t{\n\t\t\t\tstate_in->result = result;\n\t\t\t\tstate_in->step = step_A;\n\t\t\t\treturn (int)(codechar - code_out);\n\t\t\t}\n\t\t\tfragment = *plainchar++;\n\t\t\tresult = (fragment & 0x0fc) >> 2;\n\t\t\t*codechar++ = base64_encode_value(result);\n\t\t\tresult = (fragment & 0x003) << 4;\n\t\t\t#ifndef _MSC_VER\n\t\t\t\t/* fall through */\n\t\t\t#endif\n\tcase step_B:\n\t\t\tif (plainchar == plaintextend)\n\t\t\t{\n\t\t\t\tstate_in->result = result;\n\t\t\t\tstate_in->step = step_B;\n\t\t\t\treturn (int)(codechar - code_out);\n\t\t\t}\n\t\t\tfragment = *plainchar++;\n\t\t\tresult |= (fragment & 0x0f0) >> 4;\n\t\t\t*codechar++ = base64_encode_value(result);\n\t\t\tresult = (fragment & 0x00f) << 2;\n\t\t\t#ifndef _MSC_VER\n\t\t\t\t/* fall through */\n\t\t\t#endif\n\tcase step_C:\n\t\t\tif (plainchar == plaintextend)\n\t\t\t{\n\t\t\t\tstate_in->result = result;\n\t\t\t\tstate_in->step = step_C;\n\t\t\t\treturn (int)(codechar - code_out);\n\t\t\t}\n\t\t\tfragment = *plainchar++;\n\t\t\tresult |= (fragment & 0x0c0) >> 6;\n\t\t\t*codechar++ = base64_encode_value(result);\n\t\t\tresult = (fragment & 0x03f) >> 0;\n\t\t\t*codechar++ = base64_encode_value(result);\n\n\t\t\t++(state_in->stepcount);\n\t\t}\n\t}\n\t/* control should not reach here */\n\treturn (int)(codechar - code_out);\n}\n\nint base64_encode_blockend(char* code_out, base64_encodestate* state_in)\n{\n\tchar* codechar = code_out;\n\n\tswitch (state_in->step)\n\t{\n\tcase step_B:\n\t\t*codechar++ = base64_encode_value(state_in->result);\n\t\t*codechar++ = '=';\n\t\t*codechar++ = '=';\n\t\tbreak;\n\tcase step_C:\n\t\t*codechar++ = base64_encode_value(state_in->result);\n\t\t*codechar++ = '=';\n\t\tbreak;\n\tcase step_A:\n\t\tbreak;\n\t}\n\t*codechar++ = '\\n';\n\n\treturn (int)(codechar - code_out);\n}\n\n" }, { "path": "libsass-build/check_nesting.cpp", "content": "#include \"sass.hpp\"\n#include \n\n#include \"check_nesting.hpp\"\n\nnamespace Sass {\n\n CheckNesting::CheckNesting()\n : parents(std::vector()),\n traces(std::vector()),\n parent(0), current_mixin_definition(0)\n { }\n\n void error(AST_Node_Ptr node, Backtraces traces, std::string msg) {\n traces.push_back(Backtrace(node->pstate()));\n throw Exception::InvalidSass(node->pstate(), traces, msg);\n }\n\n Statement_Ptr CheckNesting::visit_children(Statement_Ptr parent)\n {\n Statement_Ptr old_parent = this->parent;\n\n if (At_Root_Block_Ptr root = Cast(parent)) {\n std::vector old_parents = this->parents;\n std::vector new_parents;\n\n for (size_t i = 0, L = this->parents.size(); i < L; i++) {\n Statement_Ptr p = this->parents.at(i);\n if (!root->exclude_node(p)) {\n new_parents.push_back(p);\n }\n }\n this->parents = new_parents;\n\n for (size_t i = this->parents.size(); i > 0; i--) {\n Statement_Ptr p = 0;\n Statement_Ptr gp = 0;\n if (i > 0) p = this->parents.at(i - 1);\n if (i > 1) gp = this->parents.at(i - 2);\n\n if (!this->is_transparent_parent(p, gp)) {\n this->parent = p;\n break;\n }\n }\n\n At_Root_Block_Ptr ar = Cast(parent);\n Block_Ptr ret = ar->block();\n\n if (ret != NULL) {\n for (auto n : ret->elements()) {\n n->perform(this);\n }\n }\n\n this->parent = old_parent;\n this->parents = old_parents;\n\n return ret;\n }\n\n if (!this->is_transparent_parent(parent, old_parent)) {\n this->parent = parent;\n }\n\n this->parents.push_back(parent);\n\n Block_Ptr b = Cast(parent);\n\n if (Trace_Ptr trace = Cast(parent)) {\n if (trace->type() == 'i') {\n this->traces.push_back(Backtrace(trace->pstate()));\n }\n }\n\n if (!b) {\n if (Has_Block_Ptr bb = Cast(parent)) {\n b = bb->block();\n }\n }\n\n if (b) {\n for (auto n : b->elements()) {\n n->perform(this);\n }\n }\n\n this->parent = old_parent;\n this->parents.pop_back();\n\n if (Trace_Ptr trace = Cast(parent)) {\n if (trace->type() == 'i') {\n this->traces.pop_back();\n }\n }\n\n return b;\n }\n\n\n Statement_Ptr CheckNesting::operator()(Block_Ptr b)\n {\n return this->visit_children(b);\n }\n\n Statement_Ptr CheckNesting::operator()(Definition_Ptr n)\n {\n if (!this->should_visit(n)) return NULL;\n if (!is_mixin(n)) {\n visit_children(n);\n return n;\n }\n\n Definition_Ptr old_mixin_definition = this->current_mixin_definition;\n this->current_mixin_definition = n;\n\n visit_children(n);\n\n this->current_mixin_definition = old_mixin_definition;\n\n return n;\n }\n\n Statement_Ptr CheckNesting::operator()(If_Ptr i)\n {\n this->visit_children(i);\n\n if (Block_Ptr b = Cast(i->alternative())) {\n for (auto n : b->elements()) n->perform(this);\n }\n\n return i;\n }\n\n Statement_Ptr CheckNesting::fallback_impl(Statement_Ptr s)\n {\n Block_Ptr b1 = Cast(s);\n Has_Block_Ptr b2 = Cast(s);\n return b1 || b2 ? visit_children(s) : s;\n }\n\n bool CheckNesting::should_visit(Statement_Ptr node)\n {\n if (!this->parent) return true;\n\n if (Cast(node))\n { this->invalid_content_parent(this->parent, node); }\n\n if (is_charset(node))\n { this->invalid_charset_parent(this->parent, node); }\n\n if (Cast(node))\n { this->invalid_extend_parent(this->parent, node); }\n\n // if (Cast(node))\n // { this->invalid_import_parent(this->parent); }\n\n if (this->is_mixin(node))\n { this->invalid_mixin_definition_parent(this->parent, node); }\n\n if (this->is_function(node))\n { this->invalid_function_parent(this->parent, node); }\n\n if (this->is_function(this->parent))\n { this->invalid_function_child(node); }\n\n if (Declaration_Ptr d = Cast(node))\n {\n this->invalid_prop_parent(this->parent, node);\n this->invalid_value_child(d->value());\n }\n\n if (Cast(this->parent))\n { this->invalid_prop_child(node); }\n\n if (Cast(node))\n { this->invalid_return_parent(this->parent, node); }\n\n return true;\n }\n\n void CheckNesting::invalid_content_parent(Statement_Ptr parent, AST_Node_Ptr node)\n {\n if (!this->current_mixin_definition) {\n error(node, traces, \"@content may only be used within a mixin.\");\n }\n }\n\n void CheckNesting::invalid_charset_parent(Statement_Ptr parent, AST_Node_Ptr node)\n {\n if (!(\n is_root_node(parent)\n )) {\n error(node, traces, \"@charset may only be used at the root of a document.\");\n }\n }\n\n void CheckNesting::invalid_extend_parent(Statement_Ptr parent, AST_Node_Ptr node)\n {\n if (!(\n Cast(parent) ||\n Cast(parent) ||\n is_mixin(parent)\n )) {\n error(node, traces, \"Extend directives may only be used within rules.\");\n }\n }\n\n // void CheckNesting::invalid_import_parent(Statement_Ptr parent, AST_Node_Ptr node)\n // {\n // for (auto pp : this->parents) {\n // if (\n // Cast(pp) ||\n // Cast(pp) ||\n // Cast(pp) ||\n // Cast(pp) ||\n // Cast(pp) ||\n // Cast(pp) ||\n // is_mixin(pp)\n // ) {\n // error(node, traces, \"Import directives may not be defined within control directives or other mixins.\");\n // }\n // }\n\n // if (this->is_root_node(parent)) {\n // return;\n // }\n\n // if (false/*n.css_import?*/) {\n // error(node, traces, \"CSS import directives may only be used at the root of a document.\");\n // }\n // }\n\n void CheckNesting::invalid_mixin_definition_parent(Statement_Ptr parent, AST_Node_Ptr node)\n {\n for (Statement_Ptr pp : this->parents) {\n if (\n Cast(pp) ||\n Cast(pp) ||\n Cast(pp) ||\n Cast(pp) ||\n Cast(pp) ||\n Cast(pp) ||\n is_mixin(pp)\n ) {\n error(node, traces, \"Mixins may not be defined within control directives or other mixins.\");\n }\n }\n }\n\n void CheckNesting::invalid_function_parent(Statement_Ptr parent, AST_Node_Ptr node)\n {\n for (Statement_Ptr pp : this->parents) {\n if (\n Cast(pp) ||\n Cast(pp) ||\n Cast(pp) ||\n Cast(pp) ||\n Cast(pp) ||\n Cast(pp) ||\n is_mixin(pp)\n ) {\n error(node, traces, \"Functions may not be defined within control directives or other mixins.\");\n }\n }\n }\n\n void CheckNesting::invalid_function_child(Statement_Ptr child)\n {\n if (!(\n Cast(child) ||\n Cast(child) ||\n Cast(child) ||\n Cast(child) ||\n Cast(child) ||\n Cast(child) ||\n Cast(child) ||\n Cast(child) ||\n Cast(child) ||\n // Ruby Sass doesn't distinguish variables and assignments\n Cast(child) ||\n Cast(child) ||\n Cast(child)\n )) {\n error(child, traces, \"Functions can only contain variable declarations and control directives.\");\n }\n }\n\n void CheckNesting::invalid_prop_child(Statement_Ptr child)\n {\n if (!(\n Cast(child) ||\n Cast(child) ||\n Cast(child) ||\n Cast(child) ||\n Cast(child) ||\n Cast(child) ||\n Cast(child) ||\n Cast(child)\n )) {\n error(child, traces, \"Illegal nesting: Only properties may be nested beneath properties.\");\n }\n }\n\n void CheckNesting::invalid_prop_parent(Statement_Ptr parent, AST_Node_Ptr node)\n {\n if (!(\n is_mixin(parent) ||\n is_directive_node(parent) ||\n Cast(parent) ||\n Cast(parent) ||\n Cast(parent) ||\n Cast(parent)\n )) {\n error(node, traces, \"Properties are only allowed within rules, directives, mixin includes, or other properties.\");\n }\n }\n\n void CheckNesting::invalid_value_child(AST_Node_Ptr d)\n {\n if (Map_Ptr m = Cast(d)) {\n traces.push_back(Backtrace(m->pstate()));\n throw Exception::InvalidValue(traces, *m);\n }\n if (Number_Ptr n = Cast(d)) {\n if (!n->is_valid_css_unit()) {\n traces.push_back(Backtrace(n->pstate()));\n throw Exception::InvalidValue(traces, *n);\n }\n }\n\n // error(dbg + \" isn't a valid CSS value.\", m->pstate(),);\n\n }\n\n void CheckNesting::invalid_return_parent(Statement_Ptr parent, AST_Node_Ptr node)\n {\n if (!this->is_function(parent)) {\n error(node, traces, \"@return may only be used within a function.\");\n }\n }\n\n bool CheckNesting::is_transparent_parent(Statement_Ptr parent, Statement_Ptr grandparent)\n {\n bool parent_bubbles = parent && parent->bubbles();\n\n bool valid_bubble_node = parent_bubbles &&\n !is_root_node(grandparent) &&\n !is_at_root_node(grandparent);\n\n return Cast(parent) ||\n Cast(parent) ||\n Cast(parent) ||\n Cast(parent) ||\n Cast(parent) ||\n Cast(parent) ||\n valid_bubble_node;\n }\n\n bool CheckNesting::is_charset(Statement_Ptr n)\n {\n Directive_Ptr d = Cast(n);\n return d && d->keyword() == \"charset\";\n }\n\n bool CheckNesting::is_mixin(Statement_Ptr n)\n {\n Definition_Ptr def = Cast(n);\n return def && def->type() == Definition::MIXIN;\n }\n\n bool CheckNesting::is_function(Statement_Ptr n)\n {\n Definition_Ptr def = Cast(n);\n return def && def->type() == Definition::FUNCTION;\n }\n\n bool CheckNesting::is_root_node(Statement_Ptr n)\n {\n if (Cast(n)) return false;\n\n Block_Ptr b = Cast(n);\n return b && b->is_root();\n }\n\n bool CheckNesting::is_at_root_node(Statement_Ptr n)\n {\n return Cast(n) != NULL;\n }\n\n bool CheckNesting::is_directive_node(Statement_Ptr n)\n {\n return Cast(n) ||\n Cast(n) ||\n Cast(n) ||\n Cast(n);\n }\n}\n" }, { "path": "libsass-build/check_nesting.hpp", "content": "#ifndef SASS_CHECK_NESTING_H\n#define SASS_CHECK_NESTING_H\n\n#include \"ast.hpp\"\n#include \"operation.hpp\"\n\nnamespace Sass {\n\n class CheckNesting : public Operation_CRTP {\n\n std::vector parents;\n Backtraces traces;\n Statement_Ptr parent;\n Definition_Ptr current_mixin_definition;\n\n Statement_Ptr fallback_impl(Statement_Ptr);\n Statement_Ptr before(Statement_Ptr);\n Statement_Ptr visit_children(Statement_Ptr);\n\n public:\n CheckNesting();\n ~CheckNesting() { }\n\n Statement_Ptr operator()(Block_Ptr);\n Statement_Ptr operator()(Definition_Ptr);\n Statement_Ptr operator()(If_Ptr);\n\n template \n Statement_Ptr fallback(U x) {\n Statement_Ptr n = Cast(x);\n if (this->should_visit(n)) {\n return fallback_impl(n);\n }\n return NULL;\n }\n\n private:\n void invalid_content_parent(Statement_Ptr, AST_Node_Ptr);\n void invalid_charset_parent(Statement_Ptr, AST_Node_Ptr);\n void invalid_extend_parent(Statement_Ptr, AST_Node_Ptr);\n // void invalid_import_parent(Statement_Ptr);\n void invalid_mixin_definition_parent(Statement_Ptr, AST_Node_Ptr);\n void invalid_function_parent(Statement_Ptr, AST_Node_Ptr);\n\n void invalid_function_child(Statement_Ptr);\n void invalid_prop_child(Statement_Ptr);\n void invalid_prop_parent(Statement_Ptr, AST_Node_Ptr);\n void invalid_return_parent(Statement_Ptr, AST_Node_Ptr);\n void invalid_value_child(AST_Node_Ptr);\n\n bool is_transparent_parent(Statement_Ptr, Statement_Ptr);\n\n bool should_visit(Statement_Ptr);\n\n bool is_charset(Statement_Ptr);\n bool is_mixin(Statement_Ptr);\n bool is_function(Statement_Ptr);\n bool is_root_node(Statement_Ptr);\n bool is_at_root_node(Statement_Ptr);\n bool is_directive_node(Statement_Ptr);\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/color_maps.cpp", "content": "#include \"sass.hpp\"\n#include \"ast.hpp\"\n#include \"color_maps.hpp\"\n\nnamespace Sass {\n\n namespace ColorNames\n {\n const char aliceblue [] = \"aliceblue\";\n const char antiquewhite [] = \"antiquewhite\";\n const char cyan [] = \"cyan\";\n const char aqua [] = \"aqua\";\n const char aquamarine [] = \"aquamarine\";\n const char azure [] = \"azure\";\n const char beige [] = \"beige\";\n const char bisque [] = \"bisque\";\n const char black [] = \"black\";\n const char blanchedalmond [] = \"blanchedalmond\";\n const char blue [] = \"blue\";\n const char blueviolet [] = \"blueviolet\";\n const char brown [] = \"brown\";\n const char burlywood [] = \"burlywood\";\n const char cadetblue [] = \"cadetblue\";\n const char chartreuse [] = \"chartreuse\";\n const char chocolate [] = \"chocolate\";\n const char coral [] = \"coral\";\n const char cornflowerblue [] = \"cornflowerblue\";\n const char cornsilk [] = \"cornsilk\";\n const char crimson [] = \"crimson\";\n const char darkblue [] = \"darkblue\";\n const char darkcyan [] = \"darkcyan\";\n const char darkgoldenrod [] = \"darkgoldenrod\";\n const char darkgray [] = \"darkgray\";\n const char darkgrey [] = \"darkgrey\";\n const char darkgreen [] = \"darkgreen\";\n const char darkkhaki [] = \"darkkhaki\";\n const char darkmagenta [] = \"darkmagenta\";\n const char darkolivegreen [] = \"darkolivegreen\";\n const char darkorange [] = \"darkorange\";\n const char darkorchid [] = \"darkorchid\";\n const char darkred [] = \"darkred\";\n const char darksalmon [] = \"darksalmon\";\n const char darkseagreen [] = \"darkseagreen\";\n const char darkslateblue [] = \"darkslateblue\";\n const char darkslategray [] = \"darkslategray\";\n const char darkslategrey [] = \"darkslategrey\";\n const char darkturquoise [] = \"darkturquoise\";\n const char darkviolet [] = \"darkviolet\";\n const char deeppink [] = \"deeppink\";\n const char deepskyblue [] = \"deepskyblue\";\n const char dimgray [] = \"dimgray\";\n const char dimgrey [] = \"dimgrey\";\n const char dodgerblue [] = \"dodgerblue\";\n const char firebrick [] = \"firebrick\";\n const char floralwhite [] = \"floralwhite\";\n const char forestgreen [] = \"forestgreen\";\n const char magenta [] = \"magenta\";\n const char fuchsia [] = \"fuchsia\";\n const char gainsboro [] = \"gainsboro\";\n const char ghostwhite [] = \"ghostwhite\";\n const char gold [] = \"gold\";\n const char goldenrod [] = \"goldenrod\";\n const char gray [] = \"gray\";\n const char grey [] = \"grey\";\n const char green [] = \"green\";\n const char greenyellow [] = \"greenyellow\";\n const char honeydew [] = \"honeydew\";\n const char hotpink [] = \"hotpink\";\n const char indianred [] = \"indianred\";\n const char indigo [] = \"indigo\";\n const char ivory [] = \"ivory\";\n const char khaki [] = \"khaki\";\n const char lavender [] = \"lavender\";\n const char lavenderblush [] = \"lavenderblush\";\n const char lawngreen [] = \"lawngreen\";\n const char lemonchiffon [] = \"lemonchiffon\";\n const char lightblue [] = \"lightblue\";\n const char lightcoral [] = \"lightcoral\";\n const char lightcyan [] = \"lightcyan\";\n const char lightgoldenrodyellow [] = \"lightgoldenrodyellow\";\n const char lightgray [] = \"lightgray\";\n const char lightgrey [] = \"lightgrey\";\n const char lightgreen [] = \"lightgreen\";\n const char lightpink [] = \"lightpink\";\n const char lightsalmon [] = \"lightsalmon\";\n const char lightseagreen [] = \"lightseagreen\";\n const char lightskyblue [] = \"lightskyblue\";\n const char lightslategray [] = \"lightslategray\";\n const char lightslategrey [] = \"lightslategrey\";\n const char lightsteelblue [] = \"lightsteelblue\";\n const char lightyellow [] = \"lightyellow\";\n const char lime [] = \"lime\";\n const char limegreen [] = \"limegreen\";\n const char linen [] = \"linen\";\n const char maroon [] = \"maroon\";\n const char mediumaquamarine [] = \"mediumaquamarine\";\n const char mediumblue [] = \"mediumblue\";\n const char mediumorchid [] = \"mediumorchid\";\n const char mediumpurple [] = \"mediumpurple\";\n const char mediumseagreen [] = \"mediumseagreen\";\n const char mediumslateblue [] = \"mediumslateblue\";\n const char mediumspringgreen [] = \"mediumspringgreen\";\n const char mediumturquoise [] = \"mediumturquoise\";\n const char mediumvioletred [] = \"mediumvioletred\";\n const char midnightblue [] = \"midnightblue\";\n const char mintcream [] = \"mintcream\";\n const char mistyrose [] = \"mistyrose\";\n const char moccasin [] = \"moccasin\";\n const char navajowhite [] = \"navajowhite\";\n const char navy [] = \"navy\";\n const char oldlace [] = \"oldlace\";\n const char olive [] = \"olive\";\n const char olivedrab [] = \"olivedrab\";\n const char orange [] = \"orange\";\n const char orangered [] = \"orangered\";\n const char orchid [] = \"orchid\";\n const char palegoldenrod [] = \"palegoldenrod\";\n const char palegreen [] = \"palegreen\";\n const char paleturquoise [] = \"paleturquoise\";\n const char palevioletred [] = \"palevioletred\";\n const char papayawhip [] = \"papayawhip\";\n const char peachpuff [] = \"peachpuff\";\n const char peru [] = \"peru\";\n const char pink [] = \"pink\";\n const char plum [] = \"plum\";\n const char powderblue [] = \"powderblue\";\n const char purple [] = \"purple\";\n const char red [] = \"red\";\n const char rosybrown [] = \"rosybrown\";\n const char royalblue [] = \"royalblue\";\n const char saddlebrown [] = \"saddlebrown\";\n const char salmon [] = \"salmon\";\n const char sandybrown [] = \"sandybrown\";\n const char seagreen [] = \"seagreen\";\n const char seashell [] = \"seashell\";\n const char sienna [] = \"sienna\";\n const char silver [] = \"silver\";\n const char skyblue [] = \"skyblue\";\n const char slateblue [] = \"slateblue\";\n const char slategray [] = \"slategray\";\n const char slategrey [] = \"slategrey\";\n const char snow [] = \"snow\";\n const char springgreen [] = \"springgreen\";\n const char steelblue [] = \"steelblue\";\n const char tan [] = \"tan\";\n const char teal [] = \"teal\";\n const char thistle [] = \"thistle\";\n const char tomato [] = \"tomato\";\n const char turquoise [] = \"turquoise\";\n const char violet [] = \"violet\";\n const char wheat [] = \"wheat\";\n const char white [] = \"white\";\n const char whitesmoke [] = \"whitesmoke\";\n const char yellow [] = \"yellow\";\n const char yellowgreen [] = \"yellowgreen\";\n const char rebeccapurple [] = \"rebeccapurple\";\n const char transparent [] = \"transparent\";\n }\n\n namespace Colors {\n const ParserState color_table(\"[COLOR TABLE]\");\n const Color aliceblue(color_table, 240, 248, 255, 1);\n const Color antiquewhite(color_table, 250, 235, 215, 1);\n const Color cyan(color_table, 0, 255, 255, 1);\n const Color aqua(color_table, 0, 255, 255, 1);\n const Color aquamarine(color_table, 127, 255, 212, 1);\n const Color azure(color_table, 240, 255, 255, 1);\n const Color beige(color_table, 245, 245, 220, 1);\n const Color bisque(color_table, 255, 228, 196, 1);\n const Color black(color_table, 0, 0, 0, 1);\n const Color blanchedalmond(color_table, 255, 235, 205, 1);\n const Color blue(color_table, 0, 0, 255, 1);\n const Color blueviolet(color_table, 138, 43, 226, 1);\n const Color brown(color_table, 165, 42, 42, 1);\n const Color burlywood(color_table, 222, 184, 135, 1);\n const Color cadetblue(color_table, 95, 158, 160, 1);\n const Color chartreuse(color_table, 127, 255, 0, 1);\n const Color chocolate(color_table, 210, 105, 30, 1);\n const Color coral(color_table, 255, 127, 80, 1);\n const Color cornflowerblue(color_table, 100, 149, 237, 1);\n const Color cornsilk(color_table, 255, 248, 220, 1);\n const Color crimson(color_table, 220, 20, 60, 1);\n const Color darkblue(color_table, 0, 0, 139, 1);\n const Color darkcyan(color_table, 0, 139, 139, 1);\n const Color darkgoldenrod(color_table, 184, 134, 11, 1);\n const Color darkgray(color_table, 169, 169, 169, 1);\n const Color darkgrey(color_table, 169, 169, 169, 1);\n const Color darkgreen(color_table, 0, 100, 0, 1);\n const Color darkkhaki(color_table, 189, 183, 107, 1);\n const Color darkmagenta(color_table, 139, 0, 139, 1);\n const Color darkolivegreen(color_table, 85, 107, 47, 1);\n const Color darkorange(color_table, 255, 140, 0, 1);\n const Color darkorchid(color_table, 153, 50, 204, 1);\n const Color darkred(color_table, 139, 0, 0, 1);\n const Color darksalmon(color_table, 233, 150, 122, 1);\n const Color darkseagreen(color_table, 143, 188, 143, 1);\n const Color darkslateblue(color_table, 72, 61, 139, 1);\n const Color darkslategray(color_table, 47, 79, 79, 1);\n const Color darkslategrey(color_table, 47, 79, 79, 1);\n const Color darkturquoise(color_table, 0, 206, 209, 1);\n const Color darkviolet(color_table, 148, 0, 211, 1);\n const Color deeppink(color_table, 255, 20, 147, 1);\n const Color deepskyblue(color_table, 0, 191, 255, 1);\n const Color dimgray(color_table, 105, 105, 105, 1);\n const Color dimgrey(color_table, 105, 105, 105, 1);\n const Color dodgerblue(color_table, 30, 144, 255, 1);\n const Color firebrick(color_table, 178, 34, 34, 1);\n const Color floralwhite(color_table, 255, 250, 240, 1);\n const Color forestgreen(color_table, 34, 139, 34, 1);\n const Color magenta(color_table, 255, 0, 255, 1);\n const Color fuchsia(color_table, 255, 0, 255, 1);\n const Color gainsboro(color_table, 220, 220, 220, 1);\n const Color ghostwhite(color_table, 248, 248, 255, 1);\n const Color gold(color_table, 255, 215, 0, 1);\n const Color goldenrod(color_table, 218, 165, 32, 1);\n const Color gray(color_table, 128, 128, 128, 1);\n const Color grey(color_table, 128, 128, 128, 1);\n const Color green(color_table, 0, 128, 0, 1);\n const Color greenyellow(color_table, 173, 255, 47, 1);\n const Color honeydew(color_table, 240, 255, 240, 1);\n const Color hotpink(color_table, 255, 105, 180, 1);\n const Color indianred(color_table, 205, 92, 92, 1);\n const Color indigo(color_table, 75, 0, 130, 1);\n const Color ivory(color_table, 255, 255, 240, 1);\n const Color khaki(color_table, 240, 230, 140, 1);\n const Color lavender(color_table, 230, 230, 250, 1);\n const Color lavenderblush(color_table, 255, 240, 245, 1);\n const Color lawngreen(color_table, 124, 252, 0, 1);\n const Color lemonchiffon(color_table, 255, 250, 205, 1);\n const Color lightblue(color_table, 173, 216, 230, 1);\n const Color lightcoral(color_table, 240, 128, 128, 1);\n const Color lightcyan(color_table, 224, 255, 255, 1);\n const Color lightgoldenrodyellow(color_table, 250, 250, 210, 1);\n const Color lightgray(color_table, 211, 211, 211, 1);\n const Color lightgrey(color_table, 211, 211, 211, 1);\n const Color lightgreen(color_table, 144, 238, 144, 1);\n const Color lightpink(color_table, 255, 182, 193, 1);\n const Color lightsalmon(color_table, 255, 160, 122, 1);\n const Color lightseagreen(color_table, 32, 178, 170, 1);\n const Color lightskyblue(color_table, 135, 206, 250, 1);\n const Color lightslategray(color_table, 119, 136, 153, 1);\n const Color lightslategrey(color_table, 119, 136, 153, 1);\n const Color lightsteelblue(color_table, 176, 196, 222, 1);\n const Color lightyellow(color_table, 255, 255, 224, 1);\n const Color lime(color_table, 0, 255, 0, 1);\n const Color limegreen(color_table, 50, 205, 50, 1);\n const Color linen(color_table, 250, 240, 230, 1);\n const Color maroon(color_table, 128, 0, 0, 1);\n const Color mediumaquamarine(color_table, 102, 205, 170, 1);\n const Color mediumblue(color_table, 0, 0, 205, 1);\n const Color mediumorchid(color_table, 186, 85, 211, 1);\n const Color mediumpurple(color_table, 147, 112, 219, 1);\n const Color mediumseagreen(color_table, 60, 179, 113, 1);\n const Color mediumslateblue(color_table, 123, 104, 238, 1);\n const Color mediumspringgreen(color_table, 0, 250, 154, 1);\n const Color mediumturquoise(color_table, 72, 209, 204, 1);\n const Color mediumvioletred(color_table, 199, 21, 133, 1);\n const Color midnightblue(color_table, 25, 25, 112, 1);\n const Color mintcream(color_table, 245, 255, 250, 1);\n const Color mistyrose(color_table, 255, 228, 225, 1);\n const Color moccasin(color_table, 255, 228, 181, 1);\n const Color navajowhite(color_table, 255, 222, 173, 1);\n const Color navy(color_table, 0, 0, 128, 1);\n const Color oldlace(color_table, 253, 245, 230, 1);\n const Color olive(color_table, 128, 128, 0, 1);\n const Color olivedrab(color_table, 107, 142, 35, 1);\n const Color orange(color_table, 255, 165, 0, 1);\n const Color orangered(color_table, 255, 69, 0, 1);\n const Color orchid(color_table, 218, 112, 214, 1);\n const Color palegoldenrod(color_table, 238, 232, 170, 1);\n const Color palegreen(color_table, 152, 251, 152, 1);\n const Color paleturquoise(color_table, 175, 238, 238, 1);\n const Color palevioletred(color_table, 219, 112, 147, 1);\n const Color papayawhip(color_table, 255, 239, 213, 1);\n const Color peachpuff(color_table, 255, 218, 185, 1);\n const Color peru(color_table, 205, 133, 63, 1);\n const Color pink(color_table, 255, 192, 203, 1);\n const Color plum(color_table, 221, 160, 221, 1);\n const Color powderblue(color_table, 176, 224, 230, 1);\n const Color purple(color_table, 128, 0, 128, 1);\n const Color red(color_table, 255, 0, 0, 1);\n const Color rosybrown(color_table, 188, 143, 143, 1);\n const Color royalblue(color_table, 65, 105, 225, 1);\n const Color saddlebrown(color_table, 139, 69, 19, 1);\n const Color salmon(color_table, 250, 128, 114, 1);\n const Color sandybrown(color_table, 244, 164, 96, 1);\n const Color seagreen(color_table, 46, 139, 87, 1);\n const Color seashell(color_table, 255, 245, 238, 1);\n const Color sienna(color_table, 160, 82, 45, 1);\n const Color silver(color_table, 192, 192, 192, 1);\n const Color skyblue(color_table, 135, 206, 235, 1);\n const Color slateblue(color_table, 106, 90, 205, 1);\n const Color slategray(color_table, 112, 128, 144, 1);\n const Color slategrey(color_table, 112, 128, 144, 1);\n const Color snow(color_table, 255, 250, 250, 1);\n const Color springgreen(color_table, 0, 255, 127, 1);\n const Color steelblue(color_table, 70, 130, 180, 1);\n const Color tan(color_table, 210, 180, 140, 1);\n const Color teal(color_table, 0, 128, 128, 1);\n const Color thistle(color_table, 216, 191, 216, 1);\n const Color tomato(color_table, 255, 99, 71, 1);\n const Color turquoise(color_table, 64, 224, 208, 1);\n const Color violet(color_table, 238, 130, 238, 1);\n const Color wheat(color_table, 245, 222, 179, 1);\n const Color white(color_table, 255, 255, 255, 1);\n const Color whitesmoke(color_table, 245, 245, 245, 1);\n const Color yellow(color_table, 255, 255, 0, 1);\n const Color yellowgreen(color_table, 154, 205, 50, 1);\n const Color rebeccapurple(color_table, 102, 51, 153, 1);\n const Color transparent(color_table, 0, 0, 0, 0);\n }\n\n const std::map colors_to_names {\n { 240 * 0x10000 + 248 * 0x100 + 255, ColorNames::aliceblue },\n { 250 * 0x10000 + 235 * 0x100 + 215, ColorNames::antiquewhite },\n { 0 * 0x10000 + 255 * 0x100 + 255, ColorNames::cyan },\n { 127 * 0x10000 + 255 * 0x100 + 212, ColorNames::aquamarine },\n { 240 * 0x10000 + 255 * 0x100 + 255, ColorNames::azure },\n { 245 * 0x10000 + 245 * 0x100 + 220, ColorNames::beige },\n { 255 * 0x10000 + 228 * 0x100 + 196, ColorNames::bisque },\n { 0 * 0x10000 + 0 * 0x100 + 0, ColorNames::black },\n { 255 * 0x10000 + 235 * 0x100 + 205, ColorNames::blanchedalmond },\n { 0 * 0x10000 + 0 * 0x100 + 255, ColorNames::blue },\n { 138 * 0x10000 + 43 * 0x100 + 226, ColorNames::blueviolet },\n { 165 * 0x10000 + 42 * 0x100 + 42, ColorNames::brown },\n { 222 * 0x10000 + 184 * 0x100 + 135, ColorNames::burlywood },\n { 95 * 0x10000 + 158 * 0x100 + 160, ColorNames::cadetblue },\n { 127 * 0x10000 + 255 * 0x100 + 0, ColorNames::chartreuse },\n { 210 * 0x10000 + 105 * 0x100 + 30, ColorNames::chocolate },\n { 255 * 0x10000 + 127 * 0x100 + 80, ColorNames::coral },\n { 100 * 0x10000 + 149 * 0x100 + 237, ColorNames::cornflowerblue },\n { 255 * 0x10000 + 248 * 0x100 + 220, ColorNames::cornsilk },\n { 220 * 0x10000 + 20 * 0x100 + 60, ColorNames::crimson },\n { 0 * 0x10000 + 0 * 0x100 + 139, ColorNames::darkblue },\n { 0 * 0x10000 + 139 * 0x100 + 139, ColorNames::darkcyan },\n { 184 * 0x10000 + 134 * 0x100 + 11, ColorNames::darkgoldenrod },\n { 169 * 0x10000 + 169 * 0x100 + 169, ColorNames::darkgray },\n { 0 * 0x10000 + 100 * 0x100 + 0, ColorNames::darkgreen },\n { 189 * 0x10000 + 183 * 0x100 + 107, ColorNames::darkkhaki },\n { 139 * 0x10000 + 0 * 0x100 + 139, ColorNames::darkmagenta },\n { 85 * 0x10000 + 107 * 0x100 + 47, ColorNames::darkolivegreen },\n { 255 * 0x10000 + 140 * 0x100 + 0, ColorNames::darkorange },\n { 153 * 0x10000 + 50 * 0x100 + 204, ColorNames::darkorchid },\n { 139 * 0x10000 + 0 * 0x100 + 0, ColorNames::darkred },\n { 233 * 0x10000 + 150 * 0x100 + 122, ColorNames::darksalmon },\n { 143 * 0x10000 + 188 * 0x100 + 143, ColorNames::darkseagreen },\n { 72 * 0x10000 + 61 * 0x100 + 139, ColorNames::darkslateblue },\n { 47 * 0x10000 + 79 * 0x100 + 79, ColorNames::darkslategray },\n { 0 * 0x10000 + 206 * 0x100 + 209, ColorNames::darkturquoise },\n { 148 * 0x10000 + 0 * 0x100 + 211, ColorNames::darkviolet },\n { 255 * 0x10000 + 20 * 0x100 + 147, ColorNames::deeppink },\n { 0 * 0x10000 + 191 * 0x100 + 255, ColorNames::deepskyblue },\n { 105 * 0x10000 + 105 * 0x100 + 105, ColorNames::dimgray },\n { 30 * 0x10000 + 144 * 0x100 + 255, ColorNames::dodgerblue },\n { 178 * 0x10000 + 34 * 0x100 + 34, ColorNames::firebrick },\n { 255 * 0x10000 + 250 * 0x100 + 240, ColorNames::floralwhite },\n { 34 * 0x10000 + 139 * 0x100 + 34, ColorNames::forestgreen },\n { 255 * 0x10000 + 0 * 0x100 + 255, ColorNames::magenta },\n { 220 * 0x10000 + 220 * 0x100 + 220, ColorNames::gainsboro },\n { 248 * 0x10000 + 248 * 0x100 + 255, ColorNames::ghostwhite },\n { 255 * 0x10000 + 215 * 0x100 + 0, ColorNames::gold },\n { 218 * 0x10000 + 165 * 0x100 + 32, ColorNames::goldenrod },\n { 128 * 0x10000 + 128 * 0x100 + 128, ColorNames::gray },\n { 0 * 0x10000 + 128 * 0x100 + 0, ColorNames::green },\n { 173 * 0x10000 + 255 * 0x100 + 47, ColorNames::greenyellow },\n { 240 * 0x10000 + 255 * 0x100 + 240, ColorNames::honeydew },\n { 255 * 0x10000 + 105 * 0x100 + 180, ColorNames::hotpink },\n { 205 * 0x10000 + 92 * 0x100 + 92, ColorNames::indianred },\n { 75 * 0x10000 + 0 * 0x100 + 130, ColorNames::indigo },\n { 255 * 0x10000 + 255 * 0x100 + 240, ColorNames::ivory },\n { 240 * 0x10000 + 230 * 0x100 + 140, ColorNames::khaki },\n { 230 * 0x10000 + 230 * 0x100 + 250, ColorNames::lavender },\n { 255 * 0x10000 + 240 * 0x100 + 245, ColorNames::lavenderblush },\n { 124 * 0x10000 + 252 * 0x100 + 0, ColorNames::lawngreen },\n { 255 * 0x10000 + 250 * 0x100 + 205, ColorNames::lemonchiffon },\n { 173 * 0x10000 + 216 * 0x100 + 230, ColorNames::lightblue },\n { 240 * 0x10000 + 128 * 0x100 + 128, ColorNames::lightcoral },\n { 224 * 0x10000 + 255 * 0x100 + 255, ColorNames::lightcyan },\n { 250 * 0x10000 + 250 * 0x100 + 210, ColorNames::lightgoldenrodyellow },\n { 211 * 0x10000 + 211 * 0x100 + 211, ColorNames::lightgray },\n { 144 * 0x10000 + 238 * 0x100 + 144, ColorNames::lightgreen },\n { 255 * 0x10000 + 182 * 0x100 + 193, ColorNames::lightpink },\n { 255 * 0x10000 + 160 * 0x100 + 122, ColorNames::lightsalmon },\n { 32 * 0x10000 + 178 * 0x100 + 170, ColorNames::lightseagreen },\n { 135 * 0x10000 + 206 * 0x100 + 250, ColorNames::lightskyblue },\n { 119 * 0x10000 + 136 * 0x100 + 153, ColorNames::lightslategray },\n { 176 * 0x10000 + 196 * 0x100 + 222, ColorNames::lightsteelblue },\n { 255 * 0x10000 + 255 * 0x100 + 224, ColorNames::lightyellow },\n { 0 * 0x10000 + 255 * 0x100 + 0, ColorNames::lime },\n { 50 * 0x10000 + 205 * 0x100 + 50, ColorNames::limegreen },\n { 250 * 0x10000 + 240 * 0x100 + 230, ColorNames::linen },\n { 128 * 0x10000 + 0 * 0x100 + 0, ColorNames::maroon },\n { 102 * 0x10000 + 205 * 0x100 + 170, ColorNames::mediumaquamarine },\n { 0 * 0x10000 + 0 * 0x100 + 205, ColorNames::mediumblue },\n { 186 * 0x10000 + 85 * 0x100 + 211, ColorNames::mediumorchid },\n { 147 * 0x10000 + 112 * 0x100 + 219, ColorNames::mediumpurple },\n { 60 * 0x10000 + 179 * 0x100 + 113, ColorNames::mediumseagreen },\n { 123 * 0x10000 + 104 * 0x100 + 238, ColorNames::mediumslateblue },\n { 0 * 0x10000 + 250 * 0x100 + 154, ColorNames::mediumspringgreen },\n { 72 * 0x10000 + 209 * 0x100 + 204, ColorNames::mediumturquoise },\n { 199 * 0x10000 + 21 * 0x100 + 133, ColorNames::mediumvioletred },\n { 25 * 0x10000 + 25 * 0x100 + 112, ColorNames::midnightblue },\n { 245 * 0x10000 + 255 * 0x100 + 250, ColorNames::mintcream },\n { 255 * 0x10000 + 228 * 0x100 + 225, ColorNames::mistyrose },\n { 255 * 0x10000 + 228 * 0x100 + 181, ColorNames::moccasin },\n { 255 * 0x10000 + 222 * 0x100 + 173, ColorNames::navajowhite },\n { 0 * 0x10000 + 0 * 0x100 + 128, ColorNames::navy },\n { 253 * 0x10000 + 245 * 0x100 + 230, ColorNames::oldlace },\n { 128 * 0x10000 + 128 * 0x100 + 0, ColorNames::olive },\n { 107 * 0x10000 + 142 * 0x100 + 35, ColorNames::olivedrab },\n { 255 * 0x10000 + 165 * 0x100 + 0, ColorNames::orange },\n { 255 * 0x10000 + 69 * 0x100 + 0, ColorNames::orangered },\n { 218 * 0x10000 + 112 * 0x100 + 214, ColorNames::orchid },\n { 238 * 0x10000 + 232 * 0x100 + 170, ColorNames::palegoldenrod },\n { 152 * 0x10000 + 251 * 0x100 + 152, ColorNames::palegreen },\n { 175 * 0x10000 + 238 * 0x100 + 238, ColorNames::paleturquoise },\n { 219 * 0x10000 + 112 * 0x100 + 147, ColorNames::palevioletred },\n { 255 * 0x10000 + 239 * 0x100 + 213, ColorNames::papayawhip },\n { 255 * 0x10000 + 218 * 0x100 + 185, ColorNames::peachpuff },\n { 205 * 0x10000 + 133 * 0x100 + 63, ColorNames::peru },\n { 255 * 0x10000 + 192 * 0x100 + 203, ColorNames::pink },\n { 221 * 0x10000 + 160 * 0x100 + 221, ColorNames::plum },\n { 176 * 0x10000 + 224 * 0x100 + 230, ColorNames::powderblue },\n { 128 * 0x10000 + 0 * 0x100 + 128, ColorNames::purple },\n { 255 * 0x10000 + 0 * 0x100 + 0, ColorNames::red },\n { 188 * 0x10000 + 143 * 0x100 + 143, ColorNames::rosybrown },\n { 65 * 0x10000 + 105 * 0x100 + 225, ColorNames::royalblue },\n { 139 * 0x10000 + 69 * 0x100 + 19, ColorNames::saddlebrown },\n { 250 * 0x10000 + 128 * 0x100 + 114, ColorNames::salmon },\n { 244 * 0x10000 + 164 * 0x100 + 96, ColorNames::sandybrown },\n { 46 * 0x10000 + 139 * 0x100 + 87, ColorNames::seagreen },\n { 255 * 0x10000 + 245 * 0x100 + 238, ColorNames::seashell },\n { 160 * 0x10000 + 82 * 0x100 + 45, ColorNames::sienna },\n { 192 * 0x10000 + 192 * 0x100 + 192, ColorNames::silver },\n { 135 * 0x10000 + 206 * 0x100 + 235, ColorNames::skyblue },\n { 106 * 0x10000 + 90 * 0x100 + 205, ColorNames::slateblue },\n { 112 * 0x10000 + 128 * 0x100 + 144, ColorNames::slategray },\n { 255 * 0x10000 + 250 * 0x100 + 250, ColorNames::snow },\n { 0 * 0x10000 + 255 * 0x100 + 127, ColorNames::springgreen },\n { 70 * 0x10000 + 130 * 0x100 + 180, ColorNames::steelblue },\n { 210 * 0x10000 + 180 * 0x100 + 140, ColorNames::tan },\n { 0 * 0x10000 + 128 * 0x100 + 128, ColorNames::teal },\n { 216 * 0x10000 + 191 * 0x100 + 216, ColorNames::thistle },\n { 255 * 0x10000 + 99 * 0x100 + 71, ColorNames::tomato },\n { 64 * 0x10000 + 224 * 0x100 + 208, ColorNames::turquoise },\n { 238 * 0x10000 + 130 * 0x100 + 238, ColorNames::violet },\n { 245 * 0x10000 + 222 * 0x100 + 179, ColorNames::wheat },\n { 255 * 0x10000 + 255 * 0x100 + 255, ColorNames::white },\n { 245 * 0x10000 + 245 * 0x100 + 245, ColorNames::whitesmoke },\n { 255 * 0x10000 + 255 * 0x100 + 0, ColorNames::yellow },\n { 154 * 0x10000 + 205 * 0x100 + 50, ColorNames::yellowgreen },\n { 102 * 0x10000 + 51 * 0x100 + 153, ColorNames::rebeccapurple }\n };\n\n const std::map names_to_colors\n {\n { ColorNames::aliceblue, &Colors::aliceblue },\n { ColorNames::antiquewhite, &Colors::antiquewhite },\n { ColorNames::cyan, &Colors::cyan },\n { ColorNames::aqua, &Colors::aqua },\n { ColorNames::aquamarine, &Colors::aquamarine },\n { ColorNames::azure, &Colors::azure },\n { ColorNames::beige, &Colors::beige },\n { ColorNames::bisque, &Colors::bisque },\n { ColorNames::black, &Colors::black },\n { ColorNames::blanchedalmond, &Colors::blanchedalmond },\n { ColorNames::blue, &Colors::blue },\n { ColorNames::blueviolet, &Colors::blueviolet },\n { ColorNames::brown, &Colors::brown },\n { ColorNames::burlywood, &Colors::burlywood },\n { ColorNames::cadetblue, &Colors::cadetblue },\n { ColorNames::chartreuse, &Colors::chartreuse },\n { ColorNames::chocolate, &Colors::chocolate },\n { ColorNames::coral, &Colors::coral },\n { ColorNames::cornflowerblue, &Colors::cornflowerblue },\n { ColorNames::cornsilk, &Colors::cornsilk },\n { ColorNames::crimson, &Colors::crimson },\n { ColorNames::darkblue, &Colors::darkblue },\n { ColorNames::darkcyan, &Colors::darkcyan },\n { ColorNames::darkgoldenrod, &Colors::darkgoldenrod },\n { ColorNames::darkgray, &Colors::darkgray },\n { ColorNames::darkgrey, &Colors::darkgrey },\n { ColorNames::darkgreen, &Colors::darkgreen },\n { ColorNames::darkkhaki, &Colors::darkkhaki },\n { ColorNames::darkmagenta, &Colors::darkmagenta },\n { ColorNames::darkolivegreen, &Colors::darkolivegreen },\n { ColorNames::darkorange, &Colors::darkorange },\n { ColorNames::darkorchid, &Colors::darkorchid },\n { ColorNames::darkred, &Colors::darkred },\n { ColorNames::darksalmon, &Colors::darksalmon },\n { ColorNames::darkseagreen, &Colors::darkseagreen },\n { ColorNames::darkslateblue, &Colors::darkslateblue },\n { ColorNames::darkslategray, &Colors::darkslategray },\n { ColorNames::darkslategrey, &Colors::darkslategrey },\n { ColorNames::darkturquoise, &Colors::darkturquoise },\n { ColorNames::darkviolet, &Colors::darkviolet },\n { ColorNames::deeppink, &Colors::deeppink },\n { ColorNames::deepskyblue, &Colors::deepskyblue },\n { ColorNames::dimgray, &Colors::dimgray },\n { ColorNames::dimgrey, &Colors::dimgrey },\n { ColorNames::dodgerblue, &Colors::dodgerblue },\n { ColorNames::firebrick, &Colors::firebrick },\n { ColorNames::floralwhite, &Colors::floralwhite },\n { ColorNames::forestgreen, &Colors::forestgreen },\n { ColorNames::magenta, &Colors::magenta },\n { ColorNames::fuchsia, &Colors::fuchsia },\n { ColorNames::gainsboro, &Colors::gainsboro },\n { ColorNames::ghostwhite, &Colors::ghostwhite },\n { ColorNames::gold, &Colors::gold },\n { ColorNames::goldenrod, &Colors::goldenrod },\n { ColorNames::gray, &Colors::gray },\n { ColorNames::grey, &Colors::grey },\n { ColorNames::green, &Colors::green },\n { ColorNames::greenyellow, &Colors::greenyellow },\n { ColorNames::honeydew, &Colors::honeydew },\n { ColorNames::hotpink, &Colors::hotpink },\n { ColorNames::indianred, &Colors::indianred },\n { ColorNames::indigo, &Colors::indigo },\n { ColorNames::ivory, &Colors::ivory },\n { ColorNames::khaki, &Colors::khaki },\n { ColorNames::lavender, &Colors::lavender },\n { ColorNames::lavenderblush, &Colors::lavenderblush },\n { ColorNames::lawngreen, &Colors::lawngreen },\n { ColorNames::lemonchiffon, &Colors::lemonchiffon },\n { ColorNames::lightblue, &Colors::lightblue },\n { ColorNames::lightcoral, &Colors::lightcoral },\n { ColorNames::lightcyan, &Colors::lightcyan },\n { ColorNames::lightgoldenrodyellow, &Colors::lightgoldenrodyellow },\n { ColorNames::lightgray, &Colors::lightgray },\n { ColorNames::lightgrey, &Colors::lightgrey },\n { ColorNames::lightgreen, &Colors::lightgreen },\n { ColorNames::lightpink, &Colors::lightpink },\n { ColorNames::lightsalmon, &Colors::lightsalmon },\n { ColorNames::lightseagreen, &Colors::lightseagreen },\n { ColorNames::lightskyblue, &Colors::lightskyblue },\n { ColorNames::lightslategray, &Colors::lightslategray },\n { ColorNames::lightslategrey, &Colors::lightslategrey },\n { ColorNames::lightsteelblue, &Colors::lightsteelblue },\n { ColorNames::lightyellow, &Colors::lightyellow },\n { ColorNames::lime, &Colors::lime },\n { ColorNames::limegreen, &Colors::limegreen },\n { ColorNames::linen, &Colors::linen },\n { ColorNames::maroon, &Colors::maroon },\n { ColorNames::mediumaquamarine, &Colors::mediumaquamarine },\n { ColorNames::mediumblue, &Colors::mediumblue },\n { ColorNames::mediumorchid, &Colors::mediumorchid },\n { ColorNames::mediumpurple, &Colors::mediumpurple },\n { ColorNames::mediumseagreen, &Colors::mediumseagreen },\n { ColorNames::mediumslateblue, &Colors::mediumslateblue },\n { ColorNames::mediumspringgreen, &Colors::mediumspringgreen },\n { ColorNames::mediumturquoise, &Colors::mediumturquoise },\n { ColorNames::mediumvioletred, &Colors::mediumvioletred },\n { ColorNames::midnightblue, &Colors::midnightblue },\n { ColorNames::mintcream, &Colors::mintcream },\n { ColorNames::mistyrose, &Colors::mistyrose },\n { ColorNames::moccasin, &Colors::moccasin },\n { ColorNames::navajowhite, &Colors::navajowhite },\n { ColorNames::navy, &Colors::navy },\n { ColorNames::oldlace, &Colors::oldlace },\n { ColorNames::olive, &Colors::olive },\n { ColorNames::olivedrab, &Colors::olivedrab },\n { ColorNames::orange, &Colors::orange },\n { ColorNames::orangered, &Colors::orangered },\n { ColorNames::orchid, &Colors::orchid },\n { ColorNames::palegoldenrod, &Colors::palegoldenrod },\n { ColorNames::palegreen, &Colors::palegreen },\n { ColorNames::paleturquoise, &Colors::paleturquoise },\n { ColorNames::palevioletred, &Colors::palevioletred },\n { ColorNames::papayawhip, &Colors::papayawhip },\n { ColorNames::peachpuff, &Colors::peachpuff },\n { ColorNames::peru, &Colors::peru },\n { ColorNames::pink, &Colors::pink },\n { ColorNames::plum, &Colors::plum },\n { ColorNames::powderblue, &Colors::powderblue },\n { ColorNames::purple, &Colors::purple },\n { ColorNames::red, &Colors::red },\n { ColorNames::rosybrown, &Colors::rosybrown },\n { ColorNames::royalblue, &Colors::royalblue },\n { ColorNames::saddlebrown, &Colors::saddlebrown },\n { ColorNames::salmon, &Colors::salmon },\n { ColorNames::sandybrown, &Colors::sandybrown },\n { ColorNames::seagreen, &Colors::seagreen },\n { ColorNames::seashell, &Colors::seashell },\n { ColorNames::sienna, &Colors::sienna },\n { ColorNames::silver, &Colors::silver },\n { ColorNames::skyblue, &Colors::skyblue },\n { ColorNames::slateblue, &Colors::slateblue },\n { ColorNames::slategray, &Colors::slategray },\n { ColorNames::slategrey, &Colors::slategrey },\n { ColorNames::snow, &Colors::snow },\n { ColorNames::springgreen, &Colors::springgreen },\n { ColorNames::steelblue, &Colors::steelblue },\n { ColorNames::tan, &Colors::tan },\n { ColorNames::teal, &Colors::teal },\n { ColorNames::thistle, &Colors::thistle },\n { ColorNames::tomato, &Colors::tomato },\n { ColorNames::turquoise, &Colors::turquoise },\n { ColorNames::violet, &Colors::violet },\n { ColorNames::wheat, &Colors::wheat },\n { ColorNames::white, &Colors::white },\n { ColorNames::whitesmoke, &Colors::whitesmoke },\n { ColorNames::yellow, &Colors::yellow },\n { ColorNames::yellowgreen, &Colors::yellowgreen },\n { ColorNames::rebeccapurple, &Colors::rebeccapurple },\n { ColorNames::transparent, &Colors::transparent }\n };\n\n Color_Ptr_Const name_to_color(const char* key)\n {\n return name_to_color(std::string(key));\n }\n\n Color_Ptr_Const name_to_color(const std::string& key)\n {\n // case insensitive lookup. See #2462\n std::string lower{key};\n std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);\n\n auto p = names_to_colors.find(lower.c_str());\n if (p != names_to_colors.end()) {\n return p->second;\n }\n return 0;\n }\n\n const char* color_to_name(const int key)\n {\n auto p = colors_to_names.find(key);\n if (p != colors_to_names.end()) {\n return p->second;\n }\n return 0;\n }\n\n const char* color_to_name(const double key)\n {\n return color_to_name((int)key);\n }\n\n const char* color_to_name(const Color& c)\n {\n double key = c.r() * 0x10000\n + c.g() * 0x100\n + c.b();\n return color_to_name(key);\n }\n\n}\n" }, { "path": "libsass-build/color_maps.hpp", "content": "\n#ifndef SASS_COLOR_MAPS_H\n#define SASS_COLOR_MAPS_H\n\n#include \n#include \"ast.hpp\"\n\nnamespace Sass {\n\n struct map_cmp_str\n {\n bool operator()(char const *a, char const *b) const\n {\n return std::strcmp(a, b) < 0;\n }\n };\n\n namespace ColorNames\n {\n extern const char aliceblue[];\n extern const char antiquewhite[];\n extern const char cyan[];\n extern const char aqua[];\n extern const char aquamarine[];\n extern const char azure[];\n extern const char beige[];\n extern const char bisque[];\n extern const char black[];\n extern const char blanchedalmond[];\n extern const char blue[];\n extern const char blueviolet[];\n extern const char brown[];\n extern const char burlywood[];\n extern const char cadetblue[];\n extern const char chartreuse[];\n extern const char chocolate[];\n extern const char coral[];\n extern const char cornflowerblue[];\n extern const char cornsilk[];\n extern const char crimson[];\n extern const char darkblue[];\n extern const char darkcyan[];\n extern const char darkgoldenrod[];\n extern const char darkgray[];\n extern const char darkgrey[];\n extern const char darkgreen[];\n extern const char darkkhaki[];\n extern const char darkmagenta[];\n extern const char darkolivegreen[];\n extern const char darkorange[];\n extern const char darkorchid[];\n extern const char darkred[];\n extern const char darksalmon[];\n extern const char darkseagreen[];\n extern const char darkslateblue[];\n extern const char darkslategray[];\n extern const char darkslategrey[];\n extern const char darkturquoise[];\n extern const char darkviolet[];\n extern const char deeppink[];\n extern const char deepskyblue[];\n extern const char dimgray[];\n extern const char dimgrey[];\n extern const char dodgerblue[];\n extern const char firebrick[];\n extern const char floralwhite[];\n extern const char forestgreen[];\n extern const char magenta[];\n extern const char fuchsia[];\n extern const char gainsboro[];\n extern const char ghostwhite[];\n extern const char gold[];\n extern const char goldenrod[];\n extern const char gray[];\n extern const char grey[];\n extern const char green[];\n extern const char greenyellow[];\n extern const char honeydew[];\n extern const char hotpink[];\n extern const char indianred[];\n extern const char indigo[];\n extern const char ivory[];\n extern const char khaki[];\n extern const char lavender[];\n extern const char lavenderblush[];\n extern const char lawngreen[];\n extern const char lemonchiffon[];\n extern const char lightblue[];\n extern const char lightcoral[];\n extern const char lightcyan[];\n extern const char lightgoldenrodyellow[];\n extern const char lightgray[];\n extern const char lightgrey[];\n extern const char lightgreen[];\n extern const char lightpink[];\n extern const char lightsalmon[];\n extern const char lightseagreen[];\n extern const char lightskyblue[];\n extern const char lightslategray[];\n extern const char lightslategrey[];\n extern const char lightsteelblue[];\n extern const char lightyellow[];\n extern const char lime[];\n extern const char limegreen[];\n extern const char linen[];\n extern const char maroon[];\n extern const char mediumaquamarine[];\n extern const char mediumblue[];\n extern const char mediumorchid[];\n extern const char mediumpurple[];\n extern const char mediumseagreen[];\n extern const char mediumslateblue[];\n extern const char mediumspringgreen[];\n extern const char mediumturquoise[];\n extern const char mediumvioletred[];\n extern const char midnightblue[];\n extern const char mintcream[];\n extern const char mistyrose[];\n extern const char moccasin[];\n extern const char navajowhite[];\n extern const char navy[];\n extern const char oldlace[];\n extern const char olive[];\n extern const char olivedrab[];\n extern const char orange[];\n extern const char orangered[];\n extern const char orchid[];\n extern const char palegoldenrod[];\n extern const char palegreen[];\n extern const char paleturquoise[];\n extern const char palevioletred[];\n extern const char papayawhip[];\n extern const char peachpuff[];\n extern const char peru[];\n extern const char pink[];\n extern const char plum[];\n extern const char powderblue[];\n extern const char purple[];\n extern const char red[];\n extern const char rosybrown[];\n extern const char royalblue[];\n extern const char saddlebrown[];\n extern const char salmon[];\n extern const char sandybrown[];\n extern const char seagreen[];\n extern const char seashell[];\n extern const char sienna[];\n extern const char silver[];\n extern const char skyblue[];\n extern const char slateblue[];\n extern const char slategray[];\n extern const char slategrey[];\n extern const char snow[];\n extern const char springgreen[];\n extern const char steelblue[];\n extern const char tan[];\n extern const char teal[];\n extern const char thistle[];\n extern const char tomato[];\n extern const char turquoise[];\n extern const char violet[];\n extern const char wheat[];\n extern const char white[];\n extern const char whitesmoke[];\n extern const char yellow[];\n extern const char yellowgreen[];\n extern const char rebeccapurple[];\n extern const char transparent[];\n }\n\n namespace Colors {\n extern const Color aliceblue;\n extern const Color antiquewhite;\n extern const Color cyan;\n extern const Color aqua;\n extern const Color aquamarine;\n extern const Color azure;\n extern const Color beige;\n extern const Color bisque;\n extern const Color black;\n extern const Color blanchedalmond;\n extern const Color blue;\n extern const Color blueviolet;\n extern const Color brown;\n extern const Color burlywood;\n extern const Color cadetblue;\n extern const Color chartreuse;\n extern const Color chocolate;\n extern const Color coral;\n extern const Color cornflowerblue;\n extern const Color cornsilk;\n extern const Color crimson;\n extern const Color darkblue;\n extern const Color darkcyan;\n extern const Color darkgoldenrod;\n extern const Color darkgray;\n extern const Color darkgrey;\n extern const Color darkgreen;\n extern const Color darkkhaki;\n extern const Color darkmagenta;\n extern const Color darkolivegreen;\n extern const Color darkorange;\n extern const Color darkorchid;\n extern const Color darkred;\n extern const Color darksalmon;\n extern const Color darkseagreen;\n extern const Color darkslateblue;\n extern const Color darkslategray;\n extern const Color darkslategrey;\n extern const Color darkturquoise;\n extern const Color darkviolet;\n extern const Color deeppink;\n extern const Color deepskyblue;\n extern const Color dimgray;\n extern const Color dimgrey;\n extern const Color dodgerblue;\n extern const Color firebrick;\n extern const Color floralwhite;\n extern const Color forestgreen;\n extern const Color magenta;\n extern const Color fuchsia;\n extern const Color gainsboro;\n extern const Color ghostwhite;\n extern const Color gold;\n extern const Color goldenrod;\n extern const Color gray;\n extern const Color grey;\n extern const Color green;\n extern const Color greenyellow;\n extern const Color honeydew;\n extern const Color hotpink;\n extern const Color indianred;\n extern const Color indigo;\n extern const Color ivory;\n extern const Color khaki;\n extern const Color lavender;\n extern const Color lavenderblush;\n extern const Color lawngreen;\n extern const Color lemonchiffon;\n extern const Color lightblue;\n extern const Color lightcoral;\n extern const Color lightcyan;\n extern const Color lightgoldenrodyellow;\n extern const Color lightgray;\n extern const Color lightgrey;\n extern const Color lightgreen;\n extern const Color lightpink;\n extern const Color lightsalmon;\n extern const Color lightseagreen;\n extern const Color lightskyblue;\n extern const Color lightslategray;\n extern const Color lightslategrey;\n extern const Color lightsteelblue;\n extern const Color lightyellow;\n extern const Color lime;\n extern const Color limegreen;\n extern const Color linen;\n extern const Color maroon;\n extern const Color mediumaquamarine;\n extern const Color mediumblue;\n extern const Color mediumorchid;\n extern const Color mediumpurple;\n extern const Color mediumseagreen;\n extern const Color mediumslateblue;\n extern const Color mediumspringgreen;\n extern const Color mediumturquoise;\n extern const Color mediumvioletred;\n extern const Color midnightblue;\n extern const Color mintcream;\n extern const Color mistyrose;\n extern const Color moccasin;\n extern const Color navajowhite;\n extern const Color navy;\n extern const Color oldlace;\n extern const Color olive;\n extern const Color olivedrab;\n extern const Color orange;\n extern const Color orangered;\n extern const Color orchid;\n extern const Color palegoldenrod;\n extern const Color palegreen;\n extern const Color paleturquoise;\n extern const Color palevioletred;\n extern const Color papayawhip;\n extern const Color peachpuff;\n extern const Color peru;\n extern const Color pink;\n extern const Color plum;\n extern const Color powderblue;\n extern const Color purple;\n extern const Color red;\n extern const Color rosybrown;\n extern const Color royalblue;\n extern const Color saddlebrown;\n extern const Color salmon;\n extern const Color sandybrown;\n extern const Color seagreen;\n extern const Color seashell;\n extern const Color sienna;\n extern const Color silver;\n extern const Color skyblue;\n extern const Color slateblue;\n extern const Color slategray;\n extern const Color slategrey;\n extern const Color snow;\n extern const Color springgreen;\n extern const Color steelblue;\n extern const Color tan;\n extern const Color teal;\n extern const Color thistle;\n extern const Color tomato;\n extern const Color turquoise;\n extern const Color violet;\n extern const Color wheat;\n extern const Color white;\n extern const Color whitesmoke;\n extern const Color yellow;\n extern const Color yellowgreen;\n extern const Color rebeccapurple;\n extern const Color transparent;\n }\n\n Color_Ptr_Const name_to_color(const char*);\n Color_Ptr_Const name_to_color(const std::string&);\n const char* color_to_name(const int);\n const char* color_to_name(const Color&);\n const char* color_to_name(const double);\n\n}\n\n#endif\n" }, { "path": "libsass-build/constants.cpp", "content": "#include \"sass.hpp\"\n#include \"constants.hpp\"\n\nnamespace Sass {\n namespace Constants {\n\n extern const unsigned long MaxCallStack = 1024;\n\n // https://github.com/sass/libsass/issues/592\n // https://developer.mozilla.org/en-US/docs/Web/CSS/Specificity\n // https://github.com/sass/sass/issues/1495#issuecomment-61189114\n extern const unsigned long Specificity_Star = 0;\n extern const unsigned long Specificity_Universal = 0;\n extern const unsigned long Specificity_Element = 1;\n extern const unsigned long Specificity_Base = 1000;\n extern const unsigned long Specificity_Class = 1000;\n extern const unsigned long Specificity_Attr = 1000;\n extern const unsigned long Specificity_Pseudo = 1000;\n extern const unsigned long Specificity_ID = 1000000;\n\n // sass keywords\n extern const char at_root_kwd[] = \"@at-root\";\n extern const char import_kwd[] = \"@import\";\n extern const char mixin_kwd[] = \"@mixin\";\n extern const char function_kwd[] = \"@function\";\n extern const char return_kwd[] = \"@return\";\n extern const char include_kwd[] = \"@include\";\n extern const char content_kwd[] = \"@content\";\n extern const char extend_kwd[] = \"@extend\";\n extern const char if_kwd[] = \"@if\";\n extern const char else_kwd[] = \"@else\";\n extern const char if_after_else_kwd[] = \"if\";\n extern const char for_kwd[] = \"@for\";\n extern const char from_kwd[] = \"from\";\n extern const char to_kwd[] = \"to\";\n extern const char through_kwd[] = \"through\";\n extern const char each_kwd[] = \"@each\";\n extern const char in_kwd[] = \"in\";\n extern const char while_kwd[] = \"@while\";\n extern const char warn_kwd[] = \"@warn\";\n extern const char error_kwd[] = \"@error\";\n extern const char debug_kwd[] = \"@debug\";\n extern const char default_kwd[] = \"default\";\n extern const char global_kwd[] = \"global\";\n extern const char null_kwd[] = \"null\";\n extern const char optional_kwd[] = \"optional\";\n extern const char with_kwd[] = \"with\";\n extern const char without_kwd[] = \"without\";\n extern const char all_kwd[] = \"all\";\n extern const char rule_kwd[] = \"rule\";\n\n // css standard units\n extern const char em_kwd[] = \"em\";\n extern const char ex_kwd[] = \"ex\";\n extern const char px_kwd[] = \"px\";\n extern const char cm_kwd[] = \"cm\";\n extern const char mm_kwd[] = \"mm\";\n extern const char pt_kwd[] = \"pt\";\n extern const char pc_kwd[] = \"pc\";\n extern const char deg_kwd[] = \"deg\";\n extern const char rad_kwd[] = \"rad\";\n extern const char grad_kwd[] = \"grad\";\n extern const char turn_kwd[] = \"turn\";\n extern const char ms_kwd[] = \"ms\";\n extern const char s_kwd[] = \"s\";\n extern const char Hz_kwd[] = \"Hz\";\n extern const char kHz_kwd[] = \"kHz\";\n\n // vendor prefixes\n extern const char vendor_opera_kwd[] = \"-o-\";\n extern const char vendor_webkit_kwd[] = \"-webkit-\";\n extern const char vendor_mozilla_kwd[] = \"-moz-\";\n extern const char vendor_ms_kwd[] = \"-ms-\";\n extern const char vendor_khtml_kwd[] = \"-khtml-\";\n\n // css functions and keywords\n extern const char charset_kwd[] = \"@charset\";\n extern const char media_kwd[] = \"@media\";\n extern const char supports_kwd[] = \"@supports\";\n extern const char keyframes_kwd[] = \"keyframes\";\n extern const char only_kwd[] = \"only\";\n extern const char rgb_fn_kwd[] = \"rgb(\";\n extern const char url_fn_kwd[] = \"url(\";\n extern const char url_kwd[] = \"url\";\n // extern const char url_prefix_fn_kwd[] = \"url-prefix(\";\n extern const char important_kwd[] = \"important\";\n extern const char pseudo_not_fn_kwd[] = \":not(\";\n extern const char even_kwd[] = \"even\";\n extern const char odd_kwd[] = \"odd\";\n extern const char progid_kwd[] = \"progid\";\n extern const char expression_kwd[] = \"expression\";\n extern const char calc_fn_kwd[] = \"calc\";\n\n extern const char almost_any_value_class[] = \"\\\"'#!;{}\";\n\n // css selector keywords\n extern const char sel_deep_kwd[] = \"/deep/\";\n\n // css attribute-matching operators\n extern const char tilde_equal[] = \"~=\";\n extern const char pipe_equal[] = \"|=\";\n extern const char caret_equal[] = \"^=\";\n extern const char dollar_equal[] = \"$=\";\n extern const char star_equal[] = \"*=\";\n\n // relational & logical operators and constants\n extern const char and_kwd[] = \"and\";\n extern const char or_kwd[] = \"or\";\n extern const char not_kwd[] = \"not\";\n extern const char gt[] = \">\";\n extern const char gte[] = \">=\";\n extern const char lt[] = \"<\";\n extern const char lte[] = \"<=\";\n extern const char eq[] = \"==\";\n extern const char neq[] = \"!=\";\n extern const char true_kwd[] = \"true\";\n extern const char false_kwd[] = \"false\";\n\n // miscellaneous punctuation and delimiters\n extern const char percent_str[] = \"%\";\n extern const char empty_str[] = \"\";\n extern const char slash_slash[] = \"//\";\n extern const char slash_star[] = \"/*\";\n extern const char star_slash[] = \"*/\";\n extern const char hash_lbrace[] = \"#{\";\n extern const char rbrace[] = \"}\";\n extern const char rparen[] = \")\";\n extern const char sign_chars[] = \"-+\";\n extern const char op_chars[] = \"-+\";\n extern const char hyphen[] = \"-\";\n extern const char ellipsis[] = \"...\";\n // extern const char url_space_chars[] = \" \\t\\r\\n\\f\";\n // type names\n extern const char numeric_name[] = \"numeric value\";\n extern const char number_name[] = \"number\";\n extern const char percentage_name[] = \"percentage\";\n extern const char dimension_name[] = \"numeric dimension\";\n extern const char string_name[] = \"string\";\n extern const char bool_name[] = \"bool\";\n extern const char color_name[] = \"color\";\n extern const char list_name[] = \"list\";\n extern const char map_name[] = \"map\";\n extern const char arglist_name[] = \"arglist\";\n\n // constants for uri parsing (RFC 3986 Appendix A.)\n extern const char uri_chars[] = \":;/?!%&#@|[]{}'`^\\\"*+-.,_=~\";\n extern const char real_uri_chars[] = \"#%&\";\n\n // some specific constant character classes\n // they must be static to be useable by lexer\n extern const char static_ops[] = \"*/%\";\n // some character classes for the parser\n extern const char selector_list_delims[] = \"){};!\";\n extern const char complex_selector_delims[] = \",){};!\";\n extern const char selector_combinator_ops[] = \"+~>\";\n // optional modifiers for alternative compare context\n extern const char attribute_compare_modifiers[] = \"~|^$*\";\n extern const char selector_lookahead_ops[] = \"*&%,()[]\";\n\n // byte order marks\n // (taken from http://en.wikipedia.org/wiki/Byte_order_mark)\n extern const unsigned char utf_8_bom[] = { 0xEF, 0xBB, 0xBF };\n extern const unsigned char utf_16_bom_be[] = { 0xFE, 0xFF };\n extern const unsigned char utf_16_bom_le[] = { 0xFF, 0xFE };\n extern const unsigned char utf_32_bom_be[] = { 0x00, 0x00, 0xFE, 0xFF };\n extern const unsigned char utf_32_bom_le[] = { 0xFF, 0xFE, 0x00, 0x00 };\n extern const unsigned char utf_7_bom_1[] = { 0x2B, 0x2F, 0x76, 0x38 };\n extern const unsigned char utf_7_bom_2[] = { 0x2B, 0x2F, 0x76, 0x39 };\n extern const unsigned char utf_7_bom_3[] = { 0x2B, 0x2F, 0x76, 0x2B };\n extern const unsigned char utf_7_bom_4[] = { 0x2B, 0x2F, 0x76, 0x2F };\n extern const unsigned char utf_7_bom_5[] = { 0x2B, 0x2F, 0x76, 0x38, 0x2D };\n extern const unsigned char utf_1_bom[] = { 0xF7, 0x64, 0x4C };\n extern const unsigned char utf_ebcdic_bom[] = { 0xDD, 0x73, 0x66, 0x73 };\n extern const unsigned char scsu_bom[] = { 0x0E, 0xFE, 0xFF };\n extern const unsigned char bocu_1_bom[] = { 0xFB, 0xEE, 0x28 };\n extern const unsigned char gb_18030_bom[] = { 0x84, 0x31, 0x95, 0x33 };\n\n }\n}\n" }, { "path": "libsass-build/constants.hpp", "content": "#ifndef SASS_CONSTANTS_H\n#define SASS_CONSTANTS_H\n\nnamespace Sass {\n namespace Constants {\n\n // The maximum call stack that can be created\n extern const unsigned long MaxCallStack;\n\n // https://developer.mozilla.org/en-US/docs/Web/CSS/Specificity\n // The following list of selectors is by increasing specificity:\n extern const unsigned long Specificity_Star;\n extern const unsigned long Specificity_Universal;\n extern const unsigned long Specificity_Element;\n extern const unsigned long Specificity_Base;\n extern const unsigned long Specificity_Class;\n extern const unsigned long Specificity_Attr;\n extern const unsigned long Specificity_Pseudo;\n extern const unsigned long Specificity_ID;\n\n // sass keywords\n extern const char at_root_kwd[];\n extern const char import_kwd[];\n extern const char mixin_kwd[];\n extern const char function_kwd[];\n extern const char return_kwd[];\n extern const char include_kwd[];\n extern const char content_kwd[];\n extern const char extend_kwd[];\n extern const char if_kwd[];\n extern const char else_kwd[];\n extern const char if_after_else_kwd[];\n extern const char for_kwd[];\n extern const char from_kwd[];\n extern const char to_kwd[];\n extern const char through_kwd[];\n extern const char each_kwd[];\n extern const char in_kwd[];\n extern const char while_kwd[];\n extern const char warn_kwd[];\n extern const char error_kwd[];\n extern const char debug_kwd[];\n extern const char default_kwd[];\n extern const char global_kwd[];\n extern const char null_kwd[];\n extern const char optional_kwd[];\n extern const char with_kwd[];\n extern const char without_kwd[];\n extern const char all_kwd[];\n extern const char rule_kwd[];\n\n // css standard units\n extern const char em_kwd[];\n extern const char ex_kwd[];\n extern const char px_kwd[];\n extern const char cm_kwd[];\n extern const char mm_kwd[];\n extern const char pt_kwd[];\n extern const char pc_kwd[];\n extern const char deg_kwd[];\n extern const char rad_kwd[];\n extern const char grad_kwd[];\n extern const char turn_kwd[];\n extern const char ms_kwd[];\n extern const char s_kwd[];\n extern const char Hz_kwd[];\n extern const char kHz_kwd[];\n\n // vendor prefixes\n extern const char vendor_opera_kwd[];\n extern const char vendor_webkit_kwd[];\n extern const char vendor_mozilla_kwd[];\n extern const char vendor_ms_kwd[];\n extern const char vendor_khtml_kwd[];\n\n // css functions and keywords\n extern const char charset_kwd[];\n extern const char media_kwd[];\n extern const char supports_kwd[];\n extern const char keyframes_kwd[];\n extern const char only_kwd[];\n extern const char rgb_fn_kwd[];\n extern const char url_fn_kwd[];\n extern const char url_kwd[];\n // extern const char url_prefix_fn_kwd[];\n extern const char important_kwd[];\n extern const char pseudo_not_fn_kwd[];\n extern const char even_kwd[];\n extern const char odd_kwd[];\n extern const char progid_kwd[];\n extern const char expression_kwd[];\n extern const char calc_fn_kwd[];\n\n // char classes for \"regular expressions\"\n extern const char almost_any_value_class[];\n\n // css selector keywords\n extern const char sel_deep_kwd[];\n\n // css attribute-matching operators\n extern const char tilde_equal[];\n extern const char pipe_equal[];\n extern const char caret_equal[];\n extern const char dollar_equal[];\n extern const char star_equal[];\n\n // relational & logical operators and constants\n extern const char and_kwd[];\n extern const char or_kwd[];\n extern const char not_kwd[];\n extern const char gt[];\n extern const char gte[];\n extern const char lt[];\n extern const char lte[];\n extern const char eq[];\n extern const char neq[];\n extern const char true_kwd[];\n extern const char false_kwd[];\n\n // miscellaneous punctuation and delimiters\n extern const char percent_str[];\n extern const char empty_str[];\n extern const char slash_slash[];\n extern const char slash_star[];\n extern const char star_slash[];\n extern const char hash_lbrace[];\n extern const char rbrace[];\n extern const char rparen[];\n extern const char sign_chars[];\n extern const char op_chars[];\n extern const char hyphen[];\n extern const char ellipsis[];\n // extern const char url_space_chars[];\n\n // type names\n extern const char numeric_name[];\n extern const char number_name[];\n extern const char percentage_name[];\n extern const char dimension_name[];\n extern const char string_name[];\n extern const char bool_name[];\n extern const char color_name[];\n extern const char list_name[];\n extern const char map_name[];\n extern const char arglist_name[];\n\n // constants for uri parsing (RFC 3986 Appendix A.)\n extern const char uri_chars[];\n extern const char real_uri_chars[];\n\n // some specific constant character classes\n // they must be static to be useable by lexer\n extern const char static_ops[];\n extern const char selector_list_delims[];\n extern const char complex_selector_delims[];\n extern const char selector_combinator_ops[];\n extern const char attribute_compare_modifiers[];\n extern const char selector_lookahead_ops[];\n\n // byte order marks\n // (taken from http://en.wikipedia.org/wiki/Byte_order_mark)\n extern const unsigned char utf_8_bom[];\n extern const unsigned char utf_16_bom_be[];\n extern const unsigned char utf_16_bom_le[];\n extern const unsigned char utf_32_bom_be[];\n extern const unsigned char utf_32_bom_le[];\n extern const unsigned char utf_7_bom_1[];\n extern const unsigned char utf_7_bom_2[];\n extern const unsigned char utf_7_bom_3[];\n extern const unsigned char utf_7_bom_4[];\n extern const unsigned char utf_7_bom_5[];\n extern const unsigned char utf_1_bom[];\n extern const unsigned char utf_ebcdic_bom[];\n extern const unsigned char scsu_bom[];\n extern const unsigned char bocu_1_bom[];\n extern const unsigned char gb_18030_bom[];\n\n }\n}\n\n#endif\n" }, { "path": "libsass-build/context.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"ast.hpp\"\n#include \"util.hpp\"\n#include \"sass.h\"\n#include \"context.hpp\"\n#include \"plugins.hpp\"\n#include \"constants.hpp\"\n#include \"parser.hpp\"\n#include \"file.hpp\"\n#include \"inspect.hpp\"\n#include \"output.hpp\"\n#include \"expand.hpp\"\n#include \"eval.hpp\"\n#include \"check_nesting.hpp\"\n#include \"cssize.hpp\"\n#include \"listize.hpp\"\n#include \"extend.hpp\"\n#include \"remove_placeholders.hpp\"\n#include \"functions.hpp\"\n#include \"sass_functions.hpp\"\n#include \"backtrace.hpp\"\n#include \"sass2scss.h\"\n#include \"prelexer.hpp\"\n#include \"emitter.hpp\"\n\nnamespace Sass {\n using namespace Constants;\n using namespace File;\n using namespace Sass;\n\n inline bool sort_importers (const Sass_Importer_Entry& i, const Sass_Importer_Entry& j)\n { return sass_importer_get_priority(i) > sass_importer_get_priority(j); }\n\n static std::string safe_input(const char* in_path)\n {\n // enforce some safe defaults\n // used to create relative file links\n std::string safe_path(in_path ? in_path : \"\");\n return safe_path == \"\" ? \"stdin\" : safe_path;\n }\n\n static std::string safe_output(const char* out_path, const std::string& input_path = \"\")\n {\n std::string safe_path(out_path ? out_path : \"\");\n // maybe we can extract an output path from input path\n if (safe_path == \"\" && input_path != \"\") {\n int lastindex = static_cast(input_path.find_last_of(\".\"));\n return (lastindex > -1 ? input_path.substr(0, lastindex) : input_path) + \".css\";\n }\n // enforce some safe defaults\n // used to create relative file links\n return safe_path == \"\" ? \"stdout\" : safe_path;\n }\n\n Context::Context(struct Sass_Context& c_ctx)\n : CWD(File::get_cwd()),\n c_options(c_ctx),\n entry_path(\"\"),\n head_imports(0),\n plugins(),\n emitter(c_options),\n\n ast_gc(),\n strings(),\n resources(),\n sheets(),\n subset_map(),\n import_stack(),\n callee_stack(),\n traces(),\n c_compiler(NULL),\n\n c_headers (std::vector()),\n c_importers (std::vector()),\n c_functions (std::vector()),\n\n indent (safe_str(c_options.indent, \" \")),\n linefeed (safe_str(c_options.linefeed, \"\\n\")),\n\n input_path (make_canonical_path(safe_input(c_options.input_path))),\n output_path (make_canonical_path(safe_output(c_options.output_path, input_path))),\n source_map_file (make_canonical_path(safe_str(c_options.source_map_file, \"\"))),\n source_map_root (make_canonical_path(safe_str(c_options.source_map_root, \"\")))\n\n {\n\n // Sass 3.4: The current working directory will no longer be placed onto the Sass load path by default.\n // If you need the current working directory to be available, set SASS_PATH=. in your shell's environment.\n // include_paths.push_back(CWD);\n\n // collect more paths from different options\n collect_include_paths(c_options.include_path);\n collect_include_paths(c_options.include_paths);\n collect_plugin_paths(c_options.plugin_path);\n collect_plugin_paths(c_options.plugin_paths);\n\n // load plugins and register custom behaviors\n for(auto plug : plugin_paths) plugins.load_plugins(plug);\n for(auto fn : plugins.get_headers()) c_headers.push_back(fn);\n for(auto fn : plugins.get_importers()) c_importers.push_back(fn);\n for(auto fn : plugins.get_functions()) c_functions.push_back(fn);\n\n // sort the items by priority (lowest first)\n sort (c_headers.begin(), c_headers.end(), sort_importers);\n sort (c_importers.begin(), c_importers.end(), sort_importers);\n\n emitter.set_filename(abs2rel(output_path, source_map_file, CWD));\n\n }\n\n void Context::add_c_function(Sass_Function_Entry function)\n {\n c_functions.push_back(function);\n }\n void Context::add_c_header(Sass_Importer_Entry header)\n {\n c_headers.push_back(header);\n // need to sort the array afterwards (no big deal)\n sort (c_headers.begin(), c_headers.end(), sort_importers);\n }\n void Context::add_c_importer(Sass_Importer_Entry importer)\n {\n c_importers.push_back(importer);\n // need to sort the array afterwards (no big deal)\n sort (c_importers.begin(), c_importers.end(), sort_importers);\n }\n\n Context::~Context()\n {\n // resources were allocated by malloc\n for (size_t i = 0; i < resources.size(); ++i) {\n free(resources[i].contents);\n free(resources[i].srcmap);\n }\n // free all strings we kept alive during compiler execution\n for (size_t n = 0; n < strings.size(); ++n) free(strings[n]);\n // everything that gets put into sources will be freed by us\n // this shouldn't have anything in it anyway!?\n for (size_t m = 0; m < import_stack.size(); ++m) {\n sass_import_take_source(import_stack[m]);\n sass_import_take_srcmap(import_stack[m]);\n sass_delete_import(import_stack[m]);\n }\n // clear inner structures (vectors) and input source\n resources.clear(); import_stack.clear();\n subset_map.clear(), sheets.clear();\n }\n\n Data_Context::~Data_Context()\n {\n // --> this will be freed by resources\n // make sure we free the source even if not processed!\n // if (resources.size() == 0 && source_c_str) free(source_c_str);\n // if (resources.size() == 0 && srcmap_c_str) free(srcmap_c_str);\n // source_c_str = 0; srcmap_c_str = 0;\n }\n\n File_Context::~File_Context()\n {\n }\n\n void Context::collect_include_paths(const char* paths_str)\n {\n if (paths_str) {\n const char* beg = paths_str;\n const char* end = Prelexer::find_first(beg);\n\n while (end) {\n std::string path(beg, end - beg);\n if (!path.empty()) {\n if (*path.rbegin() != '/') path += '/';\n include_paths.push_back(path);\n }\n beg = end + 1;\n end = Prelexer::find_first(beg);\n }\n\n std::string path(beg);\n if (!path.empty()) {\n if (*path.rbegin() != '/') path += '/';\n include_paths.push_back(path);\n }\n }\n }\n\n void Context::collect_include_paths(string_list* paths_array)\n {\n while (paths_array)\n {\n collect_include_paths(paths_array->string);\n paths_array = paths_array->next;\n }\n }\n\n void Context::collect_plugin_paths(const char* paths_str)\n {\n if (paths_str) {\n const char* beg = paths_str;\n const char* end = Prelexer::find_first(beg);\n\n while (end) {\n std::string path(beg, end - beg);\n if (!path.empty()) {\n if (*path.rbegin() != '/') path += '/';\n plugin_paths.push_back(path);\n }\n beg = end + 1;\n end = Prelexer::find_first(beg);\n }\n\n std::string path(beg);\n if (!path.empty()) {\n if (*path.rbegin() != '/') path += '/';\n plugin_paths.push_back(path);\n }\n }\n }\n\n void Context::collect_plugin_paths(string_list* paths_array)\n {\n while (paths_array)\n {\n collect_plugin_paths(paths_array->string);\n paths_array = paths_array->next;\n }\n }\n\n // resolve the imp_path in base_path or include_paths\n // looks for alternatives and returns a list from one directory\n std::vector Context::find_includes(const Importer& import)\n {\n // make sure we resolve against an absolute path\n std::string base_path(rel2abs(import.base_path));\n // first try to resolve the load path relative to the base path\n std::vector vec(resolve_includes(base_path, import.imp_path));\n // then search in every include path (but only if nothing found yet)\n for (size_t i = 0, S = include_paths.size(); vec.size() == 0 && i < S; ++i)\n {\n // call resolve_includes and individual base path and append all results\n std::vector resolved(resolve_includes(include_paths[i], import.imp_path));\n if (resolved.size()) vec.insert(vec.end(), resolved.begin(), resolved.end());\n }\n // return vector\n return vec;\n }\n\n // register include with resolved path and its content\n // memory of the resources will be freed by us on exit\n void Context::register_resource(const Include& inc, const Resource& res)\n {\n\n // do not parse same resource twice\n // maybe raise an error in this case\n // if (sheets.count(inc.abs_path)) {\n // free(res.contents); free(res.srcmap);\n // throw std::runtime_error(\"duplicate resource registered\");\n // return;\n // }\n\n // get index for this resource\n size_t idx = resources.size();\n\n // tell emitter about new resource\n emitter.add_source_index(idx);\n\n // put resources under our control\n // the memory will be freed later\n resources.push_back(res);\n\n // add a relative link to the working directory\n included_files.push_back(inc.abs_path);\n // add a relative link to the source map output file\n srcmap_links.push_back(abs2rel(inc.abs_path, source_map_file, CWD));\n\n // get pointer to the loaded content\n Sass_Import_Entry import = sass_make_import(\n inc.imp_path.c_str(),\n inc.abs_path.c_str(),\n res.contents,\n res.srcmap\n );\n // add the entry to the stack\n import_stack.push_back(import);\n\n // get pointer to the loaded content\n const char* contents = resources[idx].contents;\n // keep a copy of the path around (for parserstates)\n // ToDo: we clean it, but still not very elegant!?\n strings.push_back(sass_copy_c_string(inc.abs_path.c_str()));\n // create the initial parser state from resource\n ParserState pstate(strings.back(), contents, idx);\n\n // check existing import stack for possible recursion\n for (size_t i = 0; i < import_stack.size() - 2; ++i) {\n auto parent = import_stack[i];\n if (std::strcmp(parent->abs_path, import->abs_path) == 0) {\n std::string cwd(File::get_cwd());\n // make path relative to the current directory\n std::string stack(\"An @import loop has been found:\");\n for (size_t n = 1; n < i + 2; ++n) {\n stack += \"\\n \" + std::string(File::abs2rel(import_stack[n]->abs_path, cwd, cwd)) +\n \" imports \" + std::string(File::abs2rel(import_stack[n+1]->abs_path, cwd, cwd));\n }\n // implement error throw directly until we\n // decided how to handle full stack traces\n throw Exception::InvalidSyntax(pstate, traces, stack);\n // error(stack, prstate ? *prstate : pstate, import_stack);\n }\n }\n\n // create a parser instance from the given c_str buffer\n Parser p(Parser::from_c_str(contents, *this, traces, pstate));\n // do not yet dispose these buffers\n sass_import_take_source(import);\n sass_import_take_srcmap(import);\n // then parse the root block\n Block_Obj root = p.parse();\n // delete memory of current stack frame\n sass_delete_import(import_stack.back());\n // remove current stack frame\n import_stack.pop_back();\n // create key/value pair for ast node\n std::pair\n ast_pair(inc.abs_path, { res, root });\n // register resulting resource\n sheets.insert(ast_pair);\n }\n\n // register include with resolved path and its content\n // memory of the resources will be freed by us on exit\n void Context::register_resource(const Include& inc, const Resource& res, ParserState& prstate)\n {\n traces.push_back(Backtrace(prstate));\n register_resource(inc, res);\n traces.pop_back();\n }\n\n // Add a new import to the context (called from `import_url`)\n Include Context::load_import(const Importer& imp, ParserState pstate)\n {\n\n // search for valid imports (ie. partials) on the filesystem\n // this may return more than one valid result (ambiguous imp_path)\n const std::vector resolved(find_includes(imp));\n\n // error nicely on ambiguous imp_path\n if (resolved.size() > 1) {\n std::stringstream msg_stream;\n msg_stream << \"It's not clear which file to import for \";\n msg_stream << \"'@import \\\"\" << imp.imp_path << \"\\\"'.\" << \"\\n\";\n msg_stream << \"Candidates:\" << \"\\n\";\n for (size_t i = 0, L = resolved.size(); i < L; ++i)\n { msg_stream << \" \" << resolved[i].imp_path << \"\\n\"; }\n msg_stream << \"Please delete or rename all but one of these files.\" << \"\\n\";\n error(msg_stream.str(), pstate, traces);\n }\n\n // process the resolved entry\n else if (resolved.size() == 1) {\n bool use_cache = c_importers.size() == 0;\n // use cache for the resource loading\n if (use_cache && sheets.count(resolved[0].abs_path)) return resolved[0];\n // try to read the content of the resolved file entry\n // the memory buffer returned must be freed by us!\n if (char* contents = read_file(resolved[0].abs_path)) {\n // register the newly resolved file resource\n register_resource(resolved[0], { contents, 0 }, pstate);\n // return resolved entry\n return resolved[0];\n }\n }\n\n // nothing found\n return { imp, \"\" };\n\n }\n\n void Context::import_url (Import_Ptr imp, std::string load_path, const std::string& ctx_path) {\n\n ParserState pstate(imp->pstate());\n std::string imp_path(unquote(load_path));\n std::string protocol(\"file\");\n\n using namespace Prelexer;\n if (const char* proto = sequence< identifier, exactly<':'>, exactly<'/'>, exactly<'/'> >(imp_path.c_str())) {\n\n protocol = std::string(imp_path.c_str(), proto - 3);\n // if (protocol.compare(\"file\") && true) { }\n }\n\n // add urls (protocol other than file) and urls without procotol to `urls` member\n // ToDo: if ctx_path is already a file resource, we should not add it here?\n if (imp->import_queries() || protocol != \"file\" || imp_path.substr(0, 2) == \"//\") {\n imp->urls().push_back(SASS_MEMORY_NEW(String_Quoted, imp->pstate(), load_path));\n }\n else if (imp_path.length() > 4 && imp_path.substr(imp_path.length() - 4, 4) == \".css\") {\n String_Constant_Ptr loc = SASS_MEMORY_NEW(String_Constant, pstate, unquote(load_path));\n Argument_Obj loc_arg = SASS_MEMORY_NEW(Argument, pstate, loc);\n Arguments_Obj loc_args = SASS_MEMORY_NEW(Arguments, pstate);\n loc_args->append(loc_arg);\n Function_Call_Ptr new_url = SASS_MEMORY_NEW(Function_Call, pstate, \"url\", loc_args);\n imp->urls().push_back(new_url);\n }\n else {\n const Importer importer(imp_path, ctx_path);\n Include include(load_import(importer, pstate));\n if (include.abs_path.empty()) {\n error(\"File to import not found or unreadable: \" + imp_path + \".\", pstate, traces);\n }\n imp->incs().push_back(include);\n }\n\n }\n\n\n // call custom importers on the given (unquoted) load_path and eventually parse the resulting style_sheet\n bool Context::call_loader(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import_Ptr imp, std::vector importers, bool only_one)\n {\n // unique counter\n size_t count = 0;\n // need one correct import\n bool has_import = false;\n // process all custom importers (or custom headers)\n for (Sass_Importer_Entry& importer_ent : importers) {\n // int priority = sass_importer_get_priority(importer);\n Sass_Importer_Fn fn = sass_importer_get_function(importer_ent);\n // skip importer if it returns NULL\n if (Sass_Import_List includes =\n fn(load_path.c_str(), importer_ent, c_compiler)\n ) {\n // get c pointer copy to iterate over\n Sass_Import_List it_includes = includes;\n while (*it_includes) { ++count;\n // create unique path to use as key\n std::string uniq_path = load_path;\n if (!only_one && count) {\n std::stringstream path_strm;\n path_strm << uniq_path << \":\" << count;\n uniq_path = path_strm.str();\n }\n // create the importer struct\n Importer importer(uniq_path, ctx_path);\n // query data from the current include\n Sass_Import_Entry include_ent = *it_includes;\n char* source = sass_import_take_source(include_ent);\n char* srcmap = sass_import_take_srcmap(include_ent);\n size_t line = sass_import_get_error_line(include_ent);\n size_t column = sass_import_get_error_column(include_ent);\n const char *abs_path = sass_import_get_abs_path(include_ent);\n // handle error message passed back from custom importer\n // it may (or may not) override the line and column info\n if (const char* err_message = sass_import_get_error_message(include_ent)) {\n if (source || srcmap) register_resource({ importer, uniq_path }, { source, srcmap }, pstate);\n if (line == std::string::npos && column == std::string::npos) error(err_message, pstate, traces);\n else error(err_message, ParserState(ctx_path, source, Position(line, column)), traces);\n }\n // content for import was set\n else if (source) {\n // resolved abs_path should be set by custom importer\n // use the created uniq_path as fallback (maybe enforce)\n std::string path_key(abs_path ? abs_path : uniq_path);\n // create the importer struct\n Include include(importer, path_key);\n // attach information to AST node\n imp->incs().push_back(include);\n // register the resource buffers\n register_resource(include, { source, srcmap }, pstate);\n }\n // only a path was retuned\n // try to load it like normal\n else if(abs_path) {\n // checks some urls to preserve\n // `http://`, `https://` and `//`\n // or dispatchs to `import_file`\n // which will check for a `.css` extension\n // or resolves the file on the filesystem\n // added and resolved via `add_file`\n // finally stores everything on `imp`\n import_url(imp, abs_path, ctx_path);\n }\n // move to next\n ++it_includes;\n }\n // deallocate the returned memory\n sass_delete_import_list(includes);\n // set success flag\n has_import = true;\n // break out of loop\n if (only_one) break;\n }\n }\n // return result\n return has_import;\n }\n\n void register_function(Context&, Signature sig, Native_Function f, Env* env);\n void register_function(Context&, Signature sig, Native_Function f, size_t arity, Env* env);\n void register_overload_stub(Context&, std::string name, Env* env);\n void register_built_in_functions(Context&, Env* env);\n void register_c_functions(Context&, Env* env, Sass_Function_List);\n void register_c_function(Context&, Env* env, Sass_Function_Entry);\n\n char* Context::render(Block_Obj root)\n {\n // check for valid block\n if (!root) return 0;\n // start the render process\n root->perform(&emitter);\n // finish emitter stream\n emitter.finalize();\n // get the resulting buffer from stream\n OutputBuffer emitted = emitter.get_buffer();\n // should we append a source map url?\n if (!c_options.omit_source_map_url) {\n // generate an embeded source map\n if (c_options.source_map_embed) {\n emitted.buffer += linefeed;\n emitted.buffer += format_embedded_source_map();\n }\n // or just link the generated one\n else if (source_map_file != \"\") {\n emitted.buffer += linefeed;\n emitted.buffer += format_source_mapping_url(source_map_file);\n }\n }\n // create a copy of the resulting buffer string\n // this must be freed or taken over by implementor\n return sass_copy_c_string(emitted.buffer.c_str());\n }\n\n void Context::apply_custom_headers(Block_Obj root, const char* ctx_path, ParserState pstate)\n {\n // create a custom import to resolve headers\n Import_Obj imp = SASS_MEMORY_NEW(Import, pstate);\n // dispatch headers which will add custom functions\n // custom headers are added to the import instance\n call_headers(entry_path, ctx_path, pstate, imp);\n // increase head count to skip later\n head_imports += resources.size() - 1;\n // add the statement if we have urls\n if (!imp->urls().empty()) root->append(imp);\n // process all other resources (add Import_Stub nodes)\n for (size_t i = 0, S = imp->incs().size(); i < S; ++i) {\n root->append(SASS_MEMORY_NEW(Import_Stub, pstate, imp->incs()[i]));\n }\n }\n\n Block_Obj File_Context::parse()\n {\n\n // check if entry file is given\n if (input_path.empty()) return 0;\n\n // create absolute path from input filename\n // ToDo: this should be resolved via custom importers\n std::string abs_path(rel2abs(input_path, CWD));\n\n // try to load the entry file\n char* contents = read_file(abs_path);\n\n // alternatively also look inside each include path folder\n // I think this differs from ruby sass (IMO too late to remove)\n for (size_t i = 0, S = include_paths.size(); contents == 0 && i < S; ++i) {\n // build absolute path for this include path entry\n abs_path = rel2abs(input_path, include_paths[i]);\n // try to load the resulting path\n contents = read_file(abs_path);\n }\n\n // abort early if no content could be loaded (various reasons)\n if (!contents) throw std::runtime_error(\"File to read not found or unreadable: \" + input_path);\n\n // store entry path\n entry_path = abs_path;\n\n // create entry only for import stack\n Sass_Import_Entry import = sass_make_import(\n input_path.c_str(),\n entry_path.c_str(),\n contents,\n 0\n );\n // add the entry to the stack\n import_stack.push_back(import);\n\n // create the source entry for file entry\n register_resource({{ input_path, \".\" }, abs_path }, { contents, 0 });\n\n // create root ast tree node\n return compile();\n\n }\n\n Block_Obj Data_Context::parse()\n {\n\n // check if source string is given\n if (!source_c_str) return 0;\n\n // convert indented sass syntax\n if(c_options.is_indented_syntax_src) {\n // call sass2scss to convert the string\n char * converted = sass2scss(source_c_str,\n // preserve the structure as much as possible\n SASS2SCSS_PRETTIFY_1 | SASS2SCSS_KEEP_COMMENT);\n // replace old source_c_str with converted\n free(source_c_str); source_c_str = converted;\n }\n\n // remember entry path (defaults to stdin for string)\n entry_path = input_path.empty() ? \"stdin\" : input_path;\n\n // ToDo: this may be resolved via custom importers\n std::string abs_path(rel2abs(entry_path));\n char* abs_path_c_str = sass_copy_c_string(abs_path.c_str());\n strings.push_back(abs_path_c_str);\n\n // create entry only for the import stack\n Sass_Import_Entry import = sass_make_import(\n entry_path.c_str(),\n abs_path_c_str,\n source_c_str,\n srcmap_c_str\n );\n // add the entry to the stack\n import_stack.push_back(import);\n\n // register a synthetic resource (path does not really exist, skip in includes)\n register_resource({{ input_path, \".\" }, input_path }, { source_c_str, srcmap_c_str });\n\n // create root ast tree node\n return compile();\n }\n\n\n\n // parse root block from includes\n Block_Obj Context::compile()\n {\n // abort if there is no data\n if (resources.size() == 0) return 0;\n // get root block from the first style sheet\n Block_Obj root = sheets.at(entry_path).root;\n // abort on invalid root\n if (root.isNull()) return 0;\n Env global; // create root environment\n // register built-in functions on env\n register_built_in_functions(*this, &global);\n // register custom functions (defined via C-API)\n for (size_t i = 0, S = c_functions.size(); i < S; ++i)\n { register_c_function(*this, &global, c_functions[i]); }\n // create initial backtrace entry\n // create crtp visitor objects\n Expand expand(*this, &global);\n Cssize cssize(*this);\n CheckNesting check_nesting;\n // check nesting in all files\n for (auto sheet : sheets) {\n auto styles = sheet.second;\n check_nesting(styles.root);\n }\n // expand and eval the tree\n root = expand(root);\n // check nesting\n check_nesting(root);\n // merge and bubble certain rules\n root = cssize(root);\n // should we extend something?\n if (!subset_map.empty()) {\n // create crtp visitor object\n Extend extend(subset_map);\n extend.setEval(expand.eval);\n // extend tree nodes\n extend(root);\n }\n\n // clean up by removing empty placeholders\n // ToDo: maybe we can do this somewhere else?\n Remove_Placeholders remove_placeholders;\n root->perform(&remove_placeholders);\n // return processed tree\n return root;\n }\n // EO compile\n\n std::string Context::format_embedded_source_map()\n {\n std::string map = emitter.render_srcmap(*this);\n std::istringstream is( map );\n std::ostringstream buffer;\n base64::encoder E;\n E.encode(is, buffer);\n std::string url = \"data:application/json;base64,\" + buffer.str();\n url.erase(url.size() - 1);\n return \"/*# sourceMappingURL=\" + url + \" */\";\n }\n\n std::string Context::format_source_mapping_url(const std::string& file)\n {\n std::string url = abs2rel(file, output_path, CWD);\n return \"/*# sourceMappingURL=\" + url + \" */\";\n }\n\n char* Context::render_srcmap()\n {\n if (source_map_file == \"\") return 0;\n std::string map = emitter.render_srcmap(*this);\n return sass_copy_c_string(map.c_str());\n }\n\n\n // for data context we want to start after \"stdin\"\n // we probably always want to skip the header includes?\n std::vector Context::get_included_files(bool skip, size_t headers)\n {\n // create a copy of the vector for manipulations\n std::vector includes = included_files;\n if (includes.size() == 0) return includes;\n if (skip) { includes.erase( includes.begin(), includes.begin() + 1 + headers); }\n else { includes.erase( includes.begin() + 1, includes.begin() + 1 + headers); }\n includes.erase( std::unique( includes.begin(), includes.end() ), includes.end() );\n std::sort( includes.begin() + (skip ? 0 : 1), includes.end() );\n return includes;\n }\n\n void register_function(Context& ctx, Signature sig, Native_Function f, Env* env)\n {\n Definition_Ptr def = make_native_function(sig, f, ctx);\n def->environment(env);\n (*env)[def->name() + \"[f]\"] = def;\n }\n\n void register_function(Context& ctx, Signature sig, Native_Function f, size_t arity, Env* env)\n {\n Definition_Ptr def = make_native_function(sig, f, ctx);\n std::stringstream ss;\n ss << def->name() << \"[f]\" << arity;\n def->environment(env);\n (*env)[ss.str()] = def;\n }\n\n void register_overload_stub(Context& ctx, std::string name, Env* env)\n {\n Definition_Ptr stub = SASS_MEMORY_NEW(Definition,\n ParserState(\"[built-in function]\"),\n 0,\n name,\n 0,\n 0,\n true);\n (*env)[name + \"[f]\"] = stub;\n }\n\n\n void register_built_in_functions(Context& ctx, Env* env)\n {\n using namespace Functions;\n // RGB Functions\n register_function(ctx, rgb_sig, rgb, env);\n register_overload_stub(ctx, \"rgba\", env);\n register_function(ctx, rgba_4_sig, rgba_4, 4, env);\n register_function(ctx, rgba_2_sig, rgba_2, 2, env);\n register_function(ctx, red_sig, red, env);\n register_function(ctx, green_sig, green, env);\n register_function(ctx, blue_sig, blue, env);\n register_function(ctx, mix_sig, mix, env);\n // HSL Functions\n register_function(ctx, hsl_sig, hsl, env);\n register_function(ctx, hsla_sig, hsla, env);\n register_function(ctx, hue_sig, hue, env);\n register_function(ctx, saturation_sig, saturation, env);\n register_function(ctx, lightness_sig, lightness, env);\n register_function(ctx, adjust_hue_sig, adjust_hue, env);\n register_function(ctx, lighten_sig, lighten, env);\n register_function(ctx, darken_sig, darken, env);\n register_function(ctx, saturate_sig, saturate, env);\n register_function(ctx, desaturate_sig, desaturate, env);\n register_function(ctx, grayscale_sig, grayscale, env);\n register_function(ctx, complement_sig, complement, env);\n register_function(ctx, invert_sig, invert, env);\n // Opacity Functions\n register_function(ctx, alpha_sig, alpha, env);\n register_function(ctx, opacity_sig, alpha, env);\n register_function(ctx, opacify_sig, opacify, env);\n register_function(ctx, fade_in_sig, opacify, env);\n register_function(ctx, transparentize_sig, transparentize, env);\n register_function(ctx, fade_out_sig, transparentize, env);\n // Other Color Functions\n register_function(ctx, adjust_color_sig, adjust_color, env);\n register_function(ctx, scale_color_sig, scale_color, env);\n register_function(ctx, change_color_sig, change_color, env);\n register_function(ctx, ie_hex_str_sig, ie_hex_str, env);\n // String Functions\n register_function(ctx, unquote_sig, sass_unquote, env);\n register_function(ctx, quote_sig, sass_quote, env);\n register_function(ctx, str_length_sig, str_length, env);\n register_function(ctx, str_insert_sig, str_insert, env);\n register_function(ctx, str_index_sig, str_index, env);\n register_function(ctx, str_slice_sig, str_slice, env);\n register_function(ctx, to_upper_case_sig, to_upper_case, env);\n register_function(ctx, to_lower_case_sig, to_lower_case, env);\n // Number Functions\n register_function(ctx, percentage_sig, percentage, env);\n register_function(ctx, round_sig, round, env);\n register_function(ctx, ceil_sig, ceil, env);\n register_function(ctx, floor_sig, floor, env);\n register_function(ctx, abs_sig, abs, env);\n register_function(ctx, min_sig, min, env);\n register_function(ctx, max_sig, max, env);\n register_function(ctx, random_sig, random, env);\n // List Functions\n register_function(ctx, length_sig, length, env);\n register_function(ctx, nth_sig, nth, env);\n register_function(ctx, set_nth_sig, set_nth, env);\n register_function(ctx, index_sig, index, env);\n register_function(ctx, join_sig, join, env);\n register_function(ctx, append_sig, append, env);\n register_function(ctx, zip_sig, zip, env);\n register_function(ctx, list_separator_sig, list_separator, env);\n register_function(ctx, is_bracketed_sig, is_bracketed, env);\n // Map Functions\n register_function(ctx, map_get_sig, map_get, env);\n register_function(ctx, map_merge_sig, map_merge, env);\n register_function(ctx, map_remove_sig, map_remove, env);\n register_function(ctx, map_keys_sig, map_keys, env);\n register_function(ctx, map_values_sig, map_values, env);\n register_function(ctx, map_has_key_sig, map_has_key, env);\n register_function(ctx, keywords_sig, keywords, env);\n // Introspection Functions\n register_function(ctx, type_of_sig, type_of, env);\n register_function(ctx, unit_sig, unit, env);\n register_function(ctx, unitless_sig, unitless, env);\n register_function(ctx, comparable_sig, comparable, env);\n register_function(ctx, variable_exists_sig, variable_exists, env);\n register_function(ctx, global_variable_exists_sig, global_variable_exists, env);\n register_function(ctx, function_exists_sig, function_exists, env);\n register_function(ctx, mixin_exists_sig, mixin_exists, env);\n register_function(ctx, feature_exists_sig, feature_exists, env);\n register_function(ctx, call_sig, call, env);\n register_function(ctx, content_exists_sig, content_exists, env);\n register_function(ctx, get_function_sig, get_function, env);\n // Boolean Functions\n register_function(ctx, not_sig, sass_not, env);\n register_function(ctx, if_sig, sass_if, env);\n // Misc Functions\n register_function(ctx, inspect_sig, inspect, env);\n register_function(ctx, unique_id_sig, unique_id, env);\n // Selector functions\n register_function(ctx, selector_nest_sig, selector_nest, env);\n register_function(ctx, selector_append_sig, selector_append, env);\n register_function(ctx, selector_extend_sig, selector_extend, env);\n register_function(ctx, selector_replace_sig, selector_replace, env);\n register_function(ctx, selector_unify_sig, selector_unify, env);\n register_function(ctx, is_superselector_sig, is_superselector, env);\n register_function(ctx, simple_selectors_sig, simple_selectors, env);\n register_function(ctx, selector_parse_sig, selector_parse, env);\n }\n\n void register_c_functions(Context& ctx, Env* env, Sass_Function_List descrs)\n {\n while (descrs && *descrs) {\n register_c_function(ctx, env, *descrs);\n ++descrs;\n }\n }\n void register_c_function(Context& ctx, Env* env, Sass_Function_Entry descr)\n {\n Definition_Ptr def = make_c_function(descr, ctx);\n def->environment(env);\n (*env)[def->name() + \"[f]\"] = def;\n }\n\n}\n" }, { "path": "libsass-build/context.hpp", "content": "#ifndef SASS_CONTEXT_H\n#define SASS_CONTEXT_H\n\n#include \n#include \n#include \n\n#define BUFFERSIZE 255\n#include \"b64/encode.h\"\n\n#include \"ast_fwd_decl.hpp\"\n#include \"kwd_arg_macros.hpp\"\n#include \"ast_fwd_decl.hpp\"\n#include \"sass_context.hpp\"\n#include \"environment.hpp\"\n#include \"source_map.hpp\"\n#include \"subset_map.hpp\"\n#include \"backtrace.hpp\"\n#include \"output.hpp\"\n#include \"plugins.hpp\"\n#include \"file.hpp\"\n\n\nstruct Sass_Function;\n\nnamespace Sass {\n\n class Context {\n public:\n void import_url (Import_Ptr imp, std::string load_path, const std::string& ctx_path);\n bool call_headers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import_Ptr imp)\n { return call_loader(load_path, ctx_path, pstate, imp, c_headers, false); };\n bool call_importers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import_Ptr imp)\n { return call_loader(load_path, ctx_path, pstate, imp, c_importers, true); };\n\n private:\n bool call_loader(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import_Ptr imp, std::vector importers, bool only_one = true);\n\n public:\n const std::string CWD;\n struct Sass_Options& c_options;\n std::string entry_path;\n size_t head_imports;\n Plugins plugins;\n Output emitter;\n\n // generic ast node garbage container\n // used to avoid possible circular refs\n std::vector ast_gc;\n // resources add under our control\n // these are guaranteed to be freed\n std::vector strings;\n std::vector resources;\n std::map sheets;\n Subset_Map subset_map;\n std::vector import_stack;\n std::vector callee_stack;\n std::vector traces;\n\n struct Sass_Compiler* c_compiler;\n\n // absolute paths to includes\n std::vector included_files;\n // relative includes for sourcemap\n std::vector srcmap_links;\n // vectors above have same size\n\n std::vector plugin_paths; // relative paths to load plugins\n std::vector include_paths; // lookup paths for includes\n\n\n\n\n\n void apply_custom_headers(Block_Obj root, const char* path, ParserState pstate);\n\n std::vector c_headers;\n std::vector c_importers;\n std::vector c_functions;\n\n void add_c_header(Sass_Importer_Entry header);\n void add_c_importer(Sass_Importer_Entry importer);\n void add_c_function(Sass_Function_Entry function);\n\n const std::string indent; // String to be used for indentation\n const std::string linefeed; // String to be used for line feeds\n const std::string input_path; // for relative paths in src-map\n const std::string output_path; // for relative paths to the output\n const std::string source_map_file; // path to source map file (enables feature)\n const std::string source_map_root; // path for sourceRoot property (pass-through)\n\n virtual ~Context();\n Context(struct Sass_Context&);\n virtual Block_Obj parse() = 0;\n virtual Block_Obj compile();\n virtual char* render(Block_Obj root);\n virtual char* render_srcmap();\n\n void register_resource(const Include&, const Resource&);\n void register_resource(const Include&, const Resource&, ParserState&);\n std::vector find_includes(const Importer& import);\n Include load_import(const Importer&, ParserState pstate);\n\n Sass_Output_Style output_style() { return c_options.output_style; };\n std::vector get_included_files(bool skip = false, size_t headers = 0);\n\n private:\n void collect_plugin_paths(const char* paths_str);\n void collect_plugin_paths(string_list* paths_array);\n void collect_include_paths(const char* paths_str);\n void collect_include_paths(string_list* paths_array);\n std::string format_embedded_source_map();\n std::string format_source_mapping_url(const std::string& out_path);\n\n\n // void register_built_in_functions(Env* env);\n // void register_function(Signature sig, Native_Function f, Env* env);\n // void register_function(Signature sig, Native_Function f, size_t arity, Env* env);\n // void register_overload_stub(std::string name, Env* env);\n\n public:\n const std::string& cwd() { return CWD; };\n };\n\n class File_Context : public Context {\n public:\n File_Context(struct Sass_File_Context& ctx)\n : Context(ctx)\n { }\n virtual ~File_Context();\n virtual Block_Obj parse();\n };\n\n class Data_Context : public Context {\n public:\n char* source_c_str;\n char* srcmap_c_str;\n Data_Context(struct Sass_Data_Context& ctx)\n : Context(ctx)\n {\n source_c_str = ctx.source_string;\n srcmap_c_str = ctx.srcmap_string;\n ctx.source_string = 0; // passed away\n ctx.srcmap_string = 0; // passed away\n }\n virtual ~Data_Context();\n virtual Block_Obj parse();\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/cssize.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n#include \n\n#include \"cssize.hpp\"\n#include \"context.hpp\"\n\nnamespace Sass {\n\n Cssize::Cssize(Context& ctx)\n : ctx(ctx),\n traces(ctx.traces),\n block_stack(std::vector()),\n p_stack(std::vector())\n { }\n\n Statement_Ptr Cssize::parent()\n {\n return p_stack.size() ? p_stack.back() : block_stack.front();\n }\n\n Block_Ptr Cssize::operator()(Block_Ptr b)\n {\n Block_Obj bb = SASS_MEMORY_NEW(Block, b->pstate(), b->length(), b->is_root());\n // bb->tabs(b->tabs());\n block_stack.push_back(bb);\n append_block(b, bb);\n block_stack.pop_back();\n return bb.detach();\n }\n\n Statement_Ptr Cssize::operator()(Trace_Ptr t)\n {\n traces.push_back(Backtrace(t->pstate()));\n auto result = t->block()->perform(this);\n traces.pop_back();\n return result;\n }\n\n Statement_Ptr Cssize::operator()(Declaration_Ptr d)\n {\n String_Obj property = Cast(d->property());\n\n if (Declaration_Ptr dd = Cast(parent())) {\n String_Obj parent_property = Cast(dd->property());\n property = SASS_MEMORY_NEW(String_Constant,\n d->property()->pstate(),\n parent_property->to_string() + \"-\" + property->to_string());\n if (!dd->value()) {\n d->tabs(dd->tabs() + 1);\n }\n }\n\n Declaration_Obj dd = SASS_MEMORY_NEW(Declaration,\n d->pstate(),\n property,\n d->value(),\n d->is_important(),\n d->is_custom_property());\n dd->is_indented(d->is_indented());\n dd->tabs(d->tabs());\n\n p_stack.push_back(dd);\n Block_Obj bb = d->block() ? operator()(d->block()) : NULL;\n p_stack.pop_back();\n\n if (bb && bb->length()) {\n if (dd->value() && !dd->value()->is_invisible()) {\n bb->unshift(dd);\n }\n return bb.detach();\n }\n else if (dd->value() && !dd->value()->is_invisible()) {\n return dd.detach();\n }\n\n return 0;\n }\n\n Statement_Ptr Cssize::operator()(Directive_Ptr r)\n {\n if (!r->block() || !r->block()->length()) return r;\n\n if (parent()->statement_type() == Statement::RULESET)\n {\n return (r->is_keyframes()) ? SASS_MEMORY_NEW(Bubble, r->pstate(), r) : bubble(r);\n }\n\n p_stack.push_back(r);\n Directive_Obj rr = SASS_MEMORY_NEW(Directive,\n r->pstate(),\n r->keyword(),\n r->selector(),\n r->block() ? operator()(r->block()) : 0);\n if (r->value()) rr->value(r->value());\n p_stack.pop_back();\n\n bool directive_exists = false;\n size_t L = rr->block() ? rr->block()->length() : 0;\n for (size_t i = 0; i < L && !directive_exists; ++i) {\n Statement_Obj s = r->block()->at(i);\n if (s->statement_type() != Statement::BUBBLE) directive_exists = true;\n else {\n Bubble_Obj s_obj = Cast(s);\n s = s_obj->node();\n if (s->statement_type() != Statement::DIRECTIVE) directive_exists = false;\n else directive_exists = (Cast(s)->keyword() == rr->keyword());\n }\n\n }\n\n Block_Ptr result = SASS_MEMORY_NEW(Block, rr->pstate());\n if (!(directive_exists || rr->is_keyframes()))\n {\n Directive_Ptr empty_node = Cast(rr);\n empty_node->block(SASS_MEMORY_NEW(Block, rr->block() ? rr->block()->pstate() : rr->pstate()));\n result->append(empty_node);\n }\n\n Block_Obj db = rr->block();\n if (db.isNull()) db = SASS_MEMORY_NEW(Block, rr->pstate());\n Block_Obj ss = debubble(db, rr);\n for (size_t i = 0, L = ss->length(); i < L; ++i) {\n result->append(ss->at(i));\n }\n\n return result;\n }\n\n Statement_Ptr Cssize::operator()(Keyframe_Rule_Ptr r)\n {\n if (!r->block() || !r->block()->length()) return r;\n\n Keyframe_Rule_Obj rr = SASS_MEMORY_NEW(Keyframe_Rule,\n r->pstate(),\n operator()(r->block()));\n if (!r->name().isNull()) rr->name(r->name());\n\n return debubble(rr->block(), rr);\n }\n\n Statement_Ptr Cssize::operator()(Ruleset_Ptr r)\n {\n p_stack.push_back(r);\n // this can return a string schema\n // string schema is not a statement!\n // r->block() is already a string schema\n // and that is comming from propset expand\n Block_Ptr bb = operator()(r->block());\n // this should protect us (at least a bit) from our mess\n // fixing this properly is harder that it should be ...\n if (Cast(bb) == NULL) {\n error(\"Illegal nesting: Only properties may be nested beneath properties.\", r->block()->pstate(), traces);\n }\n Ruleset_Obj rr = SASS_MEMORY_NEW(Ruleset,\n r->pstate(),\n r->selector(),\n bb);\n\n rr->is_root(r->is_root());\n // rr->tabs(r->block()->tabs());\n p_stack.pop_back();\n\n if (!rr->block()) {\n error(\"Illegal nesting: Only properties may be nested beneath properties.\", r->block()->pstate(), traces);\n }\n\n Block_Obj props = SASS_MEMORY_NEW(Block, rr->block()->pstate());\n Block_Ptr rules = SASS_MEMORY_NEW(Block, rr->block()->pstate());\n for (size_t i = 0, L = rr->block()->length(); i < L; i++)\n {\n Statement_Ptr s = rr->block()->at(i);\n if (bubblable(s)) rules->append(s);\n if (!bubblable(s)) props->append(s);\n }\n\n if (props->length())\n {\n Block_Obj pb = SASS_MEMORY_NEW(Block, rr->block()->pstate());\n pb->concat(props);\n rr->block(pb);\n\n for (size_t i = 0, L = rules->length(); i < L; i++)\n {\n Statement_Ptr stm = rules->at(i);\n stm->tabs(stm->tabs() + 1);\n }\n\n rules->unshift(rr);\n }\n\n Block_Ptr ptr = rules;\n rules = debubble(rules);\n void* lp = ptr;\n void* rp = rules;\n if (lp != rp) {\n Block_Obj obj = ptr;\n }\n\n if (!(!rules->length() ||\n !bubblable(rules->last()) ||\n parent()->statement_type() == Statement::RULESET))\n {\n rules->last()->group_end(true);\n }\n return rules;\n }\n\n Statement_Ptr Cssize::operator()(Null_Ptr m)\n {\n return 0;\n }\n\n Statement_Ptr Cssize::operator()(Media_Block_Ptr m)\n {\n if (parent()->statement_type() == Statement::RULESET)\n { return bubble(m); }\n\n if (parent()->statement_type() == Statement::MEDIA)\n { return SASS_MEMORY_NEW(Bubble, m->pstate(), m); }\n\n p_stack.push_back(m);\n\n Media_Block_Obj mm = SASS_MEMORY_NEW(Media_Block,\n m->pstate(),\n m->media_queries(),\n operator()(m->block()));\n mm->tabs(m->tabs());\n\n p_stack.pop_back();\n\n return debubble(mm->block(), mm);\n }\n\n Statement_Ptr Cssize::operator()(Supports_Block_Ptr m)\n {\n if (!m->block()->length())\n { return m; }\n\n if (parent()->statement_type() == Statement::RULESET)\n { return bubble(m); }\n\n p_stack.push_back(m);\n\n Supports_Block_Obj mm = SASS_MEMORY_NEW(Supports_Block,\n m->pstate(),\n m->condition(),\n operator()(m->block()));\n mm->tabs(m->tabs());\n\n p_stack.pop_back();\n\n return debubble(mm->block(), mm);\n }\n\n Statement_Ptr Cssize::operator()(At_Root_Block_Ptr m)\n {\n bool tmp = false;\n for (size_t i = 0, L = p_stack.size(); i < L; ++i) {\n Statement_Ptr s = p_stack[i];\n tmp |= m->exclude_node(s);\n }\n\n if (!tmp && m->block())\n {\n Block_Ptr bb = operator()(m->block());\n for (size_t i = 0, L = bb->length(); i < L; ++i) {\n // (bb->elements())[i]->tabs(m->tabs());\n Statement_Obj stm = bb->at(i);\n if (bubblable(stm)) stm->tabs(stm->tabs() + m->tabs());\n }\n if (bb->length() && bubblable(bb->last())) bb->last()->group_end(m->group_end());\n return bb;\n }\n\n if (m->exclude_node(parent()))\n {\n return SASS_MEMORY_NEW(Bubble, m->pstate(), m);\n }\n\n return bubble(m);\n }\n\n Statement_Ptr Cssize::bubble(Directive_Ptr m)\n {\n Block_Ptr bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());\n Has_Block_Obj new_rule = Cast(SASS_MEMORY_COPY(this->parent()));\n new_rule->block(bb);\n new_rule->tabs(this->parent()->tabs());\n new_rule->block()->concat(m->block());\n\n Block_Obj wrapper_block = SASS_MEMORY_NEW(Block, m->block() ? m->block()->pstate() : m->pstate());\n wrapper_block->append(new_rule);\n Directive_Obj mm = SASS_MEMORY_NEW(Directive,\n m->pstate(),\n m->keyword(),\n m->selector(),\n wrapper_block);\n if (m->value()) mm->value(m->value());\n\n Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);\n return bubble;\n }\n\n Statement_Ptr Cssize::bubble(At_Root_Block_Ptr m)\n {\n if (!m || !m->block()) return NULL;\n Block_Ptr bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());\n Has_Block_Obj new_rule = Cast(SASS_MEMORY_COPY(this->parent()));\n Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());\n if (new_rule) {\n new_rule->block(bb);\n new_rule->tabs(this->parent()->tabs());\n new_rule->block()->concat(m->block());\n wrapper_block->append(new_rule);\n }\n\n At_Root_Block_Ptr mm = SASS_MEMORY_NEW(At_Root_Block,\n m->pstate(),\n wrapper_block,\n m->expression());\n Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);\n return bubble;\n }\n\n Statement_Ptr Cssize::bubble(Supports_Block_Ptr m)\n {\n Ruleset_Obj parent = Cast(SASS_MEMORY_COPY(this->parent()));\n\n Block_Ptr bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());\n Ruleset_Ptr new_rule = SASS_MEMORY_NEW(Ruleset,\n parent->pstate(),\n parent->selector(),\n bb);\n new_rule->tabs(parent->tabs());\n new_rule->block()->concat(m->block());\n\n Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());\n wrapper_block->append(new_rule);\n Supports_Block_Ptr mm = SASS_MEMORY_NEW(Supports_Block,\n m->pstate(),\n m->condition(),\n wrapper_block);\n\n mm->tabs(m->tabs());\n\n Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);\n return bubble;\n }\n\n Statement_Ptr Cssize::bubble(Media_Block_Ptr m)\n {\n Ruleset_Obj parent = Cast(SASS_MEMORY_COPY(this->parent()));\n\n Block_Ptr bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());\n Ruleset_Ptr new_rule = SASS_MEMORY_NEW(Ruleset,\n parent->pstate(),\n parent->selector(),\n bb);\n new_rule->tabs(parent->tabs());\n new_rule->block()->concat(m->block());\n\n Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());\n wrapper_block->append(new_rule);\n Media_Block_Obj mm = SASS_MEMORY_NEW(Media_Block,\n m->pstate(),\n m->media_queries(),\n wrapper_block);\n\n mm->tabs(m->tabs());\n\n return SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);\n }\n\n bool Cssize::bubblable(Statement_Ptr s)\n {\n return Cast(s) || s->bubbles();\n }\n\n Block_Ptr Cssize::flatten(Block_Ptr b)\n {\n Block_Ptr result = SASS_MEMORY_NEW(Block, b->pstate(), 0, b->is_root());\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Ptr ss = b->at(i);\n if (Block_Ptr bb = Cast(ss)) {\n Block_Obj bs = flatten(bb);\n for (size_t j = 0, K = bs->length(); j < K; ++j) {\n result->append(bs->at(j));\n }\n }\n else {\n result->append(ss);\n }\n }\n return result;\n }\n\n std::vector> Cssize::slice_by_bubble(Block_Ptr b)\n {\n std::vector> results;\n\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj value = b->at(i);\n bool key = Cast(value) != NULL;\n\n if (!results.empty() && results.back().first == key)\n {\n Block_Obj wrapper_block = results.back().second;\n wrapper_block->append(value);\n }\n else\n {\n Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, value->pstate());\n wrapper_block->append(value);\n results.push_back(std::make_pair(key, wrapper_block));\n }\n }\n return results;\n }\n\n Block_Ptr Cssize::debubble(Block_Ptr children, Statement_Ptr parent)\n {\n Has_Block_Obj previous_parent = 0;\n std::vector> baz = slice_by_bubble(children);\n Block_Obj result = SASS_MEMORY_NEW(Block, children->pstate());\n\n for (size_t i = 0, L = baz.size(); i < L; ++i) {\n bool is_bubble = baz[i].first;\n Block_Obj slice = baz[i].second;\n\n if (!is_bubble) {\n if (!parent) {\n result->append(slice);\n }\n else if (previous_parent) {\n previous_parent->block()->concat(slice);\n }\n else {\n previous_parent = Cast(SASS_MEMORY_COPY(parent));\n previous_parent->block(slice);\n previous_parent->tabs(parent->tabs());\n\n result->append(previous_parent);\n }\n continue;\n }\n\n for (size_t j = 0, K = slice->length(); j < K; ++j)\n {\n Statement_Ptr ss;\n Statement_Obj stm = slice->at(j);\n // this has to go now here (too bad)\n Bubble_Obj node = Cast(stm);\n Media_Block_Ptr m1 = NULL;\n Media_Block_Ptr m2 = NULL;\n if (parent) m1 = Cast(parent);\n if (node) m2 = Cast(node->node());\n if (!parent ||\n parent->statement_type() != Statement::MEDIA ||\n node->node()->statement_type() != Statement::MEDIA ||\n (m1 && m2 && *m1->media_queries() == *m2->media_queries())\n )\n {\n ss = node->node();\n }\n else\n {\n List_Obj mq = merge_media_queries(\n Cast(node->node()),\n Cast(parent)\n );\n if (!mq->length()) continue;\n if (Media_Block* b = Cast(node->node())) {\n b->media_queries(mq);\n }\n ss = node->node();\n }\n\n if (!ss) continue;\n\n ss->tabs(ss->tabs() + node->tabs());\n ss->group_end(node->group_end());\n\n Block_Obj bb = SASS_MEMORY_NEW(Block,\n children->pstate(),\n children->length(),\n children->is_root());\n bb->append(ss->perform(this));\n\n Block_Obj wrapper_block = SASS_MEMORY_NEW(Block,\n children->pstate(),\n children->length(),\n children->is_root());\n\n Block_Ptr wrapper = flatten(bb);\n wrapper_block->append(wrapper);\n\n if (wrapper->length()) {\n previous_parent = NULL;\n }\n\n if (wrapper_block) {\n result->append(wrapper_block);\n }\n }\n }\n\n return flatten(result);\n }\n\n Statement_Ptr Cssize::fallback_impl(AST_Node_Ptr n)\n {\n return static_cast(n);\n }\n\n void Cssize::append_block(Block_Ptr b, Block_Ptr cur)\n {\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj ith = b->at(i)->perform(this);\n if (Block_Ptr bb = Cast(ith)) {\n for (size_t j = 0, K = bb->length(); j < K; ++j) {\n cur->append(bb->at(j));\n }\n }\n else if (ith) {\n cur->append(ith);\n }\n }\n }\n\n List_Ptr Cssize::merge_media_queries(Media_Block_Ptr m1, Media_Block_Ptr m2)\n {\n List_Ptr qq = SASS_MEMORY_NEW(List,\n m1->media_queries()->pstate(),\n m1->media_queries()->length(),\n SASS_COMMA);\n\n for (size_t i = 0, L = m1->media_queries()->length(); i < L; i++) {\n for (size_t j = 0, K = m2->media_queries()->length(); j < K; j++) {\n Expression_Obj l1 = m1->media_queries()->at(i);\n Expression_Obj l2 = m2->media_queries()->at(j);\n Media_Query_Ptr mq1 = Cast(l1);\n Media_Query_Ptr mq2 = Cast(l2);\n Media_Query_Ptr mq = merge_media_query(mq1, mq2);\n if (mq) qq->append(mq);\n }\n }\n\n return qq;\n }\n\n\n Media_Query_Ptr Cssize::merge_media_query(Media_Query_Ptr mq1, Media_Query_Ptr mq2)\n {\n\n std::string type;\n std::string mod;\n\n std::string m1 = std::string(mq1->is_restricted() ? \"only\" : mq1->is_negated() ? \"not\" : \"\");\n std::string t1 = mq1->media_type() ? mq1->media_type()->to_string(ctx.c_options) : \"\";\n std::string m2 = std::string(mq2->is_restricted() ? \"only\" : mq2->is_negated() ? \"not\" : \"\");\n std::string t2 = mq2->media_type() ? mq2->media_type()->to_string(ctx.c_options) : \"\";\n\n\n if (t1.empty()) t1 = t2;\n if (t2.empty()) t2 = t1;\n\n if ((m1 == \"not\") ^ (m2 == \"not\")) {\n if (t1 == t2) {\n return 0;\n }\n type = m1 == \"not\" ? t2 : t1;\n mod = m1 == \"not\" ? m2 : m1;\n }\n else if (m1 == \"not\" && m2 == \"not\") {\n if (t1 != t2) {\n return 0;\n }\n type = t1;\n mod = \"not\";\n }\n else if (t1 != t2) {\n return 0;\n } else {\n type = t1;\n mod = m1.empty() ? m2 : m1;\n }\n\n Media_Query_Ptr mm = SASS_MEMORY_NEW(Media_Query,\n mq1->pstate(),\n 0,\n mq1->length() + mq2->length(),\n mod == \"not\",\n mod == \"only\");\n\n if (!type.empty()) {\n mm->media_type(SASS_MEMORY_NEW(String_Quoted, mq1->pstate(), type));\n }\n\n mm->concat(mq2);\n mm->concat(mq1);\n\n return mm;\n }\n}\n" }, { "path": "libsass-build/cssize.hpp", "content": "#ifndef SASS_CSSIZE_H\n#define SASS_CSSIZE_H\n\n#include \"ast.hpp\"\n#include \"context.hpp\"\n#include \"operation.hpp\"\n#include \"environment.hpp\"\n\nnamespace Sass {\n\n struct Backtrace;\n\n class Cssize : public Operation_CRTP {\n\n Context& ctx;\n Backtraces& traces;\n std::vector block_stack;\n std::vector p_stack;\n\n Statement_Ptr fallback_impl(AST_Node_Ptr n);\n\n public:\n Cssize(Context&);\n ~Cssize() { }\n\n Selector_List_Ptr selector();\n\n Block_Ptr operator()(Block_Ptr);\n Statement_Ptr operator()(Ruleset_Ptr);\n // Statement_Ptr operator()(Bubble_Ptr);\n Statement_Ptr operator()(Media_Block_Ptr);\n Statement_Ptr operator()(Supports_Block_Ptr);\n Statement_Ptr operator()(At_Root_Block_Ptr);\n Statement_Ptr operator()(Directive_Ptr);\n Statement_Ptr operator()(Keyframe_Rule_Ptr);\n Statement_Ptr operator()(Trace_Ptr);\n Statement_Ptr operator()(Declaration_Ptr);\n // Statement_Ptr operator()(Assignment_Ptr);\n // Statement_Ptr operator()(Import_Ptr);\n // Statement_Ptr operator()(Import_Stub_Ptr);\n // Statement_Ptr operator()(Warning_Ptr);\n // Statement_Ptr operator()(Error_Ptr);\n // Statement_Ptr operator()(Comment_Ptr);\n // Statement_Ptr operator()(If_Ptr);\n // Statement_Ptr operator()(For_Ptr);\n // Statement_Ptr operator()(Each_Ptr);\n // Statement_Ptr operator()(While_Ptr);\n // Statement_Ptr operator()(Return_Ptr);\n // Statement_Ptr operator()(Extension_Ptr);\n // Statement_Ptr operator()(Definition_Ptr);\n // Statement_Ptr operator()(Mixin_Call_Ptr);\n // Statement_Ptr operator()(Content_Ptr);\n Statement_Ptr operator()(Null_Ptr);\n\n Statement_Ptr parent();\n std::vector> slice_by_bubble(Block_Ptr);\n Statement_Ptr bubble(Directive_Ptr);\n Statement_Ptr bubble(At_Root_Block_Ptr);\n Statement_Ptr bubble(Media_Block_Ptr);\n Statement_Ptr bubble(Supports_Block_Ptr);\n\n Block_Ptr debubble(Block_Ptr children, Statement_Ptr parent = 0);\n Block_Ptr flatten(Block_Ptr);\n bool bubblable(Statement_Ptr);\n\n List_Ptr merge_media_queries(Media_Block_Ptr, Media_Block_Ptr);\n Media_Query_Ptr merge_media_query(Media_Query_Ptr, Media_Query_Ptr);\n\n template \n Statement_Ptr fallback(U x) { return fallback_impl(x); }\n\n void append_block(Block_Ptr, Block_Ptr);\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/debug.hpp", "content": "#ifndef SASS_DEBUG_H\n#define SASS_DEBUG_H\n\n#include \n\n#ifndef UINT32_MAX\n #define UINT32_MAX 0xffffffffU\n#endif\n\nenum dbg_lvl_t : uint32_t {\n NONE = 0,\n TRIM = 1,\n CHUNKS = 2,\n SUBWEAVE = 4,\n WEAVE = 8,\n EXTEND_COMPOUND = 16,\n EXTEND_COMPLEX = 32,\n LCS = 64,\n EXTEND_OBJECT = 128,\n ALL = UINT32_MAX\n};\n\n#ifdef DEBUG\n\n#ifndef DEBUG_LVL\nconst uint32_t debug_lvl = UINT32_MAX;\n#else\nconst uint32_t debug_lvl = (DEBUG_LVL);\n#endif // DEBUG_LVL\n\n#define DEBUG_PRINT(lvl, x) if((lvl) & debug_lvl) { std::cerr << x; }\n#define DEBUG_PRINTLN(lvl, x) if((lvl) & debug_lvl) { std::cerr << x << std::endl; }\n#define DEBUG_EXEC(lvl, x) if((lvl) & debug_lvl) { x; }\n\n#else // DEBUG\n\n#define DEBUG_PRINT(lvl, x)\n#define DEBUG_PRINTLN(lvl, x)\n#define DEBUG_EXEC(lvl, x)\n\n#endif // DEBUG\n\n#endif // SASS_DEBUG\n" }, { "path": "libsass-build/debugger.hpp", "content": "#ifndef SASS_DEBUGGER_H\n#define SASS_DEBUGGER_H\n\n#include \n#include \n#include \"node.hpp\"\n#include \"ast_fwd_decl.hpp\"\n\nusing namespace Sass;\n\ninline void debug_ast(AST_Node_Ptr node, std::string ind = \"\", Env* env = 0);\n\ninline void debug_ast(const AST_Node* node, std::string ind = \"\", Env* env = 0) {\n debug_ast(const_cast(node), ind, env);\n}\n\ninline void debug_sources_set(ComplexSelectorSet& set, std::string ind = \"\")\n{\n if (ind == \"\") std::cerr << \"#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\\n\";\n for(auto const &pair : set) {\n debug_ast(pair, ind + \"\");\n // debug_ast(set[pair], ind + \"first: \");\n }\n if (ind == \"\") std::cerr << \"#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\\n\";\n}\n\ninline std::string str_replace(std::string str, const std::string& oldStr, const std::string& newStr)\n{\n size_t pos = 0;\n while((pos = str.find(oldStr, pos)) != std::string::npos)\n {\n str.replace(pos, oldStr.length(), newStr);\n pos += newStr.length();\n }\n return str;\n}\n\ninline std::string prettyprint(const std::string& str) {\n std::string clean = str_replace(str, \"\\n\", \"\\\\n\");\n clean = str_replace(clean, \"\t\", \"\\\\t\");\n clean = str_replace(clean, \"\\r\", \"\\\\r\");\n return clean;\n}\n\ninline std::string longToHex(long long t) {\n std::stringstream is;\n is << std::hex << t;\n return is.str();\n}\n\ninline std::string pstate_source_position(AST_Node_Ptr node)\n{\n std::stringstream str;\n Position start(node->pstate());\n Position end(start + node->pstate().offset);\n str << (start.file == std::string::npos ? -1 : start.file)\n << \"@[\" << start.line << \":\" << start.column << \"]\"\n << \"-[\" << end.line << \":\" << end.column << \"]\";\n#ifdef DEBUG_SHARED_PTR\n str << \"x\" << node->getRefCount() << \"\"\n << \" \" << node->getDbgFile()\n << \"@\" << node->getDbgLine();\n#endif\n return str.str();\n}\n\ninline void debug_ast(AST_Node_Ptr node, std::string ind, Env* env)\n{\n if (node == 0) return;\n if (ind == \"\") std::cerr << \"####################################################################\\n\";\n if (Cast(node)) {\n Bubble_Ptr bubble = Cast(node);\n std::cerr << ind << \"Bubble \" << bubble;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << bubble->tabs();\n std::cerr << std::endl;\n debug_ast(bubble->node(), ind + \" \", env);\n } else if (Cast(node)) {\n Trace_Ptr trace = Cast(node);\n std::cerr << ind << \"Trace \" << trace;\n std::cerr << \" (\" << pstate_source_position(node) << \")\"\n << \" [name:\" << trace->name() << \", type: \" << trace->type() << \"]\"\n << std::endl;\n debug_ast(trace->block(), ind + \" \", env);\n } else if (Cast(node)) {\n At_Root_Block_Ptr root_block = Cast(node);\n std::cerr << ind << \"At_Root_Block \" << root_block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << root_block->tabs();\n std::cerr << std::endl;\n debug_ast(root_block->expression(), ind + \":\", env);\n debug_ast(root_block->block(), ind + \" \", env);\n } else if (Cast(node)) {\n Selector_List_Ptr selector = Cast(node);\n std::cerr << ind << \"Selector_List \" << selector;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" <\" << selector->hash() << \">\";\n std::cerr << \" [@media:\" << selector->media_block() << \"]\";\n std::cerr << (selector->is_invisible() ? \" [INVISIBLE]\": \" -\");\n std::cerr << (selector->has_placeholder() ? \" [PLACEHOLDER]\": \" -\");\n std::cerr << (selector->is_optional() ? \" [is_optional]\": \" -\");\n std::cerr << (selector->has_parent_ref() ? \" [has-parent]\": \" -\");\n std::cerr << (selector->has_line_break() ? \" [line-break]\": \" -\");\n std::cerr << (selector->has_line_feed() ? \" [line-feed]\": \" -\");\n std::cerr << std::endl;\n debug_ast(selector->schema(), ind + \"#{} \");\n\n for(const Complex_Selector_Obj& i : selector->elements()) { debug_ast(i, ind + \" \", env); }\n\n// } else if (Cast(node)) {\n// Expression_Ptr expression = Cast(node);\n// std::cerr << ind << \"Expression \" << expression << \" \" << expression->concrete_type() << std::endl;\n\n } else if (Cast(node)) {\n Parent_Selector_Ptr selector = Cast(node);\n std::cerr << ind << \"Parent_Selector \" << selector;\n// if (selector->not_selector()) cerr << \" [in_declaration]\";\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" <\" << selector->hash() << \">\";\n std::cerr << \" [\" << (selector->is_real_parent_ref() ? \"REAL\" : \"FAKE\") << \"]\";\n std::cerr << \" <\" << prettyprint(selector->pstate().token.ws_before()) << \">\" << std::endl;\n// debug_ast(selector->selector(), ind + \"->\", env);\n\n } else if (Cast(node)) {\n Complex_Selector_Ptr selector = Cast(node);\n std::cerr << ind << \"Complex_Selector \" << selector\n << \" (\" << pstate_source_position(node) << \")\"\n << \" <\" << selector->hash() << \">\"\n << \" [length:\" << longToHex(selector->length()) << \"]\"\n << \" [weight:\" << longToHex(selector->specificity()) << \"]\"\n << \" [@media:\" << selector->media_block() << \"]\"\n << (selector->is_invisible() ? \" [INVISIBLE]\": \" -\")\n << (selector->has_placeholder() ? \" [PLACEHOLDER]\": \" -\")\n << (selector->is_optional() ? \" [is_optional]\": \" -\")\n << (selector->has_parent_ref() ? \" [has parent]\": \" -\")\n << (selector->has_line_feed() ? \" [line-feed]\": \" -\")\n << (selector->has_line_break() ? \" [line-break]\": \" -\")\n << \" -- \";\n std::string del;\n switch (selector->combinator()) {\n case Complex_Selector::PARENT_OF: del = \">\"; break;\n case Complex_Selector::PRECEDES: del = \"~\"; break;\n case Complex_Selector::ADJACENT_TO: del = \"+\"; break;\n case Complex_Selector::ANCESTOR_OF: del = \" \"; break;\n case Complex_Selector::REFERENCE: del = \"//\"; break;\n }\n // if (del = \"/\") del += selector->reference()->perform(&to_string) + \"/\";\n std::cerr << \" <\" << prettyprint(selector->pstate().token.ws_before()) << \">\" << std::endl;\n debug_ast(selector->head(), ind + \" \" /* + \"[\" + del + \"]\" */, env);\n if (selector->tail()) {\n debug_ast(selector->tail(), ind + \"{\" + del + \"}\", env);\n } else if(del != \" \") {\n std::cerr << ind << \" |\" << del << \"| {trailing op}\" << std::endl;\n }\n ComplexSelectorSet set = selector->sources();\n // debug_sources_set(set, ind + \" @--> \");\n } else if (Cast(node)) {\n Compound_Selector_Ptr selector = Cast(node);\n std::cerr << ind << \"Compound_Selector \" << selector;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" <\" << selector->hash() << \">\";\n std::cerr << \" [weight:\" << longToHex(selector->specificity()) << \"]\";\n std::cerr << \" [@media:\" << selector->media_block() << \"]\";\n std::cerr << (selector->extended() ? \" [extended]\": \" -\");\n std::cerr << (selector->is_optional() ? \" [is_optional]\": \" -\");\n std::cerr << (selector->has_parent_ref() ? \" [has-parent]\": \" -\");\n std::cerr << (selector->has_line_break() ? \" [line-break]\": \" -\");\n std::cerr << (selector->has_line_feed() ? \" [line-feed]\": \" -\");\n std::cerr << \" <\" << prettyprint(selector->pstate().token.ws_before()) << \">\" << std::endl;\n for(const Simple_Selector_Obj& i : selector->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n Wrapped_Selector_Ptr selector = Cast(node);\n std::cerr << ind << \"Wrapped_Selector \" << selector;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" <\" << selector->hash() << \">\";\n std::cerr << \" <<\" << selector->ns_name() << \">>\";\n std::cerr << (selector->is_optional() ? \" [is_optional]\": \" -\");\n std::cerr << (selector->has_parent_ref() ? \" [has-parent]\": \" -\");\n std::cerr << (selector->has_line_break() ? \" [line-break]\": \" -\");\n std::cerr << (selector->has_line_feed() ? \" [line-feed]\": \" -\");\n std::cerr << std::endl;\n debug_ast(selector->selector(), ind + \" () \", env);\n } else if (Cast(node)) {\n Pseudo_Selector_Ptr selector = Cast(node);\n std::cerr << ind << \"Pseudo_Selector \" << selector;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" <\" << selector->hash() << \">\";\n std::cerr << \" <<\" << selector->ns_name() << \">>\";\n std::cerr << (selector->is_optional() ? \" [is_optional]\": \" -\");\n std::cerr << (selector->has_parent_ref() ? \" [has-parent]\": \" -\");\n std::cerr << (selector->has_line_break() ? \" [line-break]\": \" -\");\n std::cerr << (selector->has_line_feed() ? \" [line-feed]\": \" -\");\n std::cerr << std::endl;\n debug_ast(selector->expression(), ind + \" <= \", env);\n } else if (Cast(node)) {\n Attribute_Selector_Ptr selector = Cast(node);\n std::cerr << ind << \"Attribute_Selector \" << selector;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" <\" << selector->hash() << \">\";\n std::cerr << \" <<\" << selector->ns_name() << \">>\";\n std::cerr << (selector->is_optional() ? \" [is_optional]\": \" -\");\n std::cerr << (selector->has_parent_ref() ? \" [has-parent]\": \" -\");\n std::cerr << (selector->has_line_break() ? \" [line-break]\": \" -\");\n std::cerr << (selector->has_line_feed() ? \" [line-feed]\": \" -\");\n std::cerr << std::endl;\n debug_ast(selector->value(), ind + \"[\" + selector->matcher() + \"] \", env);\n } else if (Cast(node)) {\n Class_Selector_Ptr selector = Cast(node);\n std::cerr << ind << \"Class_Selector \" << selector;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" <\" << selector->hash() << \">\";\n std::cerr << \" <<\" << selector->ns_name() << \">>\";\n std::cerr << (selector->is_optional() ? \" [is_optional]\": \" -\");\n std::cerr << (selector->has_parent_ref() ? \" [has-parent]\": \" -\");\n std::cerr << (selector->has_line_break() ? \" [line-break]\": \" -\");\n std::cerr << (selector->has_line_feed() ? \" [line-feed]\": \" -\");\n std::cerr << std::endl;\n } else if (Cast(node)) {\n Id_Selector_Ptr selector = Cast(node);\n std::cerr << ind << \"Id_Selector \" << selector;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" <\" << selector->hash() << \">\";\n std::cerr << \" <<\" << selector->ns_name() << \">>\";\n std::cerr << (selector->is_optional() ? \" [is_optional]\": \" -\");\n std::cerr << (selector->has_parent_ref() ? \" [has-parent]\": \" -\");\n std::cerr << (selector->has_line_break() ? \" [line-break]\": \" -\");\n std::cerr << (selector->has_line_feed() ? \" [line-feed]\": \" -\");\n std::cerr << std::endl;\n } else if (Cast(node)) {\n Element_Selector_Ptr selector = Cast(node);\n std::cerr << ind << \"Element_Selector \" << selector;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" <\" << selector->hash() << \">\";\n std::cerr << \" <<\" << selector->ns_name() << \">>\";\n std::cerr << (selector->is_optional() ? \" [is_optional]\": \" -\");\n std::cerr << (selector->has_parent_ref() ? \" [has-parent]\": \" -\");\n std::cerr << (selector->has_line_break() ? \" [line-break]\": \" -\");\n std::cerr << (selector->has_line_feed() ? \" [line-feed]\": \" -\");\n std::cerr << \" <\" << prettyprint(selector->pstate().token.ws_before()) << \">\";\n std::cerr << std::endl;\n } else if (Cast(node)) {\n\n Placeholder_Selector_Ptr selector = Cast(node);\n std::cerr << ind << \"Placeholder_Selector [\" << selector->ns_name() << \"] \" << selector;\n std::cerr << \" (\" << pstate_source_position(selector) << \")\"\n << \" <\" << selector->hash() << \">\"\n << \" [@media:\" << selector->media_block() << \"]\"\n << (selector->is_optional() ? \" [is_optional]\": \" -\")\n << (selector->has_line_break() ? \" [line-break]\": \" -\")\n << (selector->has_line_feed() ? \" [line-feed]\": \" -\")\n << std::endl;\n\n } else if (Cast(node)) {\n Simple_Selector* selector = Cast(node);\n std::cerr << ind << \"Simple_Selector \" << selector;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << (selector->has_line_break() ? \" [line-break]\": \" -\") << (selector->has_line_feed() ? \" [line-feed]\": \" -\") << std::endl;\n\n } else if (Cast(node)) {\n Selector_Schema_Ptr selector = Cast(node);\n std::cerr << ind << \"Selector_Schema \" << selector;\n std::cerr << \" (\" << pstate_source_position(node) << \")\"\n << \" [@media:\" << selector->media_block() << \"]\"\n << (selector->connect_parent() ? \" [connect-parent]\": \" -\")\n << std::endl;\n\n debug_ast(selector->contents(), ind + \" \");\n // for(auto i : selector->elements()) { debug_ast(i, ind + \" \", env); }\n\n } else if (Cast(node)) {\n Selector_Ptr selector = Cast(node);\n std::cerr << ind << \"Selector \" << selector;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << (selector->has_line_break() ? \" [line-break]\": \" -\")\n << (selector->has_line_feed() ? \" [line-feed]\": \" -\")\n << std::endl;\n\n } else if (Cast(node)) {\n Media_Query_Expression_Ptr block = Cast(node);\n std::cerr << ind << \"Media_Query_Expression \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << (block->is_interpolated() ? \" [is_interpolated]\": \" -\")\n << std::endl;\n debug_ast(block->feature(), ind + \" feature) \");\n debug_ast(block->value(), ind + \" value) \");\n\n } else if (Cast(node)) {\n Media_Query_Ptr block = Cast(node);\n std::cerr << ind << \"Media_Query \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << (block->is_negated() ? \" [is_negated]\": \" -\")\n << (block->is_restricted() ? \" [is_restricted]\": \" -\")\n << std::endl;\n debug_ast(block->media_type(), ind + \" \");\n for(const auto& i : block->elements()) { debug_ast(i, ind + \" \", env); }\n\n } else if (Cast(node)) {\n Media_Block_Ptr block = Cast(node);\n std::cerr << ind << \"Media_Block \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() << std::endl;\n debug_ast(block->media_queries(), ind + \" =@ \");\n if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n Supports_Block_Ptr block = Cast(node);\n std::cerr << ind << \"Supports_Block \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() << std::endl;\n debug_ast(block->condition(), ind + \" =@ \");\n debug_ast(block->block(), ind + \" <>\");\n } else if (Cast(node)) {\n Supports_Operator_Ptr block = Cast(node);\n std::cerr << ind << \"Supports_Operator \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\"\n << std::endl;\n debug_ast(block->left(), ind + \" left) \");\n debug_ast(block->right(), ind + \" right) \");\n } else if (Cast(node)) {\n Supports_Negation_Ptr block = Cast(node);\n std::cerr << ind << \"Supports_Negation \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\"\n << std::endl;\n debug_ast(block->condition(), ind + \" condition) \");\n } else if (Cast(node)) {\n At_Root_Query_Ptr block = Cast(node);\n std::cerr << ind << \"At_Root_Query \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\"\n << std::endl;\n debug_ast(block->feature(), ind + \" feature) \");\n debug_ast(block->value(), ind + \" value) \");\n } else if (Cast(node)) {\n Supports_Declaration_Ptr block = Cast(node);\n std::cerr << ind << \"Supports_Declaration \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\"\n << std::endl;\n debug_ast(block->feature(), ind + \" feature) \");\n debug_ast(block->value(), ind + \" value) \");\n } else if (Cast(node)) {\n Block_Ptr root_block = Cast(node);\n std::cerr << ind << \"Block \" << root_block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n if (root_block->is_root()) std::cerr << \" [root]\";\n std::cerr << \" \" << root_block->tabs() << std::endl;\n for(const Statement_Obj& i : root_block->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n Warning_Ptr block = Cast(node);\n std::cerr << ind << \"Warning \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() << std::endl;\n debug_ast(block->message(), ind + \" : \");\n } else if (Cast(node)) {\n Error_Ptr block = Cast(node);\n std::cerr << ind << \"Error \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() << std::endl;\n } else if (Cast(node)) {\n Debug_Ptr block = Cast(node);\n std::cerr << ind << \"Debug \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() << std::endl;\n debug_ast(block->value(), ind + \" \");\n } else if (Cast(node)) {\n Comment_Ptr block = Cast(node);\n std::cerr << ind << \"Comment \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() <<\n \" <\" << prettyprint(block->pstate().token.ws_before()) << \">\" << std::endl;\n debug_ast(block->text(), ind + \"// \", env);\n } else if (Cast(node)) {\n If_Ptr block = Cast(node);\n std::cerr << ind << \"If \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() << std::endl;\n debug_ast(block->predicate(), ind + \" = \");\n debug_ast(block->block(), ind + \" <>\");\n debug_ast(block->alternative(), ind + \" ><\");\n } else if (Cast(node)) {\n Return_Ptr block = Cast(node);\n std::cerr << ind << \"Return \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() << std::endl;\n } else if (Cast(node)) {\n Extension_Ptr block = Cast(node);\n std::cerr << ind << \"Extension \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() << std::endl;\n debug_ast(block->selector(), ind + \"-> \", env);\n } else if (Cast(node)) {\n Content_Ptr block = Cast(node);\n std::cerr << ind << \"Content \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [@media:\" << block->media_block() << \"]\";\n std::cerr << \" \" << block->tabs() << std::endl;\n } else if (Cast(node)) {\n Import_Stub_Ptr block = Cast(node);\n std::cerr << ind << \"Import_Stub \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [\" << block->imp_path() << \"] \";\n std::cerr << \" \" << block->tabs() << std::endl;\n } else if (Cast(node)) {\n Import_Ptr block = Cast(node);\n std::cerr << ind << \"Import \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() << std::endl;\n // std::vector files_;\n for (auto imp : block->urls()) debug_ast(imp, ind + \"@: \", env);\n debug_ast(block->import_queries(), ind + \"@@ \");\n } else if (Cast(node)) {\n Assignment_Ptr block = Cast(node);\n std::cerr << ind << \"Assignment \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" <<\" << block->variable() << \">> \" << block->tabs() << std::endl;\n debug_ast(block->value(), ind + \"=\", env);\n } else if (Cast(node)) {\n Declaration_Ptr block = Cast(node);\n std::cerr << ind << \"Declaration \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [is_custom_property: \" << block->is_custom_property() << \"] \";\n std::cerr << \" \" << block->tabs() << std::endl;\n debug_ast(block->property(), ind + \" prop: \", env);\n debug_ast(block->value(), ind + \" value: \", env);\n debug_ast(block->block(), ind + \" \", env);\n } else if (Cast(node)) {\n Keyframe_Rule_Ptr has_block = Cast(node);\n std::cerr << ind << \"Keyframe_Rule \" << has_block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << has_block->tabs() << std::endl;\n if (has_block->name()) debug_ast(has_block->name(), ind + \"@\");\n if (has_block->block()) for(const Statement_Obj& i : has_block->block()->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n Directive_Ptr block = Cast(node);\n std::cerr << ind << \"Directive \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [\" << block->keyword() << \"] \" << block->tabs() << std::endl;\n debug_ast(block->selector(), ind + \"~\", env);\n debug_ast(block->value(), ind + \"+\", env);\n if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n Each_Ptr block = Cast(node);\n std::cerr << ind << \"Each \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() << std::endl;\n if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n For_Ptr block = Cast(node);\n std::cerr << ind << \"For \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() << std::endl;\n if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n While_Ptr block = Cast(node);\n std::cerr << ind << \"While \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << block->tabs() << std::endl;\n if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n Definition_Ptr block = Cast(node);\n std::cerr << ind << \"Definition \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [name: \" << block->name() << \"] \";\n std::cerr << \" [type: \" << (block->type() == Sass::Definition::Type::MIXIN ? \"Mixin \" : \"Function \") << \"] \";\n // this seems to lead to segfaults some times?\n // std::cerr << \" [signature: \" << block->signature() << \"] \";\n std::cerr << \" [native: \" << block->native_function() << \"] \";\n std::cerr << \" \" << block->tabs() << std::endl;\n debug_ast(block->parameters(), ind + \" params: \", env);\n if (block->block()) debug_ast(block->block(), ind + \" \", env);\n } else if (Cast(node)) {\n Mixin_Call_Ptr block = Cast(node);\n std::cerr << ind << \"Mixin_Call \" << block << \" \" << block->tabs();\n std::cerr << \" (\" << pstate_source_position(block) << \")\";\n std::cerr << \" [\" << block->name() << \"]\";\n std::cerr << \" [has_content: \" << block->has_content() << \"] \" << std::endl;\n debug_ast(block->arguments(), ind + \" args: \");\n if (block->block()) debug_ast(block->block(), ind + \" \", env);\n } else if (Ruleset_Ptr ruleset = Cast(node)) {\n std::cerr << ind << \"Ruleset \" << ruleset;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [indent: \" << ruleset->tabs() << \"]\";\n std::cerr << (ruleset->is_invisible() ? \" [INVISIBLE]\" : \"\");\n std::cerr << (ruleset->is_root() ? \" [root]\" : \"\");\n std::cerr << std::endl;\n debug_ast(ruleset->selector(), ind + \">\");\n debug_ast(ruleset->block(), ind + \" \");\n } else if (Cast(node)) {\n Block_Ptr block = Cast(node);\n std::cerr << ind << \"Block \" << block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << (block->is_invisible() ? \" [INVISIBLE]\" : \"\");\n std::cerr << \" [indent: \" << block->tabs() << \"]\" << std::endl;\n for(const Statement_Obj& i : block->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n Variable_Ptr expression = Cast(node);\n std::cerr << ind << \"Variable \" << expression;\n std::cerr << \" [interpolant: \" << expression->is_interpolant() << \"] \";\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [\" << expression->name() << \"]\" << std::endl;\n std::string name(expression->name());\n if (env && env->has(name)) debug_ast(Cast((*env)[name]), ind + \" -> \", env);\n } else if (Cast(node)) {\n Function_Call_Schema_Ptr expression = Cast(node);\n std::cerr << ind << \"Function_Call_Schema \" << expression;\n std::cerr << \" [interpolant: \" << expression->is_interpolant() << \"] \";\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \"\" << std::endl;\n debug_ast(expression->name(), ind + \"name: \", env);\n debug_ast(expression->arguments(), ind + \" args: \", env);\n } else if (Cast(node)) {\n Function_Call_Ptr expression = Cast(node);\n std::cerr << ind << \"Function_Call \" << expression;\n std::cerr << \" [interpolant: \" << expression->is_interpolant() << \"] \";\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [\" << expression->name() << \"]\";\n if (expression->is_delayed()) std::cerr << \" [delayed]\";\n if (expression->is_interpolant()) std::cerr << \" [interpolant]\";\n if (expression->is_css()) std::cerr << \" [css]\";\n std::cerr << std::endl;\n debug_ast(expression->arguments(), ind + \" args: \", env);\n debug_ast(expression->func(), ind + \" func: \", env);\n } else if (Cast(node)) {\n Function_Ptr expression = Cast(node);\n std::cerr << ind << \"Function \" << expression;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n if (expression->is_css()) std::cerr << \" [css]\";\n std::cerr << std::endl;\n debug_ast(expression->definition(), ind + \" definition: \", env);\n } else if (Cast(node)) {\n Arguments_Ptr expression = Cast(node);\n std::cerr << ind << \"Arguments \" << expression;\n if (expression->is_delayed()) std::cerr << \" [delayed]\";\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n if (expression->has_named_arguments()) std::cerr << \" [has_named_arguments]\";\n if (expression->has_rest_argument()) std::cerr << \" [has_rest_argument]\";\n if (expression->has_keyword_argument()) std::cerr << \" [has_keyword_argument]\";\n std::cerr << std::endl;\n for(const Argument_Obj& i : expression->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n Argument_Ptr expression = Cast(node);\n std::cerr << ind << \"Argument \" << expression;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [\" << expression->value().ptr() << \"]\";\n std::cerr << \" [name: \" << expression->name() << \"] \";\n std::cerr << \" [rest: \" << expression->is_rest_argument() << \"] \";\n std::cerr << \" [keyword: \" << expression->is_keyword_argument() << \"] \" << std::endl;\n debug_ast(expression->value(), ind + \" value: \", env);\n } else if (Cast(node)) {\n Parameters_Ptr expression = Cast(node);\n std::cerr << ind << \"Parameters \" << expression;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [has_optional: \" << expression->has_optional_parameters() << \"] \";\n std::cerr << \" [has_rest: \" << expression->has_rest_parameter() << \"] \";\n std::cerr << std::endl;\n for(const Parameter_Obj& i : expression->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n Parameter_Ptr expression = Cast(node);\n std::cerr << ind << \"Parameter \" << expression;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [name: \" << expression->name() << \"] \";\n std::cerr << \" [default: \" << expression->default_value().ptr() << \"] \";\n std::cerr << \" [rest: \" << expression->is_rest_parameter() << \"] \" << std::endl;\n } else if (Cast(node)) {\n Unary_Expression_Ptr expression = Cast(node);\n std::cerr << ind << \"Unary_Expression \" << expression;\n std::cerr << \" [interpolant: \" << expression->is_interpolant() << \"] \";\n std::cerr << \" [delayed: \" << expression->is_delayed() << \"] \";\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [\" << expression->type() << \"]\" << std::endl;\n debug_ast(expression->operand(), ind + \" operand: \", env);\n } else if (Cast(node)) {\n Binary_Expression_Ptr expression = Cast(node);\n std::cerr << ind << \"Binary_Expression \" << expression;\n if (expression->is_interpolant()) std::cerr << \" [is interpolant] \";\n if (expression->is_left_interpolant()) std::cerr << \" [left interpolant] \";\n if (expression->is_right_interpolant()) std::cerr << \" [right interpolant] \";\n std::cerr << \" [delayed: \" << expression->is_delayed() << \"] \";\n std::cerr << \" [ws_before: \" << expression->op().ws_before << \"] \";\n std::cerr << \" [ws_after: \" << expression->op().ws_after << \"] \";\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [\" << expression->type_name() << \"]\" << std::endl;\n debug_ast(expression->left(), ind + \" left: \", env);\n debug_ast(expression->right(), ind + \" right: \", env);\n } else if (Cast(node)) {\n Map_Ptr expression = Cast(node);\n std::cerr << ind << \"Map \" << expression;\n std::cerr << \" [interpolant: \" << expression->is_interpolant() << \"] \";\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [Hashed]\" << std::endl;\n for (const auto& i : expression->elements()) {\n debug_ast(i.first, ind + \" key: \");\n debug_ast(i.second, ind + \" val: \");\n }\n } else if (Cast(node)) {\n List_Ptr expression = Cast(node);\n std::cerr << ind << \"List \" << expression;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" (\" << expression->length() << \") \" <<\n (expression->separator() == SASS_COMMA ? \"Comma \" : expression->separator() == SASS_HASH ? \"Map \" : \"Space \") <<\n \" [delayed: \" << expression->is_delayed() << \"] \" <<\n \" [interpolant: \" << expression->is_interpolant() << \"] \" <<\n \" [listized: \" << expression->from_selector() << \"] \" <<\n \" [arglist: \" << expression->is_arglist() << \"] \" <<\n \" [bracketed: \" << expression->is_bracketed() << \"] \" <<\n \" [expanded: \" << expression->is_expanded() << \"] \" <<\n \" [hash: \" << expression->hash() << \"] \" <<\n std::endl;\n for(const auto& i : expression->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n Content_Ptr expression = Cast(node);\n std::cerr << ind << \"Content \" << expression;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [@media:\" << expression->media_block() << \"]\";\n std::cerr << \" [Statement]\" << std::endl;\n } else if (Cast(node)) {\n Boolean_Ptr expression = Cast(node);\n std::cerr << ind << \"Boolean \" << expression;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [interpolant: \" << expression->is_interpolant() << \"] \";\n std::cerr << \" [\" << expression->value() << \"]\" << std::endl;\n } else if (Cast(node)) {\n Color_Ptr expression = Cast(node);\n std::cerr << ind << \"Color \" << expression;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [delayed: \" << expression->is_delayed() << \"] \";\n std::cerr << \" [interpolant: \" << expression->is_interpolant() << \"] \";\n std::cerr << \" [\" << expression->r() << \":\" << expression->g() << \":\" << expression->b() << \"@\" << expression->a() << \"]\" << std::endl;\n } else if (Cast(node)) {\n Number_Ptr expression = Cast(node);\n std::cerr << ind << \"Number \" << expression;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [delayed: \" << expression->is_delayed() << \"] \";\n std::cerr << \" [interpolant: \" << expression->is_interpolant() << \"] \";\n std::cerr << \" [\" << expression->value() << expression->unit() << \"]\" <<\n \" [hash: \" << expression->hash() << \"] \" <<\n std::endl;\n } else if (Cast(node)) {\n Null_Ptr expression = Cast(node);\n std::cerr << ind << \"Null \" << expression;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [interpolant: \" << expression->is_interpolant() << \"] \"\n // \" [hash: \" << expression->hash() << \"] \"\n << std::endl;\n } else if (Cast(node)) {\n String_Quoted_Ptr expression = Cast(node);\n std::cerr << ind << \"String_Quoted \" << expression;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [\" << prettyprint(expression->value()) << \"]\";\n if (expression->is_delayed()) std::cerr << \" [delayed]\";\n if (expression->is_interpolant()) std::cerr << \" [interpolant]\";\n if (expression->quote_mark()) std::cerr << \" [quote_mark: \" << expression->quote_mark() << \"]\";\n std::cerr << \" <\" << prettyprint(expression->pstate().token.ws_before()) << \">\" << std::endl;\n } else if (Cast(node)) {\n String_Constant_Ptr expression = Cast(node);\n std::cerr << ind << \"String_Constant \" << expression;\n if (expression->concrete_type()) {\n std::cerr << \" \" << expression->concrete_type();\n }\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" [\" << prettyprint(expression->value()) << \"]\";\n if (expression->is_delayed()) std::cerr << \" [delayed]\";\n if (expression->is_interpolant()) std::cerr << \" [interpolant]\";\n std::cerr << \" <\" << prettyprint(expression->pstate().token.ws_before()) << \">\" << std::endl;\n } else if (Cast(node)) {\n String_Schema_Ptr expression = Cast(node);\n std::cerr << ind << \"String_Schema \" << expression;\n std::cerr << \" (\" << pstate_source_position(expression) << \")\";\n std::cerr << \" \" << expression->concrete_type();\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n if (expression->css()) std::cerr << \" [css]\";\n if (expression->is_delayed()) std::cerr << \" [delayed]\";\n if (expression->is_interpolant()) std::cerr << \" [is interpolant]\";\n if (expression->has_interpolant()) std::cerr << \" [has interpolant]\";\n if (expression->is_left_interpolant()) std::cerr << \" [left interpolant] \";\n if (expression->is_right_interpolant()) std::cerr << \" [right interpolant] \";\n std::cerr << \" <\" << prettyprint(expression->pstate().token.ws_before()) << \">\" << std::endl;\n for(const auto& i : expression->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n String_Ptr expression = Cast(node);\n std::cerr << ind << \"String \" << expression;\n std::cerr << \" \" << expression->concrete_type();\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n if (expression->is_interpolant()) std::cerr << \" [interpolant]\";\n std::cerr << \" <\" << prettyprint(expression->pstate().token.ws_before()) << \">\" << std::endl;\n } else if (Cast(node)) {\n Expression_Ptr expression = Cast(node);\n std::cerr << ind << \"Expression \" << expression;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n switch (expression->concrete_type()) {\n case Expression::Concrete_Type::NONE: std::cerr << \" [NONE]\"; break;\n case Expression::Concrete_Type::BOOLEAN: std::cerr << \" [BOOLEAN]\"; break;\n case Expression::Concrete_Type::NUMBER: std::cerr << \" [NUMBER]\"; break;\n case Expression::Concrete_Type::COLOR: std::cerr << \" [COLOR]\"; break;\n case Expression::Concrete_Type::STRING: std::cerr << \" [STRING]\"; break;\n case Expression::Concrete_Type::LIST: std::cerr << \" [LIST]\"; break;\n case Expression::Concrete_Type::MAP: std::cerr << \" [MAP]\"; break;\n case Expression::Concrete_Type::SELECTOR: std::cerr << \" [SELECTOR]\"; break;\n case Expression::Concrete_Type::NULL_VAL: std::cerr << \" [NULL_VAL]\"; break;\n case Expression::Concrete_Type::C_WARNING: std::cerr << \" [C_WARNING]\"; break;\n case Expression::Concrete_Type::C_ERROR: std::cerr << \" [C_ERROR]\"; break;\n case Expression::Concrete_Type::FUNCTION: std::cerr << \" [FUNCTION]\"; break;\n case Expression::Concrete_Type::NUM_TYPES: std::cerr << \" [NUM_TYPES]\"; break;\n case Expression::Concrete_Type::VARIABLE: std::cerr << \" [VARIABLE]\"; break;\n case Expression::Concrete_Type::FUNCTION_VAL: std::cerr << \" [FUNCTION_VAL]\"; break;\n }\n std::cerr << std::endl;\n } else if (Cast(node)) {\n Has_Block_Ptr has_block = Cast(node);\n std::cerr << ind << \"Has_Block \" << has_block;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << has_block->tabs() << std::endl;\n if (has_block->block()) for(const Statement_Obj& i : has_block->block()->elements()) { debug_ast(i, ind + \" \", env); }\n } else if (Cast(node)) {\n Statement_Ptr statement = Cast(node);\n std::cerr << ind << \"Statement \" << statement;\n std::cerr << \" (\" << pstate_source_position(node) << \")\";\n std::cerr << \" \" << statement->tabs() << std::endl;\n }\n\n if (ind == \"\") std::cerr << \"####################################################################\\n\";\n}\n\ninline void debug_node(Node* node, std::string ind = \"\")\n{\n if (ind == \"\") std::cerr << \"#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\\n\";\n if (node->isCombinator()) {\n std::cerr << ind;\n std::cerr << \"Combinator \";\n std::cerr << node << \" \";\n if (node->got_line_feed) std::cerr << \"[LF] \";\n switch (node->combinator()) {\n case Complex_Selector::ADJACENT_TO: std::cerr << \"{+} \"; break;\n case Complex_Selector::PARENT_OF: std::cerr << \"{>} \"; break;\n case Complex_Selector::PRECEDES: std::cerr << \"{~} \"; break;\n case Complex_Selector::REFERENCE: std::cerr << \"{@} \"; break;\n case Complex_Selector::ANCESTOR_OF: std::cerr << \"{ } \"; break;\n }\n std::cerr << std::endl;\n // debug_ast(node->combinator(), ind + \" \");\n } else if (node->isSelector()) {\n std::cerr << ind;\n std::cerr << \"Selector \";\n std::cerr << node << \" \";\n if (node->got_line_feed) std::cerr << \"[LF] \";\n std::cerr << std::endl;\n debug_ast(node->selector(), ind + \" \");\n } else if (node->isCollection()) {\n std::cerr << ind;\n std::cerr << \"Collection \";\n std::cerr << node << \" \";\n if (node->got_line_feed) std::cerr << \"[LF] \";\n std::cerr << std::endl;\n for(auto n : (*node->collection())) {\n debug_node(&n, ind + \" \");\n }\n } else if (node->isNil()) {\n std::cerr << ind;\n std::cerr << \"Nil \";\n std::cerr << node << \" \";\n if (node->got_line_feed) std::cerr << \"[LF] \";\n std::cerr << std::endl;\n } else {\n std::cerr << ind;\n std::cerr << \"OTHER \";\n std::cerr << node << \" \";\n if (node->got_line_feed) std::cerr << \"[LF] \";\n std::cerr << std::endl;\n }\n if (ind == \"\") std::cerr << \"#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\\n\";\n}\n\n/*\ninline void debug_ast(const AST_Node_Ptr node, std::string ind = \"\", Env* env = 0)\n{\n debug_ast(const_cast(node), ind, env);\n}\n*/\ninline void debug_node(const Node* node, std::string ind = \"\")\n{\n debug_node(const_cast(node), ind);\n}\n\ninline void debug_subset_map(Sass::Subset_Map& map, std::string ind = \"\")\n{\n if (ind == \"\") std::cerr << \"#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\\n\";\n for(auto const &it : map.values()) {\n debug_ast(it.first, ind + \"first: \");\n debug_ast(it.second, ind + \"second: \");\n }\n if (ind == \"\") std::cerr << \"#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\\n\";\n}\n\ninline void debug_subset_entries(SubSetMapPairs* entries, std::string ind = \"\")\n{\n if (ind == \"\") std::cerr << \"#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\\n\";\n for(auto const &pair : *entries) {\n debug_ast(pair.first, ind + \"first: \");\n debug_ast(pair.second, ind + \"second: \");\n }\n if (ind == \"\") std::cerr << \"#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\\n\";\n}\n\n#endif // SASS_DEBUGGER\n" }, { "path": "libsass-build/emitter.cpp", "content": "#include \"sass.hpp\"\n#include \"util.hpp\"\n#include \"context.hpp\"\n#include \"output.hpp\"\n#include \"emitter.hpp\"\n#include \"utf8_string.hpp\"\n\nnamespace Sass {\n\n Emitter::Emitter(struct Sass_Output_Options& opt)\n : wbuf(),\n opt(opt),\n indentation(0),\n scheduled_space(0),\n scheduled_linefeed(0),\n scheduled_delimiter(false),\n scheduled_crutch(0),\n scheduled_mapping(0),\n in_custom_property(false),\n in_comment(false),\n in_wrapped(false),\n in_media_block(false),\n in_declaration(false),\n in_space_array(false),\n in_comma_array(false)\n { }\n\n // return buffer as string\n std::string Emitter::get_buffer(void)\n {\n return wbuf.buffer;\n }\n\n Sass_Output_Style Emitter::output_style(void) const\n {\n return opt.output_style;\n }\n\n // PROXY METHODS FOR SOURCE MAPS\n\n void Emitter::add_source_index(size_t idx)\n { wbuf.smap.source_index.push_back(idx); }\n\n std::string Emitter::render_srcmap(Context &ctx)\n { return wbuf.smap.render_srcmap(ctx); }\n\n void Emitter::set_filename(const std::string& str)\n { wbuf.smap.file = str; }\n\n void Emitter::schedule_mapping(const AST_Node_Ptr node)\n { scheduled_mapping = node; }\n void Emitter::add_open_mapping(const AST_Node_Ptr node)\n { wbuf.smap.add_open_mapping(node); }\n void Emitter::add_close_mapping(const AST_Node_Ptr node)\n { wbuf.smap.add_close_mapping(node); }\n ParserState Emitter::remap(const ParserState& pstate)\n { return wbuf.smap.remap(pstate); }\n\n // MAIN BUFFER MANIPULATION\n\n // add outstanding delimiter\n void Emitter::finalize(bool final)\n {\n scheduled_space = 0;\n if (output_style() == SASS_STYLE_COMPRESSED)\n if (final) scheduled_delimiter = false;\n if (scheduled_linefeed)\n scheduled_linefeed = 1;\n flush_schedules();\n }\n\n // flush scheduled space/linefeed\n void Emitter::flush_schedules(void)\n {\n // check the schedule\n if (scheduled_linefeed) {\n std::string linefeeds = \"\";\n\n for (size_t i = 0; i < scheduled_linefeed; i++)\n linefeeds += opt.linefeed;\n scheduled_space = 0;\n scheduled_linefeed = 0;\n append_string(linefeeds);\n\n } else if (scheduled_space) {\n std::string spaces(scheduled_space, ' ');\n scheduled_space = 0;\n append_string(spaces);\n }\n if (scheduled_delimiter) {\n scheduled_delimiter = false;\n append_string(\";\");\n }\n }\n\n // prepend some text or token to the buffer\n void Emitter::prepend_output(const OutputBuffer& output)\n {\n wbuf.smap.prepend(output);\n wbuf.buffer = output.buffer + wbuf.buffer;\n }\n\n // prepend some text or token to the buffer\n void Emitter::prepend_string(const std::string& text)\n {\n // do not adjust mappings for utf8 bom\n // seems they are not counted in any UA\n if (text.compare(\"\\xEF\\xBB\\xBF\") != 0) {\n wbuf.smap.prepend(Offset(text));\n }\n wbuf.buffer = text + wbuf.buffer;\n }\n\n char Emitter::last_char()\n {\n return wbuf.buffer.back();\n }\n\n // append a single char to the buffer\n void Emitter::append_char(const char chr)\n {\n // write space/lf\n flush_schedules();\n // add to buffer\n wbuf.buffer += chr;\n // account for data in source-maps\n wbuf.smap.append(Offset(chr));\n }\n\n // append some text or token to the buffer\n void Emitter::append_string(const std::string& text)\n {\n\n // write space/lf\n flush_schedules();\n\n if (in_comment && output_style() == COMPACT) {\n // unescape comment nodes\n std::string out = comment_to_string(text);\n // add to buffer\n wbuf.buffer += out;\n // account for data in source-maps\n wbuf.smap.append(Offset(out));\n } else {\n // add to buffer\n wbuf.buffer += text;\n // account for data in source-maps\n wbuf.smap.append(Offset(text));\n }\n }\n\n // append some white-space only text\n void Emitter::append_wspace(const std::string& text)\n {\n if (text.empty()) return;\n if (peek_linefeed(text.c_str())) {\n scheduled_space = 0;\n append_mandatory_linefeed();\n }\n }\n\n // append some text or token to the buffer\n // this adds source-mappings for node start and end\n void Emitter::append_token(const std::string& text, const AST_Node_Ptr node)\n {\n flush_schedules();\n add_open_mapping(node);\n // hotfix for browser issues\n // this is pretty ugly indeed\n if (scheduled_crutch) {\n add_open_mapping(scheduled_crutch);\n scheduled_crutch = 0;\n }\n append_string(text);\n add_close_mapping(node);\n }\n\n // HELPER METHODS\n\n void Emitter::append_indentation()\n {\n if (output_style() == COMPRESSED) return;\n if (output_style() == COMPACT) return;\n if (in_declaration && in_comma_array) return;\n if (scheduled_linefeed && indentation)\n scheduled_linefeed = 1;\n std::string indent = \"\";\n for (size_t i = 0; i < indentation; i++)\n indent += opt.indent;\n append_string(indent);\n }\n\n void Emitter::append_delimiter()\n {\n scheduled_delimiter = true;\n if (output_style() == COMPACT) {\n if (indentation == 0) {\n append_mandatory_linefeed();\n } else {\n append_mandatory_space();\n }\n } else if (output_style() != COMPRESSED) {\n append_optional_linefeed();\n }\n }\n\n void Emitter::append_comma_separator()\n {\n // scheduled_space = 0;\n append_string(\",\");\n append_optional_space();\n }\n\n void Emitter::append_colon_separator()\n {\n scheduled_space = 0;\n append_string(\":\");\n if (!in_custom_property) append_optional_space();\n }\n\n void Emitter::append_mandatory_space()\n {\n scheduled_space = 1;\n }\n\n void Emitter::append_optional_space()\n {\n if ((output_style() != COMPRESSED) && buffer().size()) {\n unsigned char lst = buffer().at(buffer().length() - 1);\n if (!isspace(lst) || scheduled_delimiter) {\n if (last_char() != '(') {\n append_mandatory_space();\n }\n }\n }\n }\n\n void Emitter::append_special_linefeed()\n {\n if (output_style() == COMPACT) {\n append_mandatory_linefeed();\n for (size_t p = 0; p < indentation; p++)\n append_string(opt.indent);\n }\n }\n\n void Emitter::append_optional_linefeed()\n {\n if (in_declaration && in_comma_array) return;\n if (output_style() == COMPACT) {\n append_mandatory_space();\n } else {\n append_mandatory_linefeed();\n }\n }\n\n void Emitter::append_mandatory_linefeed()\n {\n if (output_style() != COMPRESSED) {\n scheduled_linefeed = 1;\n scheduled_space = 0;\n // flush_schedules();\n }\n }\n\n void Emitter::append_scope_opener(AST_Node_Ptr node)\n {\n scheduled_linefeed = 0;\n append_optional_space();\n flush_schedules();\n if (node) add_open_mapping(node);\n append_string(\"{\");\n append_optional_linefeed();\n // append_optional_space();\n ++ indentation;\n }\n void Emitter::append_scope_closer(AST_Node_Ptr node)\n {\n -- indentation;\n scheduled_linefeed = 0;\n if (output_style() == COMPRESSED)\n scheduled_delimiter = false;\n if (output_style() == EXPANDED) {\n append_optional_linefeed();\n append_indentation();\n } else {\n append_optional_space();\n }\n append_string(\"}\");\n if (node) add_close_mapping(node);\n append_optional_linefeed();\n if (indentation != 0) return;\n if (output_style() != COMPRESSED)\n scheduled_linefeed = 2;\n }\n\n}\n" }, { "path": "libsass-build/emitter.hpp", "content": "#ifndef SASS_EMITTER_H\n#define SASS_EMITTER_H\n\n#include \n#include \"sass.hpp\"\n#include \"sass/base.h\"\n#include \"source_map.hpp\"\n#include \"ast_fwd_decl.hpp\"\n\nnamespace Sass {\n class Context;\n\n class Emitter {\n\n public:\n Emitter(struct Sass_Output_Options& opt);\n virtual ~Emitter() { }\n\n protected:\n OutputBuffer wbuf;\n public:\n const std::string& buffer(void) { return wbuf.buffer; }\n const SourceMap smap(void) { return wbuf.smap; }\n const OutputBuffer output(void) { return wbuf; }\n // proxy methods for source maps\n void add_source_index(size_t idx);\n void set_filename(const std::string& str);\n void add_open_mapping(const AST_Node_Ptr node);\n void add_close_mapping(const AST_Node_Ptr node);\n void schedule_mapping(const AST_Node_Ptr node);\n std::string render_srcmap(Context &ctx);\n ParserState remap(const ParserState& pstate);\n\n public:\n struct Sass_Output_Options& opt;\n size_t indentation;\n size_t scheduled_space;\n size_t scheduled_linefeed;\n bool scheduled_delimiter;\n AST_Node_Ptr scheduled_crutch;\n AST_Node_Ptr scheduled_mapping;\n\n public:\n // output strings different in custom css properties\n bool in_custom_property;\n // output strings different in comments\n bool in_comment;\n // selector list does not get linefeeds\n bool in_wrapped;\n // lists always get a space after delimiter\n bool in_media_block;\n // nested list must not have parentheses\n bool in_declaration;\n // nested lists need parentheses\n bool in_space_array;\n bool in_comma_array;\n\n public:\n // return buffer as std::string\n std::string get_buffer(void);\n // flush scheduled space/linefeed\n Sass_Output_Style output_style(void) const;\n // add outstanding linefeed\n void finalize(bool final = true);\n // flush scheduled space/linefeed\n void flush_schedules(void);\n // prepend some text or token to the buffer\n void prepend_string(const std::string& text);\n void prepend_output(const OutputBuffer& out);\n // append some text or token to the buffer\n void append_string(const std::string& text);\n // append a single character to buffer\n void append_char(const char chr);\n // append some white-space only text\n void append_wspace(const std::string& text);\n // append some text or token to the buffer\n // this adds source-mappings for node start and end\n void append_token(const std::string& text, const AST_Node_Ptr node);\n // query last appended character\n char last_char();\n\n public: // syntax sugar\n void append_indentation();\n void append_optional_space(void);\n void append_mandatory_space(void);\n void append_special_linefeed(void);\n void append_optional_linefeed(void);\n void append_mandatory_linefeed(void);\n void append_scope_opener(AST_Node_Ptr node = 0);\n void append_scope_closer(AST_Node_Ptr node = 0);\n void append_comma_separator(void);\n void append_colon_separator(void);\n void append_delimiter(void);\n\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/environment.cpp", "content": "#include \"sass.hpp\"\n#include \"ast.hpp\"\n#include \"environment.hpp\"\n\nnamespace Sass {\n\n template \n Environment::Environment(bool is_shadow)\n : local_frame_(environment_map()),\n parent_(0), is_shadow_(false)\n { }\n template \n Environment::Environment(Environment* env, bool is_shadow)\n : local_frame_(environment_map()),\n parent_(env), is_shadow_(is_shadow)\n { }\n template \n Environment::Environment(Environment& env, bool is_shadow)\n : local_frame_(environment_map()),\n parent_(&env), is_shadow_(is_shadow)\n { }\n\n // link parent to create a stack\n template \n void Environment::link(Environment& env) { parent_ = &env; }\n template \n void Environment::link(Environment* env) { parent_ = env; }\n\n // this is used to find the global frame\n // which is the second last on the stack\n template \n bool Environment::is_lexical() const\n {\n return !! parent_ && parent_->parent_;\n }\n\n // only match the real root scope\n // there is still a parent around\n // not sure what it is actually use for\n // I guess we store functions etc. there\n template \n bool Environment::is_global() const\n {\n return parent_ && ! parent_->parent_;\n }\n\n template \n environment_map& Environment::local_frame() {\n return local_frame_;\n }\n\n template \n bool Environment::has_local(const std::string& key) const\n { return local_frame_.find(key) != local_frame_.end(); }\n\n template EnvResult\n Environment::find_local(const std::string& key)\n {\n auto end = local_frame_.end();\n auto it = local_frame_.find(key);\n return EnvResult(it, it != end);\n }\n\n template \n T& Environment::get_local(const std::string& key)\n { return local_frame_[key]; }\n\n template \n void Environment::set_local(const std::string& key, const T& val)\n {\n local_frame_[key] = val;\n }\n template \n void Environment::set_local(const std::string& key, T&& val)\n {\n local_frame_[key] = val;\n }\n\n template \n void Environment::del_local(const std::string& key)\n { local_frame_.erase(key); }\n\n template \n Environment* Environment::global_env()\n {\n Environment* cur = this;\n while (cur->is_lexical()) {\n cur = cur->parent_;\n }\n return cur;\n }\n\n template \n bool Environment::has_global(const std::string& key)\n { return global_env()->has(key); }\n\n template \n T& Environment::get_global(const std::string& key)\n { return (*global_env())[key]; }\n\n template \n void Environment::set_global(const std::string& key, const T& val)\n {\n global_env()->local_frame_[key] = val;\n }\n template \n void Environment::set_global(const std::string& key, T&& val)\n {\n global_env()->local_frame_[key] = val;\n }\n\n template \n void Environment::del_global(const std::string& key)\n { global_env()->local_frame_.erase(key); }\n\n template \n Environment* Environment::lexical_env(const std::string& key)\n {\n Environment* cur = this;\n while (cur) {\n if (cur->has_local(key)) {\n return cur;\n }\n cur = cur->parent_;\n }\n return this;\n }\n\n // see if we have a lexical variable\n // move down the stack but stop before we\n // reach the global frame (is not included)\n template \n bool Environment::has_lexical(const std::string& key) const\n {\n auto cur = this;\n while (cur->is_lexical()) {\n if (cur->has_local(key)) return true;\n cur = cur->parent_;\n }\n return false;\n }\n\n // see if we have a lexical we could update\n // either update already existing lexical value\n // or if flag is set, we create one if no lexical found\n template \n void Environment::set_lexical(const std::string& key, const T& val)\n {\n Environment* cur = this;\n bool shadow = false;\n while ((cur && cur->is_lexical()) || shadow) {\n EnvResult rv(cur->find_local(key));\n if (rv.found) {\n rv.it->second = val;\n return;\n }\n shadow = cur->is_shadow();\n cur = cur->parent_;\n }\n set_local(key, val);\n }\n // this one moves the value\n template \n void Environment::set_lexical(const std::string& key, T&& val)\n {\n Environment* cur = this;\n bool shadow = false;\n while ((cur && cur->is_lexical()) || shadow) {\n EnvResult rv(cur->find_local(key));\n if (rv.found) {\n rv.it->second = val;\n return;\n }\n shadow = cur->is_shadow();\n cur = cur->parent_;\n }\n set_local(key, val);\n }\n\n // look on the full stack for key\n // include all scopes available\n template \n bool Environment::has(const std::string& key) const\n {\n auto cur = this;\n while (cur) {\n if (cur->has_local(key)) {\n return true;\n }\n cur = cur->parent_;\n }\n return false;\n }\n\n // look on the full stack for key\n // include all scopes available\n template EnvResult\n Environment::find(const std::string& key)\n {\n auto cur = this;\n while (true) {\n EnvResult rv(cur->find_local(key));\n if (rv.found) return rv;\n cur = cur->parent_;\n if (!cur) return rv;\n }\n };\n\n // use array access for getter and setter functions\n template \n T& Environment::operator[](const std::string& key)\n {\n auto cur = this;\n while (cur) {\n if (cur->has_local(key)) {\n return cur->get_local(key);\n }\n cur = cur->parent_;\n }\n return get_local(key);\n }\n/*\n #ifdef DEBUG\n template \n size_t Environment::print(std::string prefix)\n {\n size_t indent = 0;\n if (parent_) indent = parent_->print(prefix) + 1;\n std::cerr << prefix << std::string(indent, ' ') << \"== \" << this << std::endl;\n for (typename environment_map::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {\n if (!ends_with(i->first, \"[f]\") && !ends_with(i->first, \"[f]4\") && !ends_with(i->first, \"[f]2\")) {\n std::cerr << prefix << std::string(indent, ' ') << i->first << \" \" << i->second;\n if (Value_Ptr val = Cast(i->second))\n { std::cerr << \" : \" << val->to_string(); }\n std::cerr << std::endl;\n }\n }\n return indent ;\n }\n #endif\n*/\n // compile implementation for AST_Node\n template class Environment;\n\n}\n\n" }, { "path": "libsass-build/environment.hpp", "content": "#ifndef SASS_ENVIRONMENT_H\n#define SASS_ENVIRONMENT_H\n\n#include \n#include \"ast_fwd_decl.hpp\"\n#include \"ast_def_macros.hpp\"\n\nnamespace Sass {\n\n typedef environment_map::iterator EnvIter;\n\n class EnvResult {\n public:\n EnvIter it;\n bool found;\n public:\n EnvResult(EnvIter it, bool found)\n : it(it), found(found) {}\n };\n\n template \n class Environment {\n // TODO: test with map\n environment_map local_frame_;\n ADD_PROPERTY(Environment*, parent)\n ADD_PROPERTY(bool, is_shadow)\n\n public:\n Environment(bool is_shadow = false);\n Environment(Environment* env, bool is_shadow = false);\n Environment(Environment& env, bool is_shadow = false);\n\n // link parent to create a stack\n void link(Environment& env);\n void link(Environment* env);\n\n // this is used to find the global frame\n // which is the second last on the stack\n bool is_lexical() const;\n\n // only match the real root scope\n // there is still a parent around\n // not sure what it is actually use for\n // I guess we store functions etc. there\n bool is_global() const;\n\n // scope operates on the current frame\n\n environment_map& local_frame();\n\n bool has_local(const std::string& key) const;\n\n EnvResult find_local(const std::string& key);\n\n T& get_local(const std::string& key);\n\n // set variable on the current frame\n void set_local(const std::string& key, const T& val);\n void set_local(const std::string& key, T&& val);\n\n void del_local(const std::string& key);\n\n // global operates on the global frame\n // which is the second last on the stack\n Environment* global_env();\n // get the env where the variable already exists\n // if it does not yet exist, we return current env\n Environment* lexical_env(const std::string& key);\n\n bool has_global(const std::string& key);\n\n T& get_global(const std::string& key);\n\n // set a variable on the global frame\n void set_global(const std::string& key, const T& val);\n void set_global(const std::string& key, T&& val);\n\n void del_global(const std::string& key);\n\n // see if we have a lexical variable\n // move down the stack but stop before we\n // reach the global frame (is not included)\n bool has_lexical(const std::string& key) const;\n\n // see if we have a lexical we could update\n // either update already existing lexical value\n // or we create a new one on the current frame\n void set_lexical(const std::string& key, T&& val);\n void set_lexical(const std::string& key, const T& val);\n\n // look on the full stack for key\n // include all scopes available\n bool has(const std::string& key) const;\n\n // look on the full stack for key\n // include all scopes available\n EnvResult find(const std::string& key);\n\n // use array access for getter and setter functions\n T& operator[](const std::string& key);\n\n #ifdef DEBUG\n size_t print(std::string prefix = \"\");\n #endif\n\n };\n\n // define typedef for our use case\n typedef Environment Env;\n\n}\n\n#endif\n" }, { "path": "libsass-build/error_handling.cpp", "content": "#include \"sass.hpp\"\n#include \"ast.hpp\"\n#include \"prelexer.hpp\"\n#include \"backtrace.hpp\"\n#include \"error_handling.hpp\"\n\n#include \n\nnamespace Sass {\n\n namespace Exception {\n\n Base::Base(ParserState pstate, std::string msg, Backtraces traces)\n : std::runtime_error(msg), msg(msg),\n prefix(\"Error\"), pstate(pstate), traces(traces)\n { }\n\n InvalidSass::InvalidSass(ParserState pstate, Backtraces traces, std::string msg)\n : Base(pstate, msg, traces)\n { }\n\n\n InvalidParent::InvalidParent(Selector_Ptr parent, Backtraces traces, Selector_Ptr selector)\n : Base(selector->pstate(), def_msg, traces), parent(parent), selector(selector)\n {\n msg = \"Invalid parent selector for \\\"\";\n msg += selector->to_string(Sass_Inspect_Options());\n msg += \"\\\": \\\"\";\n msg += parent->to_string(Sass_Inspect_Options());\n msg += \"\\\"\";\n }\n\n InvalidVarKwdType::InvalidVarKwdType(ParserState pstate, Backtraces traces, std::string name, const Argument_Ptr arg)\n : Base(pstate, def_msg, traces), name(name), arg(arg)\n {\n msg = \"Variable keyword argument map must have string keys.\\n\";\n msg += name + \" is not a string in \" + arg->to_string() + \".\";\n }\n\n InvalidArgumentType::InvalidArgumentType(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string type, const Value_Ptr value)\n : Base(pstate, def_msg, traces), fn(fn), arg(arg), type(type), value(value)\n {\n msg = arg + \": \\\"\";\n if (value) msg += value->to_string(Sass_Inspect_Options());\n msg += \"\\\" is not a \" + type;\n msg += \" for `\" + fn + \"'\";\n }\n\n MissingArgument::MissingArgument(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string fntype)\n : Base(pstate, def_msg, traces), fn(fn), arg(arg), fntype(fntype)\n {\n msg = fntype + \" \" + fn;\n msg += \" is missing argument \";\n msg += arg + \".\";\n }\n\n InvalidSyntax::InvalidSyntax(ParserState pstate, Backtraces traces, std::string msg)\n : Base(pstate, msg, traces)\n { }\n\n NestingLimitError::NestingLimitError(ParserState pstate, Backtraces traces, std::string msg)\n : Base(pstate, msg, traces)\n { }\n\n DuplicateKeyError::DuplicateKeyError(Backtraces traces, const Map& dup, const Expression& org)\n : Base(org.pstate(), def_msg, traces), dup(dup), org(org)\n {\n msg = \"Duplicate key \";\n msg += dup.get_duplicate_key()->inspect();\n msg += \" in map (\";\n msg += org.inspect();\n msg += \").\";\n }\n\n TypeMismatch::TypeMismatch(Backtraces traces, const Expression& var, const std::string type)\n : Base(var.pstate(), def_msg, traces), var(var), type(type)\n {\n msg = var.to_string();\n msg += \" is not an \";\n msg += type;\n msg += \".\";\n }\n\n InvalidValue::InvalidValue(Backtraces traces, const Expression& val)\n : Base(val.pstate(), def_msg, traces), val(val)\n {\n msg = val.to_string();\n msg += \" isn't a valid CSS value.\";\n }\n\n StackError::StackError(Backtraces traces, const AST_Node& node)\n : Base(node.pstate(), def_msg, traces), node(node)\n {\n msg = \"stack level too deep\";\n }\n\n IncompatibleUnits::IncompatibleUnits(const Units& lhs, const Units& rhs)\n {\n msg = \"Incompatible units: '\";\n msg += rhs.unit();\n msg += \"' and '\";\n msg += lhs.unit();\n msg += \"'.\";\n }\n\n IncompatibleUnits::IncompatibleUnits(const UnitType lhs, const UnitType rhs)\n {\n msg = \"Incompatible units: '\";\n msg += unit_to_string(rhs);\n msg += \"' and '\";\n msg += unit_to_string(lhs);\n msg += \"'.\";\n }\n\n AlphaChannelsNotEqual::AlphaChannelsNotEqual(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op)\n : OperationError(), lhs(lhs), rhs(rhs), op(op)\n {\n msg = \"Alpha channels must be equal: \";\n msg += lhs->to_string({ NESTED, 5 });\n msg += \" \" + sass_op_to_name(op) + \" \";\n msg += rhs->to_string({ NESTED, 5 });\n msg += \".\";\n }\n\n ZeroDivisionError::ZeroDivisionError(const Expression& lhs, const Expression& rhs)\n : OperationError(), lhs(lhs), rhs(rhs)\n {\n msg = \"divided by 0\";\n }\n\n UndefinedOperation::UndefinedOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op)\n : OperationError(), lhs(lhs), rhs(rhs), op(op)\n {\n msg = def_op_msg + \": \\\"\";\n msg += lhs->to_string({ NESTED, 5 });\n msg += \" \" + sass_op_to_name(op) + \" \";\n msg += rhs->to_string({ TO_SASS, 5 });\n msg += \"\\\".\";\n }\n\n InvalidNullOperation::InvalidNullOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op)\n : UndefinedOperation(lhs, rhs, op)\n {\n msg = def_op_null_msg + \": \\\"\";\n msg += lhs->inspect();\n msg += \" \" + sass_op_to_name(op) + \" \";\n msg += rhs->inspect();\n msg += \"\\\".\";\n }\n\n SassValueError::SassValueError(Backtraces traces, ParserState pstate, OperationError& err)\n : Base(pstate, err.what(), traces)\n {\n msg = err.what();\n prefix = err.errtype();\n }\n\n }\n\n\n void warn(std::string msg, ParserState pstate)\n {\n std::cerr << \"Warning: \" << msg << std::endl;\n }\n\n void warning(std::string msg, ParserState pstate)\n {\n std::string cwd(Sass::File::get_cwd());\n std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));\n std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));\n std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));\n\n std::cerr << \"WARNING on line \" << pstate.line+1 << \", column \" << pstate.column+1 << \" of \" << output_path << \":\" << std::endl;\n std::cerr << msg << std::endl << std::endl;\n }\n\n void warn(std::string msg, ParserState pstate, Backtrace* bt)\n {\n warn(msg, pstate);\n }\n\n void deprecated_function(std::string msg, ParserState pstate)\n {\n std::string cwd(Sass::File::get_cwd());\n std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));\n std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));\n std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));\n\n std::cerr << \"DEPRECATION WARNING: \" << msg << std::endl;\n std::cerr << \"will be an error in future versions of Sass.\" << std::endl;\n std::cerr << \" on line \" << pstate.line+1 << \" of \" << output_path << std::endl;\n }\n\n void deprecated(std::string msg, std::string msg2, bool with_column, ParserState pstate)\n {\n std::string cwd(Sass::File::get_cwd());\n std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));\n std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));\n std::string output_path(Sass::File::path_for_console(rel_path, pstate.path, pstate.path));\n\n std::cerr << \"DEPRECATION WARNING on line \" << pstate.line + 1;\n if (with_column) std::cerr << \", column \" << pstate.column + pstate.offset.column + 1;\n if (output_path.length()) std::cerr << \" of \" << output_path;\n std::cerr << \":\" << std::endl;\n std::cerr << msg << std::endl;\n if (msg2.length()) std::cerr << msg2 << std::endl;\n std::cerr << std::endl;\n }\n\n void deprecated_bind(std::string msg, ParserState pstate)\n {\n std::string cwd(Sass::File::get_cwd());\n std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));\n std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));\n std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));\n\n std::cerr << \"WARNING: \" << msg << std::endl;\n std::cerr << \" on line \" << pstate.line+1 << \" of \" << output_path << std::endl;\n std::cerr << \"This will be an error in future versions of Sass.\" << std::endl;\n }\n\n // should be replaced with error with backtraces\n void coreError(std::string msg, ParserState pstate)\n {\n Backtraces traces;\n throw Exception::InvalidSyntax(pstate, traces, msg);\n }\n\n void error(std::string msg, ParserState pstate, Backtraces& traces)\n {\n traces.push_back(Backtrace(pstate));\n throw Exception::InvalidSyntax(pstate, traces, msg);\n }\n\n}\n" }, { "path": "libsass-build/error_handling.hpp", "content": "#ifndef SASS_ERROR_HANDLING_H\n#define SASS_ERROR_HANDLING_H\n\n#include \n#include \n#include \n#include \"position.hpp\"\n#include \"backtrace.hpp\"\n#include \"ast_fwd_decl.hpp\"\n#include \"sass/functions.h\"\n\nnamespace Sass {\n\n struct Backtrace;\n\n namespace Exception {\n\n const std::string def_msg = \"Invalid sass detected\";\n const std::string def_op_msg = \"Undefined operation\";\n const std::string def_op_null_msg = \"Invalid null operation\";\n const std::string def_nesting_limit = \"Code too deeply neested\";\n\n class Base : public std::runtime_error {\n protected:\n std::string msg;\n std::string prefix;\n public:\n ParserState pstate;\n Backtraces traces;\n public:\n Base(ParserState pstate, std::string msg, Backtraces traces);\n virtual const char* errtype() const { return prefix.c_str(); }\n virtual const char* what() const throw() { return msg.c_str(); }\n virtual ~Base() throw() {};\n };\n\n class InvalidSass : public Base {\n public:\n InvalidSass(ParserState pstate, Backtraces traces, std::string msg);\n virtual ~InvalidSass() throw() {};\n };\n\n class InvalidParent : public Base {\n protected:\n Selector_Ptr parent;\n Selector_Ptr selector;\n public:\n InvalidParent(Selector_Ptr parent, Backtraces traces, Selector_Ptr selector);\n virtual ~InvalidParent() throw() {};\n };\n\n class MissingArgument : public Base {\n protected:\n std::string fn;\n std::string arg;\n std::string fntype;\n public:\n MissingArgument(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string fntype);\n virtual ~MissingArgument() throw() {};\n };\n\n class InvalidArgumentType : public Base {\n protected:\n std::string fn;\n std::string arg;\n std::string type;\n const Value_Ptr value;\n public:\n InvalidArgumentType(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string type, const Value_Ptr value = 0);\n virtual ~InvalidArgumentType() throw() {};\n };\n\n class InvalidVarKwdType : public Base {\n protected:\n std::string name;\n const Argument_Ptr arg;\n public:\n InvalidVarKwdType(ParserState pstate, Backtraces traces, std::string name, const Argument_Ptr arg = 0);\n virtual ~InvalidVarKwdType() throw() {};\n };\n\n class InvalidSyntax : public Base {\n public:\n InvalidSyntax(ParserState pstate, Backtraces traces, std::string msg);\n virtual ~InvalidSyntax() throw() {};\n };\n\n class NestingLimitError : public Base {\n public:\n NestingLimitError(ParserState pstate, Backtraces traces, std::string msg = def_nesting_limit);\n virtual ~NestingLimitError() throw() {};\n };\n\n class DuplicateKeyError : public Base {\n protected:\n const Map& dup;\n const Expression& org;\n public:\n DuplicateKeyError(Backtraces traces, const Map& dup, const Expression& org);\n virtual const char* errtype() const { return \"Error\"; }\n virtual ~DuplicateKeyError() throw() {};\n };\n\n class TypeMismatch : public Base {\n protected:\n const Expression& var;\n const std::string type;\n public:\n TypeMismatch(Backtraces traces, const Expression& var, const std::string type);\n virtual const char* errtype() const { return \"Error\"; }\n virtual ~TypeMismatch() throw() {};\n };\n\n class InvalidValue : public Base {\n protected:\n const Expression& val;\n public:\n InvalidValue(Backtraces traces, const Expression& val);\n virtual const char* errtype() const { return \"Error\"; }\n virtual ~InvalidValue() throw() {};\n };\n\n class StackError : public Base {\n protected:\n const AST_Node& node;\n public:\n StackError(Backtraces traces, const AST_Node& node);\n virtual const char* errtype() const { return \"SystemStackError\"; }\n virtual ~StackError() throw() {};\n };\n\n /* common virtual base class (has no pstate or trace) */\n class OperationError : public std::runtime_error {\n protected:\n std::string msg;\n public:\n OperationError(std::string msg = def_op_msg)\n : std::runtime_error(msg), msg(msg)\n {};\n public:\n virtual const char* errtype() const { return \"Error\"; }\n virtual const char* what() const throw() { return msg.c_str(); }\n virtual ~OperationError() throw() {};\n };\n\n class ZeroDivisionError : public OperationError {\n protected:\n const Expression& lhs;\n const Expression& rhs;\n public:\n ZeroDivisionError(const Expression& lhs, const Expression& rhs);\n virtual const char* errtype() const { return \"ZeroDivisionError\"; }\n virtual ~ZeroDivisionError() throw() {};\n };\n\n class IncompatibleUnits : public OperationError {\n protected:\n // const Sass::UnitType lhs;\n // const Sass::UnitType rhs;\n public:\n IncompatibleUnits(const Units& lhs, const Units& rhs);\n IncompatibleUnits(const UnitType lhs, const UnitType rhs);\n virtual ~IncompatibleUnits() throw() {};\n };\n\n class UndefinedOperation : public OperationError {\n protected:\n Expression_Ptr_Const lhs;\n Expression_Ptr_Const rhs;\n const Sass_OP op;\n public:\n UndefinedOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op);\n // virtual const char* errtype() const { return \"Error\"; }\n virtual ~UndefinedOperation() throw() {};\n };\n\n class InvalidNullOperation : public UndefinedOperation {\n public:\n InvalidNullOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op);\n virtual ~InvalidNullOperation() throw() {};\n };\n\n class AlphaChannelsNotEqual : public OperationError {\n protected:\n Expression_Ptr_Const lhs;\n Expression_Ptr_Const rhs;\n const Sass_OP op;\n public:\n AlphaChannelsNotEqual(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op);\n // virtual const char* errtype() const { return \"Error\"; }\n virtual ~AlphaChannelsNotEqual() throw() {};\n };\n\n class SassValueError : public Base {\n public:\n SassValueError(Backtraces traces, ParserState pstate, OperationError& err);\n virtual ~SassValueError() throw() {};\n };\n\n }\n\n void warn(std::string msg, ParserState pstate);\n void warn(std::string msg, ParserState pstate, Backtrace* bt);\n void warning(std::string msg, ParserState pstate);\n\n void deprecated_function(std::string msg, ParserState pstate);\n void deprecated(std::string msg, std::string msg2, bool with_column, ParserState pstate);\n void deprecated_bind(std::string msg, ParserState pstate);\n // void deprecated(std::string msg, ParserState pstate, Backtrace* bt);\n\n void coreError(std::string msg, ParserState pstate);\n void error(std::string msg, ParserState pstate, Backtraces& traces);\n\n}\n\n#endif\n" }, { "path": "libsass-build/eval.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"file.hpp\"\n#include \"eval.hpp\"\n#include \"ast.hpp\"\n#include \"bind.hpp\"\n#include \"util.hpp\"\n#include \"inspect.hpp\"\n#include \"operators.hpp\"\n#include \"environment.hpp\"\n#include \"position.hpp\"\n#include \"sass/values.h\"\n#include \"to_value.hpp\"\n#include \"to_c.hpp\"\n#include \"context.hpp\"\n#include \"backtrace.hpp\"\n#include \"lexer.hpp\"\n#include \"prelexer.hpp\"\n#include \"parser.hpp\"\n#include \"expand.hpp\"\n#include \"color_maps.hpp\"\n#include \"sass_functions.hpp\"\n\nnamespace Sass {\n\n Eval::Eval(Expand& exp)\n : exp(exp),\n ctx(exp.ctx),\n traces(exp.traces),\n force(false),\n is_in_comment(false),\n is_in_selector_schema(false)\n {\n bool_true = SASS_MEMORY_NEW(Boolean, \"[NA]\", true);\n bool_false = SASS_MEMORY_NEW(Boolean, \"[NA]\", false);\n }\n Eval::~Eval() { }\n\n Env* Eval::environment()\n {\n return exp.environment();\n }\n\n Selector_List_Obj Eval::selector()\n {\n return exp.selector();\n }\n\n Expression_Ptr Eval::operator()(Block_Ptr b)\n {\n Expression_Ptr val = 0;\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n val = b->at(i)->perform(this);\n if (val) return val;\n }\n return val;\n }\n\n Expression_Ptr Eval::operator()(Assignment_Ptr a)\n {\n Env* env = exp.environment();\n std::string var(a->variable());\n if (a->is_global()) {\n if (a->is_default()) {\n if (env->has_global(var)) {\n Expression_Ptr e = Cast(env->get_global(var));\n if (!e || e->concrete_type() == Expression::NULL_VAL) {\n env->set_global(var, a->value()->perform(this));\n }\n }\n else {\n env->set_global(var, a->value()->perform(this));\n }\n }\n else {\n env->set_global(var, a->value()->perform(this));\n }\n }\n else if (a->is_default()) {\n if (env->has_lexical(var)) {\n auto cur = env;\n while (cur && cur->is_lexical()) {\n if (cur->has_local(var)) {\n if (AST_Node_Obj node = cur->get_local(var)) {\n Expression_Ptr e = Cast(node);\n if (!e || e->concrete_type() == Expression::NULL_VAL) {\n cur->set_local(var, a->value()->perform(this));\n }\n }\n else {\n throw std::runtime_error(\"Env not in sync\");\n }\n return 0;\n }\n cur = cur->parent();\n }\n throw std::runtime_error(\"Env not in sync\");\n }\n else if (env->has_global(var)) {\n if (AST_Node_Obj node = env->get_global(var)) {\n Expression_Ptr e = Cast(node);\n if (!e || e->concrete_type() == Expression::NULL_VAL) {\n env->set_global(var, a->value()->perform(this));\n }\n }\n }\n else if (env->is_lexical()) {\n env->set_local(var, a->value()->perform(this));\n }\n else {\n env->set_local(var, a->value()->perform(this));\n }\n }\n else {\n env->set_lexical(var, a->value()->perform(this));\n }\n return 0;\n }\n\n Expression_Ptr Eval::operator()(If_Ptr i)\n {\n Expression_Obj rv = 0;\n Env env(exp.environment());\n exp.env_stack.push_back(&env);\n Expression_Obj cond = i->predicate()->perform(this);\n if (!cond->is_false()) {\n rv = i->block()->perform(this);\n }\n else {\n Block_Obj alt = i->alternative();\n if (alt) rv = alt->perform(this);\n }\n exp.env_stack.pop_back();\n return rv.detach();\n }\n\n // For does not create a new env scope\n // But iteration vars are reset afterwards\n Expression_Ptr Eval::operator()(For_Ptr f)\n {\n std::string variable(f->variable());\n Expression_Obj low = f->lower_bound()->perform(this);\n if (low->concrete_type() != Expression::NUMBER) {\n traces.push_back(Backtrace(low->pstate()));\n throw Exception::TypeMismatch(traces, *low, \"integer\");\n }\n Expression_Obj high = f->upper_bound()->perform(this);\n if (high->concrete_type() != Expression::NUMBER) {\n traces.push_back(Backtrace(high->pstate()));\n throw Exception::TypeMismatch(traces, *high, \"integer\");\n }\n Number_Obj sass_start = Cast(low);\n Number_Obj sass_end = Cast(high);\n // check if units are valid for sequence\n if (sass_start->unit() != sass_end->unit()) {\n std::stringstream msg; msg << \"Incompatible units: '\"\n << sass_end->unit() << \"' and '\"\n << sass_start->unit() << \"'.\";\n error(msg.str(), low->pstate(), traces);\n }\n double start = sass_start->value();\n double end = sass_end->value();\n // only create iterator once in this environment\n Env env(environment(), true);\n exp.env_stack.push_back(&env);\n Block_Obj body = f->block();\n Expression_Ptr val = 0;\n if (start < end) {\n if (f->is_inclusive()) ++end;\n for (double i = start;\n i < end;\n ++i) {\n Number_Obj it = SASS_MEMORY_NEW(Number, low->pstate(), i, sass_end->unit());\n env.set_local(variable, it);\n val = body->perform(this);\n if (val) break;\n }\n } else {\n if (f->is_inclusive()) --end;\n for (double i = start;\n i > end;\n --i) {\n Number_Obj it = SASS_MEMORY_NEW(Number, low->pstate(), i, sass_end->unit());\n env.set_local(variable, it);\n val = body->perform(this);\n if (val) break;\n }\n }\n exp.env_stack.pop_back();\n return val;\n }\n\n // Eval does not create a new env scope\n // But iteration vars are reset afterwards\n Expression_Ptr Eval::operator()(Each_Ptr e)\n {\n std::vector variables(e->variables());\n Expression_Obj expr = e->list()->perform(this);\n Env env(environment(), true);\n exp.env_stack.push_back(&env);\n List_Obj list = 0;\n Map_Ptr map = 0;\n if (expr->concrete_type() == Expression::MAP) {\n map = Cast(expr);\n }\n else if (Selector_List_Ptr ls = Cast(expr)) {\n Listize listize;\n Expression_Obj rv = ls->perform(&listize);\n list = Cast(rv);\n }\n else if (expr->concrete_type() != Expression::LIST) {\n list = SASS_MEMORY_NEW(List, expr->pstate(), 1, SASS_COMMA);\n list->append(expr);\n }\n else {\n list = Cast(expr);\n }\n\n Block_Obj body = e->block();\n Expression_Obj val = 0;\n\n if (map) {\n for (Expression_Obj key : map->keys()) {\n Expression_Obj value = map->at(key);\n\n if (variables.size() == 1) {\n List_Ptr variable = SASS_MEMORY_NEW(List, map->pstate(), 2, SASS_SPACE);\n variable->append(key);\n variable->append(value);\n env.set_local(variables[0], variable);\n } else {\n env.set_local(variables[0], key);\n env.set_local(variables[1], value);\n }\n\n val = body->perform(this);\n if (val) break;\n }\n }\n else {\n if (list->length() == 1 && Cast(list)) {\n list = Cast(list);\n }\n for (size_t i = 0, L = list->length(); i < L; ++i) {\n Expression_Ptr item = list->at(i);\n // unwrap value if the expression is an argument\n if (Argument_Ptr arg = Cast(item)) item = arg->value();\n // check if we got passed a list of args (investigate)\n if (List_Ptr scalars = Cast(item)) {\n if (variables.size() == 1) {\n Expression_Ptr var = scalars;\n env.set_local(variables[0], var);\n } else {\n // XXX: this is never hit via spec tests\n for (size_t j = 0, K = variables.size(); j < K; ++j) {\n Expression_Ptr res = j >= scalars->length()\n ? SASS_MEMORY_NEW(Null, expr->pstate())\n : scalars->at(j);\n env.set_local(variables[j], res);\n }\n }\n } else {\n if (variables.size() > 0) {\n env.set_local(variables.at(0), item);\n for (size_t j = 1, K = variables.size(); j < K; ++j) {\n // XXX: this is never hit via spec tests\n Expression_Ptr res = SASS_MEMORY_NEW(Null, expr->pstate());\n env.set_local(variables[j], res);\n }\n }\n }\n val = body->perform(this);\n if (val) break;\n }\n }\n exp.env_stack.pop_back();\n return val.detach();\n }\n\n Expression_Ptr Eval::operator()(While_Ptr w)\n {\n Expression_Obj pred = w->predicate();\n Block_Obj body = w->block();\n Env env(environment(), true);\n exp.env_stack.push_back(&env);\n Expression_Obj cond = pred->perform(this);\n while (!cond->is_false()) {\n Expression_Obj val = body->perform(this);\n if (val) {\n exp.env_stack.pop_back();\n return val.detach();\n }\n cond = pred->perform(this);\n }\n exp.env_stack.pop_back();\n return 0;\n }\n\n Expression_Ptr Eval::operator()(Return_Ptr r)\n {\n return r->value()->perform(this);\n }\n\n Expression_Ptr Eval::operator()(Warning_Ptr w)\n {\n Sass_Output_Style outstyle = ctx.c_options.output_style;\n ctx.c_options.output_style = NESTED;\n Expression_Obj message = w->message()->perform(this);\n Env* env = exp.environment();\n\n // try to use generic function\n if (env->has(\"@warn[f]\")) {\n\n // add call stack entry\n ctx.callee_stack.push_back({\n \"@warn\",\n w->pstate().path,\n w->pstate().line + 1,\n w->pstate().column + 1,\n SASS_CALLEE_FUNCTION,\n { env }\n });\n\n Definition_Ptr def = Cast((*env)[\"@warn[f]\"]);\n // Block_Obj body = def->block();\n // Native_Function func = def->native_function();\n Sass_Function_Entry c_function = def->c_function();\n Sass_Function_Fn c_func = sass_function_get_function(c_function);\n\n To_C to_c;\n union Sass_Value* c_args = sass_make_list(1, SASS_COMMA, false);\n sass_list_set_value(c_args, 0, message->perform(&to_c));\n union Sass_Value* c_val = c_func(c_args, c_function, ctx.c_compiler);\n ctx.c_options.output_style = outstyle;\n ctx.callee_stack.pop_back();\n sass_delete_value(c_args);\n sass_delete_value(c_val);\n return 0;\n\n }\n\n std::string result(unquote(message->to_sass()));\n std::cerr << \"WARNING: \" << result << std::endl;\n traces.push_back(Backtrace(w->pstate()));\n std::cerr << traces_to_string(traces, \" \");\n std::cerr << std::endl;\n ctx.c_options.output_style = outstyle;\n traces.pop_back();\n return 0;\n }\n\n Expression_Ptr Eval::operator()(Error_Ptr e)\n {\n Sass_Output_Style outstyle = ctx.c_options.output_style;\n ctx.c_options.output_style = NESTED;\n Expression_Obj message = e->message()->perform(this);\n Env* env = exp.environment();\n\n // try to use generic function\n if (env->has(\"@error[f]\")) {\n\n // add call stack entry\n ctx.callee_stack.push_back({\n \"@error\",\n e->pstate().path,\n e->pstate().line + 1,\n e->pstate().column + 1,\n SASS_CALLEE_FUNCTION,\n { env }\n });\n\n Definition_Ptr def = Cast((*env)[\"@error[f]\"]);\n // Block_Obj body = def->block();\n // Native_Function func = def->native_function();\n Sass_Function_Entry c_function = def->c_function();\n Sass_Function_Fn c_func = sass_function_get_function(c_function);\n\n To_C to_c;\n union Sass_Value* c_args = sass_make_list(1, SASS_COMMA, false);\n sass_list_set_value(c_args, 0, message->perform(&to_c));\n union Sass_Value* c_val = c_func(c_args, c_function, ctx.c_compiler);\n ctx.c_options.output_style = outstyle;\n ctx.callee_stack.pop_back();\n sass_delete_value(c_args);\n sass_delete_value(c_val);\n return 0;\n\n }\n\n std::string result(unquote(message->to_sass()));\n ctx.c_options.output_style = outstyle;\n error(result, e->pstate(), traces);\n return 0;\n }\n\n Expression_Ptr Eval::operator()(Debug_Ptr d)\n {\n Sass_Output_Style outstyle = ctx.c_options.output_style;\n ctx.c_options.output_style = NESTED;\n Expression_Obj message = d->value()->perform(this);\n Env* env = exp.environment();\n\n // try to use generic function\n if (env->has(\"@debug[f]\")) {\n\n // add call stack entry\n ctx.callee_stack.push_back({\n \"@debug\",\n d->pstate().path,\n d->pstate().line + 1,\n d->pstate().column + 1,\n SASS_CALLEE_FUNCTION,\n { env }\n });\n\n Definition_Ptr def = Cast((*env)[\"@debug[f]\"]);\n // Block_Obj body = def->block();\n // Native_Function func = def->native_function();\n Sass_Function_Entry c_function = def->c_function();\n Sass_Function_Fn c_func = sass_function_get_function(c_function);\n\n To_C to_c;\n union Sass_Value* c_args = sass_make_list(1, SASS_COMMA, false);\n sass_list_set_value(c_args, 0, message->perform(&to_c));\n union Sass_Value* c_val = c_func(c_args, c_function, ctx.c_compiler);\n ctx.c_options.output_style = outstyle;\n ctx.callee_stack.pop_back();\n sass_delete_value(c_args);\n sass_delete_value(c_val);\n return 0;\n\n }\n\n std::string cwd(ctx.cwd());\n std::string result(unquote(message->to_sass()));\n std::string abs_path(Sass::File::rel2abs(d->pstate().path, cwd, cwd));\n std::string rel_path(Sass::File::abs2rel(d->pstate().path, cwd, cwd));\n std::string output_path(Sass::File::path_for_console(rel_path, abs_path, d->pstate().path));\n ctx.c_options.output_style = outstyle;\n\n std::cerr << output_path << \":\" << d->pstate().line+1 << \" DEBUG: \" << result;\n std::cerr << std::endl;\n return 0;\n }\n\n Expression_Ptr Eval::operator()(List_Ptr l)\n {\n // special case for unevaluated map\n if (l->separator() == SASS_HASH) {\n Map_Obj lm = SASS_MEMORY_NEW(Map,\n l->pstate(),\n l->length() / 2);\n for (size_t i = 0, L = l->length(); i < L; i += 2)\n {\n Expression_Obj key = (*l)[i+0]->perform(this);\n Expression_Obj val = (*l)[i+1]->perform(this);\n // make sure the color key never displays its real name\n key->is_delayed(true); // verified\n *lm << std::make_pair(key, val);\n }\n if (lm->has_duplicate_key()) {\n traces.push_back(Backtrace(l->pstate()));\n throw Exception::DuplicateKeyError(traces, *lm, *l);\n }\n\n lm->is_interpolant(l->is_interpolant());\n return lm->perform(this);\n }\n // check if we should expand it\n if (l->is_expanded()) return l;\n // regular case for unevaluated lists\n List_Obj ll = SASS_MEMORY_NEW(List,\n l->pstate(),\n l->length(),\n l->separator(),\n l->is_arglist(),\n l->is_bracketed());\n for (size_t i = 0, L = l->length(); i < L; ++i) {\n ll->append((*l)[i]->perform(this));\n }\n ll->is_interpolant(l->is_interpolant());\n ll->from_selector(l->from_selector());\n ll->is_expanded(true);\n return ll.detach();\n }\n\n Expression_Ptr Eval::operator()(Map_Ptr m)\n {\n if (m->is_expanded()) return m;\n\n // make sure we're not starting with duplicate keys.\n // the duplicate key state will have been set in the parser phase.\n if (m->has_duplicate_key()) {\n traces.push_back(Backtrace(m->pstate()));\n throw Exception::DuplicateKeyError(traces, *m, *m);\n }\n\n Map_Obj mm = SASS_MEMORY_NEW(Map,\n m->pstate(),\n m->length());\n for (auto key : m->keys()) {\n Expression_Ptr ex_key = key->perform(this);\n Expression_Ptr ex_val = m->at(key);\n if (ex_val == NULL) continue;\n ex_val = ex_val->perform(this);\n *mm << std::make_pair(ex_key, ex_val);\n }\n\n // check the evaluated keys aren't duplicates.\n if (mm->has_duplicate_key()) {\n traces.push_back(Backtrace(m->pstate()));\n throw Exception::DuplicateKeyError(traces, *mm, *m);\n }\n\n mm->is_expanded(true);\n return mm.detach();\n }\n\n Expression_Ptr Eval::operator()(Binary_Expression_Ptr b_in)\n {\n\n Expression_Obj lhs = b_in->left();\n Expression_Obj rhs = b_in->right();\n enum Sass_OP op_type = b_in->optype();\n\n if (op_type == Sass_OP::AND) {\n // LOCAL_FLAG(force, true);\n lhs = lhs->perform(this);\n if (!*lhs) return lhs.detach();\n return rhs->perform(this);\n }\n else if (op_type == Sass_OP::OR) {\n // LOCAL_FLAG(force, true);\n lhs = lhs->perform(this);\n if (*lhs) return lhs.detach();\n return rhs->perform(this);\n }\n\n // Evaluate variables as early o\n while (Variable_Ptr l_v = Cast(lhs)) {\n lhs = operator()(l_v);\n }\n while (Variable_Ptr r_v = Cast(rhs)) {\n rhs = operator()(r_v);\n }\n\n Binary_Expression_Obj b = b_in;\n\n // Evaluate sub-expressions early on\n while (Binary_Expression_Ptr l_b = Cast(lhs)) {\n if (!force && l_b->is_delayed()) break;\n lhs = operator()(l_b);\n }\n while (Binary_Expression_Ptr r_b = Cast(rhs)) {\n if (!force && r_b->is_delayed()) break;\n rhs = operator()(r_b);\n }\n\n // don't eval delayed expressions (the '/' when used as a separator)\n if (!force && op_type == Sass_OP::DIV && b->is_delayed()) {\n b->right(b->right()->perform(this));\n b->left(b->left()->perform(this));\n return b.detach();\n }\n\n // specific types we know are final\n // handle them early to avoid overhead\n if (Number_Ptr l_n = Cast(lhs)) {\n // lhs is number and rhs is number\n if (Number_Ptr r_n = Cast(rhs)) {\n try {\n switch (op_type) {\n case Sass_OP::EQ: return *l_n == *r_n ? bool_true : bool_false;\n case Sass_OP::NEQ: return *l_n == *r_n ? bool_false : bool_true;\n case Sass_OP::LT: return *l_n < *r_n ? bool_true : bool_false;\n case Sass_OP::GTE: return *l_n < *r_n ? bool_false : bool_true;\n case Sass_OP::LTE: return *l_n < *r_n || *l_n == *r_n ? bool_true : bool_false;\n case Sass_OP::GT: return *l_n < *r_n || *l_n == *r_n ? bool_false : bool_true;\n case Sass_OP::ADD: case Sass_OP::SUB: case Sass_OP::MUL: case Sass_OP::DIV: case Sass_OP::MOD:\n return Operators::op_numbers(op_type, *l_n, *r_n, ctx.c_options, b_in->pstate());\n default: break;\n }\n }\n catch (Exception::OperationError& err)\n {\n traces.push_back(Backtrace(b_in->pstate()));\n throw Exception::SassValueError(traces, b_in->pstate(), err);\n }\n }\n // lhs is number and rhs is color\n else if (Color_Ptr r_c = Cast(rhs)) {\n try {\n switch (op_type) {\n case Sass_OP::EQ: return *l_n == *r_c ? bool_true : bool_false;\n case Sass_OP::NEQ: return *l_n == *r_c ? bool_false : bool_true;\n case Sass_OP::ADD: case Sass_OP::SUB: case Sass_OP::MUL: case Sass_OP::DIV: case Sass_OP::MOD:\n return Operators::op_number_color(op_type, *l_n, *r_c, ctx.c_options, b_in->pstate());\n default: break;\n }\n }\n catch (Exception::OperationError& err)\n {\n traces.push_back(Backtrace(b_in->pstate()));\n throw Exception::SassValueError(traces, b_in->pstate(), err);\n }\n }\n }\n else if (Color_Ptr l_c = Cast(lhs)) {\n // lhs is color and rhs is color\n if (Color_Ptr r_c = Cast(rhs)) {\n try {\n switch (op_type) {\n case Sass_OP::EQ: return *l_c == *r_c ? bool_true : bool_false;\n case Sass_OP::NEQ: return *l_c == *r_c ? bool_false : bool_true;\n case Sass_OP::LT: return *l_c < *r_c ? bool_true : bool_false;\n case Sass_OP::GTE: return *l_c < *r_c ? bool_false : bool_true;\n case Sass_OP::LTE: return *l_c < *r_c || *l_c == *r_c ? bool_true : bool_false;\n case Sass_OP::GT: return *l_c < *r_c || *l_c == *r_c ? bool_false : bool_true;\n case Sass_OP::ADD: case Sass_OP::SUB: case Sass_OP::MUL: case Sass_OP::DIV: case Sass_OP::MOD:\n return Operators::op_colors(op_type, *l_c, *r_c, ctx.c_options, b_in->pstate());\n default: break;\n }\n }\n catch (Exception::OperationError& err)\n {\n traces.push_back(Backtrace(b_in->pstate()));\n throw Exception::SassValueError(traces, b_in->pstate(), err);\n }\n }\n // lhs is color and rhs is number\n else if (Number_Ptr r_n = Cast(rhs)) {\n try {\n switch (op_type) {\n case Sass_OP::EQ: return *l_c == *r_n ? bool_true : bool_false;\n case Sass_OP::NEQ: return *l_c == *r_n ? bool_false : bool_true;\n case Sass_OP::ADD: case Sass_OP::SUB: case Sass_OP::MUL: case Sass_OP::DIV: case Sass_OP::MOD:\n return Operators::op_color_number(op_type, *l_c, *r_n, ctx.c_options, b_in->pstate());\n default: break;\n }\n }\n catch (Exception::OperationError& err)\n {\n traces.push_back(Backtrace(b_in->pstate()));\n throw Exception::SassValueError(traces, b_in->pstate(), err);\n }\n }\n }\n\n String_Schema_Obj ret_schema;\n\n // only the last item will be used to eval the binary expression\n if (String_Schema_Ptr s_l = Cast(b->left())) {\n if (!s_l->has_interpolant() && (!s_l->is_right_interpolant())) {\n ret_schema = SASS_MEMORY_NEW(String_Schema, b->pstate());\n Binary_Expression_Obj bin_ex = SASS_MEMORY_NEW(Binary_Expression, b->pstate(),\n b->op(), s_l->last(), b->right());\n bin_ex->is_delayed(b->left()->is_delayed() || b->right()->is_delayed()); // unverified\n for (size_t i = 0; i < s_l->length() - 1; ++i) {\n ret_schema->append(s_l->at(i)->perform(this));\n }\n ret_schema->append(bin_ex->perform(this));\n return ret_schema->perform(this);\n }\n }\n if (String_Schema_Ptr s_r = Cast(b->right())) {\n\n if (!s_r->has_interpolant() && (!s_r->is_left_interpolant() || op_type == Sass_OP::DIV)) {\n ret_schema = SASS_MEMORY_NEW(String_Schema, b->pstate());\n Binary_Expression_Obj bin_ex = SASS_MEMORY_NEW(Binary_Expression, b->pstate(),\n b->op(), b->left(), s_r->first());\n bin_ex->is_delayed(b->left()->is_delayed() || b->right()->is_delayed()); // verified\n ret_schema->append(bin_ex->perform(this));\n for (size_t i = 1; i < s_r->length(); ++i) {\n ret_schema->append(s_r->at(i)->perform(this));\n }\n return ret_schema->perform(this);\n }\n }\n\n // fully evaluate their values\n if (op_type == Sass_OP::EQ ||\n op_type == Sass_OP::NEQ ||\n op_type == Sass_OP::GT ||\n op_type == Sass_OP::GTE ||\n op_type == Sass_OP::LT ||\n op_type == Sass_OP::LTE)\n {\n LOCAL_FLAG(force, true);\n lhs->is_expanded(false);\n lhs->set_delayed(false);\n lhs = lhs->perform(this);\n rhs->is_expanded(false);\n rhs->set_delayed(false);\n rhs = rhs->perform(this);\n }\n else {\n lhs = lhs->perform(this);\n }\n\n // not a logical connective, so go ahead and eval the rhs\n rhs = rhs->perform(this);\n AST_Node_Obj lu = lhs;\n AST_Node_Obj ru = rhs;\n\n Expression::Concrete_Type l_type;\n Expression::Concrete_Type r_type;\n\n // Is one of the operands an interpolant?\n String_Schema_Obj s1 = Cast(b->left());\n String_Schema_Obj s2 = Cast(b->right());\n Binary_Expression_Obj b1 = Cast(b->left());\n Binary_Expression_Obj b2 = Cast(b->right());\n\n bool schema_op = false;\n\n bool force_delay = (s2 && s2->is_left_interpolant()) ||\n (s1 && s1->is_right_interpolant()) ||\n (b1 && b1->is_right_interpolant()) ||\n (b2 && b2->is_left_interpolant());\n\n if ((s1 && s1->has_interpolants()) || (s2 && s2->has_interpolants()) || force_delay)\n {\n if (op_type == Sass_OP::DIV || op_type == Sass_OP::MUL || op_type == Sass_OP::MOD || op_type == Sass_OP::ADD || op_type == Sass_OP::SUB ||\n op_type == Sass_OP::EQ) {\n // If possible upgrade LHS to a number (for number to string compare)\n if (String_Constant_Ptr str = Cast(lhs)) {\n std::string value(str->value());\n const char* start = value.c_str();\n if (Prelexer::sequence < Prelexer::dimension, Prelexer::end_of_file >(start) != 0) {\n lhs = Parser::lexed_dimension(b->pstate(), str->value());\n }\n }\n // If possible upgrade RHS to a number (for string to number compare)\n if (String_Constant_Ptr str = Cast(rhs)) {\n std::string value(str->value());\n const char* start = value.c_str();\n if (Prelexer::sequence < Prelexer::dimension, Prelexer::number >(start) != 0) {\n rhs = Parser::lexed_dimension(b->pstate(), str->value());\n }\n }\n }\n\n To_Value to_value(ctx);\n Value_Obj v_l = Cast(lhs->perform(&to_value));\n Value_Obj v_r = Cast(rhs->perform(&to_value));\n\n if (force_delay) {\n std::string str(\"\");\n str += v_l->to_string(ctx.c_options);\n if (b->op().ws_before) str += \" \";\n str += b->separator();\n if (b->op().ws_after) str += \" \";\n str += v_r->to_string(ctx.c_options);\n String_Constant_Ptr val = SASS_MEMORY_NEW(String_Constant, b->pstate(), str);\n val->is_interpolant(b->left()->has_interpolant());\n return val;\n }\n }\n\n // see if it's a relational expression\n try {\n switch(op_type) {\n case Sass_OP::EQ: return SASS_MEMORY_NEW(Boolean, b->pstate(), Operators::eq(lhs, rhs));\n case Sass_OP::NEQ: return SASS_MEMORY_NEW(Boolean, b->pstate(), Operators::neq(lhs, rhs));\n case Sass_OP::GT: return SASS_MEMORY_NEW(Boolean, b->pstate(), Operators::gt(lhs, rhs));\n case Sass_OP::GTE: return SASS_MEMORY_NEW(Boolean, b->pstate(), Operators::gte(lhs, rhs));\n case Sass_OP::LT: return SASS_MEMORY_NEW(Boolean, b->pstate(), Operators::lt(lhs, rhs));\n case Sass_OP::LTE: return SASS_MEMORY_NEW(Boolean, b->pstate(), Operators::lte(lhs, rhs));\n default: break;\n }\n }\n catch (Exception::OperationError& err)\n {\n // throw Exception::Base(b->pstate(), err.what());\n traces.push_back(Backtrace(b->pstate()));\n throw Exception::SassValueError(traces, b->pstate(), err);\n }\n\n l_type = lhs->concrete_type();\n r_type = rhs->concrete_type();\n\n // ToDo: throw error in op functions\n // ToDo: then catch and re-throw them\n Expression_Obj rv;\n try {\n ParserState pstate(b->pstate());\n if (l_type == Expression::NUMBER && r_type == Expression::NUMBER) {\n Number_Ptr l_n = Cast(lhs);\n Number_Ptr r_n = Cast(rhs);\n l_n->reduce(); r_n->reduce();\n rv = Operators::op_numbers(op_type, *l_n, *r_n, ctx.c_options, pstate);\n }\n else if (l_type == Expression::NUMBER && r_type == Expression::COLOR) {\n Number_Ptr l_n = Cast(lhs);\n Color_Ptr r_c = Cast(rhs);\n rv = Operators::op_number_color(op_type, *l_n, *r_c, ctx.c_options, pstate);\n }\n else if (l_type == Expression::COLOR && r_type == Expression::NUMBER) {\n Color_Ptr l_c = Cast(lhs);\n Number_Ptr r_n = Cast(rhs);\n rv = Operators::op_color_number(op_type, *l_c, *r_n, ctx.c_options, pstate);\n }\n else if (l_type == Expression::COLOR && r_type == Expression::COLOR) {\n Color_Ptr l_c = Cast(lhs);\n Color_Ptr r_c = Cast(rhs);\n rv = Operators::op_colors(op_type, *l_c, *r_c, ctx.c_options, pstate);\n }\n else {\n To_Value to_value(ctx);\n // this will leak if perform does not return a value!\n Value_Obj v_l = Cast(lhs->perform(&to_value));\n Value_Obj v_r = Cast(rhs->perform(&to_value));\n bool interpolant = b->is_right_interpolant() ||\n b->is_left_interpolant() ||\n b->is_interpolant();\n if (op_type == Sass_OP::SUB) interpolant = false;\n // if (op_type == Sass_OP::DIV) interpolant = true;\n // check for type violations\n if (l_type == Expression::MAP || l_type == Expression::FUNCTION_VAL) {\n traces.push_back(Backtrace(v_l->pstate()));\n throw Exception::InvalidValue(traces, *v_l);\n }\n if (r_type == Expression::MAP || l_type == Expression::FUNCTION_VAL) {\n traces.push_back(Backtrace(v_r->pstate()));\n throw Exception::InvalidValue(traces, *v_r);\n }\n Value_Ptr ex = Operators::op_strings(b->op(), *v_l, *v_r, ctx.c_options, pstate, !interpolant); // pass true to compress\n if (String_Constant_Ptr str = Cast(ex))\n {\n if (str->concrete_type() == Expression::STRING)\n {\n String_Constant_Ptr lstr = Cast(lhs);\n String_Constant_Ptr rstr = Cast(rhs);\n if (op_type != Sass_OP::SUB) {\n if (String_Constant_Ptr org = lstr ? lstr : rstr)\n { str->quote_mark(org->quote_mark()); }\n }\n }\n }\n ex->is_interpolant(b->is_interpolant());\n rv = ex;\n }\n }\n catch (Exception::OperationError& err)\n {\n traces.push_back(Backtrace(b->pstate()));\n // throw Exception::Base(b->pstate(), err.what());\n throw Exception::SassValueError(traces, b->pstate(), err);\n }\n\n if (rv) {\n if (schema_op) {\n // XXX: this is never hit via spec tests\n (*s2)[0] = rv;\n rv = s2->perform(this);\n }\n }\n\n return rv.detach();\n\n }\n\n Expression_Ptr Eval::operator()(Unary_Expression_Ptr u)\n {\n Expression_Obj operand = u->operand()->perform(this);\n if (u->optype() == Unary_Expression::NOT) {\n Boolean_Ptr result = SASS_MEMORY_NEW(Boolean, u->pstate(), (bool)*operand);\n result->value(!result->value());\n return result;\n }\n else if (Number_Obj nr = Cast(operand)) {\n // negate value for minus unary expression\n if (u->optype() == Unary_Expression::MINUS) {\n Number_Obj cpy = SASS_MEMORY_COPY(nr);\n cpy->value( - cpy->value() ); // negate value\n return cpy.detach(); // return the copy\n }\n else if (u->optype() == Unary_Expression::SLASH) {\n std::string str = '/' + nr->to_string(ctx.c_options);\n return SASS_MEMORY_NEW(String_Constant, u->pstate(), str);\n }\n // nothing for positive\n return nr.detach();\n }\n else {\n // Special cases: +/- variables which evaluate to null ouput just +/-,\n // but +/- null itself outputs the string\n if (operand->concrete_type() == Expression::NULL_VAL && Cast(u->operand())) {\n u->operand(SASS_MEMORY_NEW(String_Quoted, u->pstate(), \"\"));\n }\n // Never apply unary opertions on colors @see #2140\n else if (Color_Ptr color = Cast(operand)) {\n // Use the color name if this was eval with one\n if (color->disp().length() > 0) {\n operand = SASS_MEMORY_NEW(String_Constant, operand->pstate(), color->disp());\n u->operand(operand);\n }\n }\n else {\n u->operand(operand);\n }\n\n return SASS_MEMORY_NEW(String_Quoted,\n u->pstate(),\n u->inspect());\n }\n // unreachable\n return u;\n }\n\n Expression_Ptr Eval::operator()(Function_Call_Ptr c)\n {\n if (traces.size() > Constants::MaxCallStack) {\n // XXX: this is never hit via spec tests\n std::ostringstream stm;\n stm << \"Stack depth exceeded max of \" << Constants::MaxCallStack;\n error(stm.str(), c->pstate(), traces);\n }\n std::string name(Util::normalize_underscores(c->name()));\n std::string full_name(name + \"[f]\");\n // we make a clone here, need to implement that further\n Arguments_Obj args = c->arguments();\n\n Env* env = environment();\n if (!env->has(full_name) || (!c->via_call() && Prelexer::re_special_fun(name.c_str()))) {\n if (!env->has(\"*[f]\")) {\n for (Argument_Obj arg : args->elements()) {\n if (List_Obj ls = Cast(arg->value())) {\n if (ls->size() == 0) error(\"() isn't a valid CSS value.\", c->pstate(), traces);\n }\n }\n args = Cast(args->perform(this));\n Function_Call_Obj lit = SASS_MEMORY_NEW(Function_Call,\n c->pstate(),\n c->name(),\n args);\n if (args->has_named_arguments()) {\n error(\"Function \" + c->name() + \" doesn't support keyword arguments\", c->pstate(), traces);\n }\n String_Quoted_Ptr str = SASS_MEMORY_NEW(String_Quoted,\n c->pstate(),\n lit->to_string(ctx.c_options));\n str->is_interpolant(c->is_interpolant());\n return str;\n } else {\n // call generic function\n full_name = \"*[f]\";\n }\n }\n\n // further delay for calls\n if (full_name != \"call[f]\") {\n args->set_delayed(false); // verified\n }\n if (full_name != \"if[f]\") {\n args = Cast(args->perform(this));\n }\n Definition_Ptr def = Cast((*env)[full_name]);\n\n if (c->func()) def = c->func()->definition();\n\n if (def->is_overload_stub()) {\n std::stringstream ss;\n size_t L = args->length();\n // account for rest arguments\n if (args->has_rest_argument() && args->length() > 0) {\n // get the rest arguments list\n List_Ptr rest = Cast(args->last()->value());\n // arguments before rest argument plus rest\n if (rest) L += rest->length() - 1;\n }\n ss << full_name << L;\n full_name = ss.str();\n std::string resolved_name(full_name);\n if (!env->has(resolved_name)) error(\"overloaded function `\" + std::string(c->name()) + \"` given wrong number of arguments\", c->pstate(), traces);\n def = Cast((*env)[resolved_name]);\n }\n\n Expression_Obj result = c;\n Block_Obj body = def->block();\n Native_Function func = def->native_function();\n Sass_Function_Entry c_function = def->c_function();\n\n if (c->is_css()) return result.detach();\n\n Parameters_Obj params = def->parameters();\n Env fn_env(def->environment());\n exp.env_stack.push_back(&fn_env);\n\n if (func || body) {\n bind(std::string(\"Function\"), c->name(), params, args, &ctx, &fn_env, this);\n std::string msg(\", in function `\" + c->name() + \"`\");\n traces.push_back(Backtrace(c->pstate(), msg));\n ctx.callee_stack.push_back({\n c->name().c_str(),\n c->pstate().path,\n c->pstate().line + 1,\n c->pstate().column + 1,\n SASS_CALLEE_FUNCTION,\n { env }\n });\n\n // eval the body if user-defined or special, invoke underlying CPP function if native\n if (body /* && !Prelexer::re_special_fun(name.c_str()) */) {\n result = body->perform(this);\n }\n else if (func) {\n result = func(fn_env, *env, ctx, def->signature(), c->pstate(), traces, exp.selector_stack);\n }\n if (!result) {\n error(std::string(\"Function \") + c->name() + \" finished without @return\", c->pstate(), traces);\n }\n ctx.callee_stack.pop_back();\n traces.pop_back();\n }\n\n // else if it's a user-defined c function\n // convert call into C-API compatible form\n else if (c_function) {\n Sass_Function_Fn c_func = sass_function_get_function(c_function);\n if (full_name == \"*[f]\") {\n String_Quoted_Obj str = SASS_MEMORY_NEW(String_Quoted, c->pstate(), c->name());\n Arguments_Obj new_args = SASS_MEMORY_NEW(Arguments, c->pstate());\n new_args->append(SASS_MEMORY_NEW(Argument, c->pstate(), str));\n new_args->concat(args);\n args = new_args;\n }\n\n // populates env with default values for params\n std::string ff(c->name());\n bind(std::string(\"Function\"), c->name(), params, args, &ctx, &fn_env, this);\n std::string msg(\", in function `\" + c->name() + \"`\");\n traces.push_back(Backtrace(c->pstate(), msg));\n ctx.callee_stack.push_back({\n c->name().c_str(),\n c->pstate().path,\n c->pstate().line + 1,\n c->pstate().column + 1,\n SASS_CALLEE_C_FUNCTION,\n { env }\n });\n\n To_C to_c;\n union Sass_Value* c_args = sass_make_list(params->length(), SASS_COMMA, false);\n for(size_t i = 0; i < params->length(); i++) {\n Parameter_Obj param = params->at(i);\n std::string key = param->name();\n AST_Node_Obj node = fn_env.get_local(key);\n Expression_Obj arg = Cast(node);\n sass_list_set_value(c_args, i, arg->perform(&to_c));\n }\n union Sass_Value* c_val = c_func(c_args, c_function, ctx.c_compiler);\n if (sass_value_get_tag(c_val) == SASS_ERROR) {\n error(\"error in C function \" + c->name() + \": \" + sass_error_get_message(c_val), c->pstate(), traces);\n } else if (sass_value_get_tag(c_val) == SASS_WARNING) {\n error(\"warning in C function \" + c->name() + \": \" + sass_warning_get_message(c_val), c->pstate(), traces);\n }\n result = cval_to_astnode(c_val, traces, c->pstate());\n\n ctx.callee_stack.pop_back();\n traces.pop_back();\n sass_delete_value(c_args);\n if (c_val != c_args)\n sass_delete_value(c_val);\n }\n\n // link back to function definition\n // only do this for custom functions\n if (result->pstate().file == std::string::npos)\n result->pstate(c->pstate());\n\n result = result->perform(this);\n result->is_interpolant(c->is_interpolant());\n exp.env_stack.pop_back();\n return result.detach();\n }\n\n Expression_Ptr Eval::operator()(Function_Call_Schema_Ptr s)\n {\n Expression_Ptr evaluated_name = s->name()->perform(this);\n Expression_Ptr evaluated_args = s->arguments()->perform(this);\n String_Schema_Obj ss = SASS_MEMORY_NEW(String_Schema, s->pstate(), 2);\n ss->append(evaluated_name);\n ss->append(evaluated_args);\n return ss->perform(this);\n }\n\n Expression_Ptr Eval::operator()(Variable_Ptr v)\n {\n Expression_Obj value = 0;\n Env* env = environment();\n const std::string& name(v->name());\n EnvResult rv(env->find(name));\n if (rv.found) value = static_cast(rv.it->second.ptr());\n else error(\"Undefined variable: \\\"\" + v->name() + \"\\\".\", v->pstate(), traces);\n if (Argument_Ptr arg = Cast(value)) value = arg->value();\n if (Number_Ptr nr = Cast(value)) nr->zero(true); // force flag\n value->is_interpolant(v->is_interpolant());\n if (force) value->is_expanded(false);\n value->set_delayed(false); // verified\n value = value->perform(this);\n if(!force) rv.it->second = value;\n return value.detach();\n }\n\n Expression_Ptr Eval::operator()(Color_Ptr c)\n {\n return c;\n }\n\n Expression_Ptr Eval::operator()(Number_Ptr n)\n {\n return n;\n }\n\n Expression_Ptr Eval::operator()(Boolean_Ptr b)\n {\n return b;\n }\n\n void Eval::interpolation(Context& ctx, std::string& res, Expression_Obj ex, bool into_quotes, bool was_itpl) {\n\n bool needs_closing_brace = false;\n\n if (Arguments_Ptr args = Cast(ex)) {\n List_Ptr ll = SASS_MEMORY_NEW(List, args->pstate(), 0, SASS_COMMA);\n for(auto arg : args->elements()) {\n ll->append(arg->value());\n }\n ll->is_interpolant(args->is_interpolant());\n needs_closing_brace = true;\n res += \"(\";\n ex = ll;\n }\n if (Number_Ptr nr = Cast(ex)) {\n Number reduced(nr);\n reduced.reduce();\n if (!reduced.is_valid_css_unit()) {\n traces.push_back(Backtrace(nr->pstate()));\n throw Exception::InvalidValue(traces, *nr);\n }\n }\n if (Argument_Ptr arg = Cast(ex)) {\n ex = arg->value();\n }\n if (String_Quoted_Ptr sq = Cast(ex)) {\n if (was_itpl) {\n bool was_interpolant = ex->is_interpolant();\n ex = SASS_MEMORY_NEW(String_Constant, sq->pstate(), sq->value());\n ex->is_interpolant(was_interpolant);\n }\n }\n\n if (Cast(ex)) { return; }\n\n // parent selector needs another go\n if (Cast(ex)) {\n // XXX: this is never hit via spec tests\n ex = ex->perform(this);\n }\n\n if (List_Ptr l = Cast(ex)) {\n List_Obj ll = SASS_MEMORY_NEW(List, l->pstate(), 0, l->separator());\n // this fixes an issue with bourbon sample, not really sure why\n // if (l->size() && Cast((*l)[0])) { res += \"\"; }\n for(Expression_Obj item : *l) {\n item->is_interpolant(l->is_interpolant());\n std::string rl(\"\"); interpolation(ctx, rl, item, into_quotes, l->is_interpolant());\n bool is_null = Cast(item) != 0; // rl != \"\"\n if (!is_null) ll->append(SASS_MEMORY_NEW(String_Quoted, item->pstate(), rl));\n }\n // Check indicates that we probably should not get a list\n // here. Normally single list items are already unwrapped.\n if (l->size() > 1) {\n // string_to_output would fail \"#{'_\\a' '_\\a'}\";\n std::string str(ll->to_string(ctx.c_options));\n str = read_hex_escapes(str); // read escapes\n newline_to_space(str); // replace directly\n res += str; // append to result string\n } else {\n res += (ll->to_string(ctx.c_options));\n }\n ll->is_interpolant(l->is_interpolant());\n }\n\n // Value\n // Function_Call\n // Selector_List\n // String_Quoted\n // String_Constant\n // Parent_Selector\n // Binary_Expression\n else {\n // ex = ex->perform(this);\n if (into_quotes && ex->is_interpolant()) {\n res += evacuate_escapes(ex ? ex->to_string(ctx.c_options) : \"\");\n } else {\n std::string str(ex ? ex->to_string(ctx.c_options) : \"\");\n if (into_quotes) str = read_hex_escapes(str);\n res += str; // append to result string\n }\n }\n\n if (needs_closing_brace) res += \")\";\n\n }\n\n Expression_Ptr Eval::operator()(String_Schema_Ptr s)\n {\n size_t L = s->length();\n bool into_quotes = false;\n if (L > 1) {\n if (!Cast((*s)[0]) && !Cast((*s)[L - 1])) {\n if (String_Constant_Ptr l = Cast((*s)[0])) {\n if (String_Constant_Ptr r = Cast((*s)[L - 1])) {\n if (r->value().size() > 0) {\n if (l->value()[0] == '\"' && r->value()[r->value().size() - 1] == '\"') into_quotes = true;\n if (l->value()[0] == '\\'' && r->value()[r->value().size() - 1] == '\\'') into_quotes = true;\n }\n }\n }\n }\n }\n bool was_quoted = false;\n bool was_interpolant = false;\n std::string res(\"\");\n for (size_t i = 0; i < L; ++i) {\n bool is_quoted = Cast((*s)[i]) != NULL;\n if (was_quoted && !(*s)[i]->is_interpolant() && !was_interpolant) { res += \" \"; }\n else if (i > 0 && is_quoted && !(*s)[i]->is_interpolant() && !was_interpolant) { res += \" \"; }\n Expression_Obj ex = (*s)[i]->perform(this);\n interpolation(ctx, res, ex, into_quotes, ex->is_interpolant());\n was_quoted = Cast((*s)[i]) != NULL;\n was_interpolant = (*s)[i]->is_interpolant();\n\n }\n if (!s->is_interpolant()) {\n if (s->length() > 1 && res == \"\") return SASS_MEMORY_NEW(Null, s->pstate());\n return SASS_MEMORY_NEW(String_Constant, s->pstate(), res, s->css());\n }\n // string schema seems to have a special unquoting behavior (also handles \"nested\" quotes)\n String_Quoted_Obj str = SASS_MEMORY_NEW(String_Quoted, s->pstate(), res, 0, false, false, false, s->css());\n // if (s->is_interpolant()) str->quote_mark(0);\n // String_Constant_Ptr str = SASS_MEMORY_NEW(String_Constant, s->pstate(), res);\n if (str->quote_mark()) str->quote_mark('*');\n else if (!is_in_comment) str->value(string_to_output(str->value()));\n str->is_interpolant(s->is_interpolant());\n return str.detach();\n }\n\n\n Expression_Ptr Eval::operator()(String_Constant_Ptr s)\n {\n return s;\n }\n\n Expression_Ptr Eval::operator()(String_Quoted_Ptr s)\n {\n String_Quoted_Ptr str = SASS_MEMORY_NEW(String_Quoted, s->pstate(), \"\");\n str->value(s->value());\n str->quote_mark(s->quote_mark());\n str->is_interpolant(s->is_interpolant());\n return str;\n }\n\n Expression_Ptr Eval::operator()(Supports_Operator_Ptr c)\n {\n Expression_Ptr left = c->left()->perform(this);\n Expression_Ptr right = c->right()->perform(this);\n Supports_Operator_Ptr cc = SASS_MEMORY_NEW(Supports_Operator,\n c->pstate(),\n Cast(left),\n Cast(right),\n c->operand());\n return cc;\n }\n\n Expression_Ptr Eval::operator()(Supports_Negation_Ptr c)\n {\n Expression_Ptr condition = c->condition()->perform(this);\n Supports_Negation_Ptr cc = SASS_MEMORY_NEW(Supports_Negation,\n c->pstate(),\n Cast(condition));\n return cc;\n }\n\n Expression_Ptr Eval::operator()(Supports_Declaration_Ptr c)\n {\n Expression_Ptr feature = c->feature()->perform(this);\n Expression_Ptr value = c->value()->perform(this);\n Supports_Declaration_Ptr cc = SASS_MEMORY_NEW(Supports_Declaration,\n c->pstate(),\n feature,\n value);\n return cc;\n }\n\n Expression_Ptr Eval::operator()(Supports_Interpolation_Ptr c)\n {\n Expression_Ptr value = c->value()->perform(this);\n Supports_Interpolation_Ptr cc = SASS_MEMORY_NEW(Supports_Interpolation,\n c->pstate(),\n value);\n return cc;\n }\n\n Expression_Ptr Eval::operator()(At_Root_Query_Ptr e)\n {\n Expression_Obj feature = e->feature();\n feature = (feature ? feature->perform(this) : 0);\n Expression_Obj value = e->value();\n value = (value ? value->perform(this) : 0);\n Expression_Ptr ee = SASS_MEMORY_NEW(At_Root_Query,\n e->pstate(),\n Cast(feature),\n value);\n return ee;\n }\n\n Media_Query_Ptr Eval::operator()(Media_Query_Ptr q)\n {\n String_Obj t = q->media_type();\n t = static_cast(t.isNull() ? 0 : t->perform(this));\n Media_Query_Obj qq = SASS_MEMORY_NEW(Media_Query,\n q->pstate(),\n t,\n q->length(),\n q->is_negated(),\n q->is_restricted());\n for (size_t i = 0, L = q->length(); i < L; ++i) {\n qq->append(static_cast((*q)[i]->perform(this)));\n }\n return qq.detach();\n }\n\n Expression_Ptr Eval::operator()(Media_Query_Expression_Ptr e)\n {\n Expression_Obj feature = e->feature();\n feature = (feature ? feature->perform(this) : 0);\n if (feature && Cast(feature)) {\n feature = SASS_MEMORY_NEW(String_Quoted,\n feature->pstate(),\n Cast(feature)->value());\n }\n Expression_Obj value = e->value();\n value = (value ? value->perform(this) : 0);\n if (value && Cast(value)) {\n // XXX: this is never hit via spec tests\n value = SASS_MEMORY_NEW(String_Quoted,\n value->pstate(),\n Cast(value)->value());\n }\n return SASS_MEMORY_NEW(Media_Query_Expression,\n e->pstate(),\n feature,\n value,\n e->is_interpolated());\n }\n\n Expression_Ptr Eval::operator()(Null_Ptr n)\n {\n return n;\n }\n\n Expression_Ptr Eval::operator()(Argument_Ptr a)\n {\n Expression_Obj val = a->value()->perform(this);\n bool is_rest_argument = a->is_rest_argument();\n bool is_keyword_argument = a->is_keyword_argument();\n\n if (a->is_rest_argument()) {\n if (val->concrete_type() == Expression::MAP) {\n is_rest_argument = false;\n is_keyword_argument = true;\n }\n else if(val->concrete_type() != Expression::LIST) {\n List_Obj wrapper = SASS_MEMORY_NEW(List,\n val->pstate(),\n 0,\n SASS_COMMA,\n true);\n wrapper->append(val);\n val = wrapper;\n }\n }\n return SASS_MEMORY_NEW(Argument,\n a->pstate(),\n val,\n a->name(),\n is_rest_argument,\n is_keyword_argument);\n }\n\n Expression_Ptr Eval::operator()(Arguments_Ptr a)\n {\n Arguments_Obj aa = SASS_MEMORY_NEW(Arguments, a->pstate());\n if (a->length() == 0) return aa.detach();\n for (size_t i = 0, L = a->length(); i < L; ++i) {\n Expression_Obj rv = (*a)[i]->perform(this);\n Argument_Ptr arg = Cast(rv);\n if (!(arg->is_rest_argument() || arg->is_keyword_argument())) {\n aa->append(arg);\n }\n }\n\n if (a->has_rest_argument()) {\n Expression_Obj rest = a->get_rest_argument()->perform(this);\n Expression_Obj splat = Cast(rest)->value()->perform(this);\n\n Sass_Separator separator = SASS_COMMA;\n List_Ptr ls = Cast(splat);\n Map_Ptr ms = Cast(splat);\n\n List_Obj arglist = SASS_MEMORY_NEW(List,\n splat->pstate(),\n 0,\n ls ? ls->separator() : separator,\n true);\n\n if (ls && ls->is_arglist()) {\n arglist->concat(ls);\n } else if (ms) {\n aa->append(SASS_MEMORY_NEW(Argument, splat->pstate(), ms, \"\", false, true));\n } else if (ls) {\n arglist->concat(ls);\n } else {\n arglist->append(splat);\n }\n if (arglist->length()) {\n aa->append(SASS_MEMORY_NEW(Argument, splat->pstate(), arglist, \"\", true));\n }\n }\n\n if (a->has_keyword_argument()) {\n Expression_Obj rv = a->get_keyword_argument()->perform(this);\n Argument_Ptr rvarg = Cast(rv);\n Expression_Obj kwarg = rvarg->value()->perform(this);\n\n aa->append(SASS_MEMORY_NEW(Argument, kwarg->pstate(), kwarg, \"\", false, true));\n }\n return aa.detach();\n }\n\n Expression_Ptr Eval::operator()(Comment_Ptr c)\n {\n return 0;\n }\n\n inline Expression_Ptr Eval::fallback_impl(AST_Node_Ptr n)\n {\n return static_cast(n);\n }\n\n // All the binary helpers.\n\n Expression_Ptr cval_to_astnode(union Sass_Value* v, Backtraces traces, ParserState pstate)\n {\n using std::strlen;\n using std::strcpy;\n Expression_Ptr e = NULL;\n switch (sass_value_get_tag(v)) {\n case SASS_BOOLEAN: {\n e = SASS_MEMORY_NEW(Boolean, pstate, !!sass_boolean_get_value(v));\n } break;\n case SASS_NUMBER: {\n e = SASS_MEMORY_NEW(Number, pstate, sass_number_get_value(v), sass_number_get_unit(v));\n } break;\n case SASS_COLOR: {\n e = SASS_MEMORY_NEW(Color, pstate, sass_color_get_r(v), sass_color_get_g(v), sass_color_get_b(v), sass_color_get_a(v));\n } break;\n case SASS_STRING: {\n if (sass_string_is_quoted(v))\n e = SASS_MEMORY_NEW(String_Quoted, pstate, sass_string_get_value(v));\n else {\n e = SASS_MEMORY_NEW(String_Constant, pstate, sass_string_get_value(v));\n }\n } break;\n case SASS_LIST: {\n List_Ptr l = SASS_MEMORY_NEW(List, pstate, sass_list_get_length(v), sass_list_get_separator(v));\n for (size_t i = 0, L = sass_list_get_length(v); i < L; ++i) {\n l->append(cval_to_astnode(sass_list_get_value(v, i), traces, pstate));\n }\n l->is_bracketed(sass_list_get_is_bracketed(v));\n e = l;\n } break;\n case SASS_MAP: {\n Map_Ptr m = SASS_MEMORY_NEW(Map, pstate);\n for (size_t i = 0, L = sass_map_get_length(v); i < L; ++i) {\n *m << std::make_pair(\n cval_to_astnode(sass_map_get_key(v, i), traces, pstate),\n cval_to_astnode(sass_map_get_value(v, i), traces, pstate));\n }\n e = m;\n } break;\n case SASS_NULL: {\n e = SASS_MEMORY_NEW(Null, pstate);\n } break;\n case SASS_ERROR: {\n error(\"Error in C function: \" + std::string(sass_error_get_message(v)), pstate, traces);\n } break;\n case SASS_WARNING: {\n error(\"Warning in C function: \" + std::string(sass_warning_get_message(v)), pstate, traces);\n } break;\n default: break;\n }\n return e;\n }\n\n Selector_List_Ptr Eval::operator()(Selector_List_Ptr s)\n {\n std::vector rv;\n Selector_List_Obj sl = SASS_MEMORY_NEW(Selector_List, s->pstate());\n sl->is_optional(s->is_optional());\n sl->media_block(s->media_block());\n sl->is_optional(s->is_optional());\n for (size_t i = 0, iL = s->length(); i < iL; ++i) {\n rv.push_back(operator()((*s)[i]));\n }\n\n // we should actually permutate parent first\n // but here we have permutated the selector first\n size_t round = 0;\n while (round != std::string::npos) {\n bool abort = true;\n for (size_t i = 0, iL = rv.size(); i < iL; ++i) {\n if (rv[i]->length() > round) {\n sl->append((*rv[i])[round]);\n abort = false;\n }\n }\n if (abort) {\n round = std::string::npos;\n } else {\n ++ round;\n }\n\n }\n return sl.detach();\n }\n\n\n Selector_List_Ptr Eval::operator()(Complex_Selector_Ptr s)\n {\n bool implicit_parent = !exp.old_at_root_without_rule;\n if (is_in_selector_schema) exp.selector_stack.push_back(0);\n Selector_List_Obj resolved = s->resolve_parent_refs(exp.selector_stack, traces, implicit_parent);\n if (is_in_selector_schema) exp.selector_stack.pop_back();\n for (size_t i = 0; i < resolved->length(); i++) {\n Complex_Selector_Ptr is = resolved->at(i)->first();\n while (is) {\n if (is->head()) {\n is->head(operator()(is->head()));\n }\n is = is->tail();\n }\n }\n return resolved.detach();\n }\n\n Compound_Selector_Ptr Eval::operator()(Compound_Selector_Ptr s)\n {\n for (size_t i = 0; i < s->length(); i++) {\n Simple_Selector_Ptr ss = s->at(i);\n // skip parents here (called via resolve_parent_refs)\n if (ss == NULL || Cast(ss)) continue;\n s->at(i) = Cast(ss->perform(this));\n }\n return s;\n }\n\n Selector_List_Ptr Eval::operator()(Selector_Schema_Ptr s)\n {\n LOCAL_FLAG(is_in_selector_schema, true);\n // the parser will look for a brace to end the selector\n ctx.c_options.in_selector = true; // do not compress colors\n Expression_Obj sel = s->contents()->perform(this);\n std::string result_str(sel->to_string(ctx.c_options));\n ctx.c_options.in_selector = false; // flag temporary only\n result_str = unquote(Util::rtrim(result_str));\n char* temp_cstr = sass_copy_c_string(result_str.c_str());\n ctx.strings.push_back(temp_cstr); // attach to context\n Parser p = Parser::from_c_str(temp_cstr, ctx, traces, s->pstate());\n p.last_media_block = s->media_block();\n // a selector schema may or may not connect to parent?\n bool chroot = s->connect_parent() == false;\n Selector_List_Obj sl = p.parse_selector_list(chroot);\n auto vec_str_rend = ctx.strings.rend();\n auto vec_str_rbegin = ctx.strings.rbegin();\n // remove the first item searching from the back\n // we cannot assume our item is still the last one\n // order is not important, so we can optimize this\n auto it = std::find(vec_str_rbegin, vec_str_rend, temp_cstr);\n // undefined behavior if not found!\n if (it != vec_str_rend) {\n // overwrite with last item\n *it = ctx.strings.back();\n // remove last one from vector\n ctx.strings.pop_back();\n // free temporary copy\n free(temp_cstr);\n }\n flag_is_in_selector_schema.reset();\n return operator()(sl);\n }\n\n Expression_Ptr Eval::operator()(Parent_Selector_Ptr p)\n {\n if (Selector_List_Obj pr = selector()) {\n exp.selector_stack.pop_back();\n Selector_List_Obj rv = operator()(pr);\n exp.selector_stack.push_back(rv);\n return rv.detach();\n } else {\n return SASS_MEMORY_NEW(Null, p->pstate());\n }\n }\n\n Simple_Selector_Ptr Eval::operator()(Simple_Selector_Ptr s)\n {\n return s;\n }\n\n // hotfix to avoid invalid nested `:not` selectors\n // probably the wrong place, but this should ultimately\n // be fixed by implement superselector correctly for `:not`\n // first use of \"find\" (ATM only implemented for selectors)\n bool hasNotSelector(AST_Node_Obj obj) {\n if (Wrapped_Selector_Ptr w = Cast(obj)) {\n return w->name() == \":not\";\n }\n return false;\n }\n\n Wrapped_Selector_Ptr Eval::operator()(Wrapped_Selector_Ptr s)\n {\n\n if (s->name() == \":not\") {\n if (exp.selector_stack.back()) {\n if (s->selector()->find(hasNotSelector)) {\n s->selector()->clear();\n s->name(\" \");\n } else if (s->selector()->length() == 1) {\n Complex_Selector_Ptr cs = s->selector()->at(0);\n if (cs->tail()) {\n s->selector()->clear();\n s->name(\" \");\n }\n } else if (s->selector()->length() > 1) {\n s->selector()->clear();\n s->name(\" \");\n }\n }\n }\n return s;\n };\n\n}\n" }, { "path": "libsass-build/eval.hpp", "content": "#ifndef SASS_EVAL_H\n#define SASS_EVAL_H\n\n#include \"ast.hpp\"\n#include \"context.hpp\"\n#include \"listize.hpp\"\n#include \"operation.hpp\"\n#include \"environment.hpp\"\n\nnamespace Sass {\n\n class Expand;\n class Context;\n\n class Eval : public Operation_CRTP {\n\n private:\n Expression_Ptr fallback_impl(AST_Node_Ptr n);\n\n public:\n Expand& exp;\n Context& ctx;\n Backtraces& traces;\n Eval(Expand& exp);\n ~Eval();\n\n bool force;\n bool is_in_comment;\n bool is_in_selector_schema;\n\n Boolean_Obj bool_true;\n Boolean_Obj bool_false;\n\n Env* environment();\n Selector_List_Obj selector();\n\n // for evaluating function bodies\n Expression_Ptr operator()(Block_Ptr);\n Expression_Ptr operator()(Assignment_Ptr);\n Expression_Ptr operator()(If_Ptr);\n Expression_Ptr operator()(For_Ptr);\n Expression_Ptr operator()(Each_Ptr);\n Expression_Ptr operator()(While_Ptr);\n Expression_Ptr operator()(Return_Ptr);\n Expression_Ptr operator()(Warning_Ptr);\n Expression_Ptr operator()(Error_Ptr);\n Expression_Ptr operator()(Debug_Ptr);\n\n Expression_Ptr operator()(List_Ptr);\n Expression_Ptr operator()(Map_Ptr);\n Expression_Ptr operator()(Binary_Expression_Ptr);\n Expression_Ptr operator()(Unary_Expression_Ptr);\n Expression_Ptr operator()(Function_Call_Ptr);\n Expression_Ptr operator()(Function_Call_Schema_Ptr);\n Expression_Ptr operator()(Variable_Ptr);\n Expression_Ptr operator()(Number_Ptr);\n Expression_Ptr operator()(Color_Ptr);\n Expression_Ptr operator()(Boolean_Ptr);\n Expression_Ptr operator()(String_Schema_Ptr);\n Expression_Ptr operator()(String_Quoted_Ptr);\n Expression_Ptr operator()(String_Constant_Ptr);\n // Expression_Ptr operator()(Selector_List_Ptr);\n Media_Query_Ptr operator()(Media_Query_Ptr);\n Expression_Ptr operator()(Media_Query_Expression_Ptr);\n Expression_Ptr operator()(At_Root_Query_Ptr);\n Expression_Ptr operator()(Supports_Operator_Ptr);\n Expression_Ptr operator()(Supports_Negation_Ptr);\n Expression_Ptr operator()(Supports_Declaration_Ptr);\n Expression_Ptr operator()(Supports_Interpolation_Ptr);\n Expression_Ptr operator()(Null_Ptr);\n Expression_Ptr operator()(Argument_Ptr);\n Expression_Ptr operator()(Arguments_Ptr);\n Expression_Ptr operator()(Comment_Ptr);\n\n // these will return selectors\n Selector_List_Ptr operator()(Selector_List_Ptr);\n Selector_List_Ptr operator()(Complex_Selector_Ptr);\n Compound_Selector_Ptr operator()(Compound_Selector_Ptr);\n Simple_Selector_Ptr operator()(Simple_Selector_Ptr s);\n Wrapped_Selector_Ptr operator()(Wrapped_Selector_Ptr s);\n // they don't have any specific implementation (yet)\n // Element_Selector_Ptr operator()(Element_Selector_Ptr s) { return s; };\n // Pseudo_Selector_Ptr operator()(Pseudo_Selector_Ptr s) { return s; };\n // Class_Selector_Ptr operator()(Class_Selector_Ptr s) { return s; };\n // Id_Selector_Ptr operator()(Id_Selector_Ptr s) { return s; };\n // Placeholder_Selector_Ptr operator()(Placeholder_Selector_Ptr s) { return s; };\n // actual evaluated selectors\n Selector_List_Ptr operator()(Selector_Schema_Ptr);\n Expression_Ptr operator()(Parent_Selector_Ptr);\n\n template \n Expression_Ptr fallback(U x) { return fallback_impl(x); }\n\n private:\n void interpolation(Context& ctx, std::string& res, Expression_Obj ex, bool into_quotes, bool was_itpl = false);\n\n };\n\n Expression_Ptr cval_to_astnode(union Sass_Value* v, Backtraces traces, ParserState pstate = ParserState(\"[AST]\"));\n\n}\n\n#endif\n" }, { "path": "libsass-build/expand.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n\n#include \"ast.hpp\"\n#include \"expand.hpp\"\n#include \"bind.hpp\"\n#include \"eval.hpp\"\n#include \"backtrace.hpp\"\n#include \"context.hpp\"\n#include \"parser.hpp\"\n#include \"sass_functions.hpp\"\n\nnamespace Sass {\n\n // simple endless recursion protection\n const size_t maxRecursion = 500;\n\n Expand::Expand(Context& ctx, Env* env, std::vector* stack)\n : ctx(ctx),\n traces(ctx.traces),\n eval(Eval(*this)),\n recursions(0),\n in_keyframes(false),\n at_root_without_rule(false),\n old_at_root_without_rule(false),\n env_stack(std::vector()),\n block_stack(std::vector()),\n call_stack(std::vector()),\n selector_stack(std::vector()),\n media_block_stack(std::vector())\n {\n env_stack.push_back(0);\n env_stack.push_back(env);\n block_stack.push_back(0);\n call_stack.push_back(0);\n if (stack == NULL) { selector_stack.push_back(0); }\n else { selector_stack.insert(selector_stack.end(), stack->begin(), stack->end()); }\n media_block_stack.push_back(0);\n }\n\n Env* Expand::environment()\n {\n if (env_stack.size() > 0)\n return env_stack.back();\n return 0;\n }\n\n Selector_List_Obj Expand::selector()\n {\n if (selector_stack.size() > 0)\n return selector_stack.back();\n return 0;\n }\n\n // blocks create new variable scopes\n Block_Ptr Expand::operator()(Block_Ptr b)\n {\n // create new local environment\n // set the current env as parent\n Env env(environment());\n // copy the block object (add items later)\n Block_Obj bb = SASS_MEMORY_NEW(Block,\n b->pstate(),\n b->length(),\n b->is_root());\n // setup block and env stack\n this->block_stack.push_back(bb);\n this->env_stack.push_back(&env);\n // operate on block\n // this may throw up!\n this->append_block(b);\n // revert block and env stack\n this->block_stack.pop_back();\n this->env_stack.pop_back();\n // return copy\n return bb.detach();\n }\n\n Statement_Ptr Expand::operator()(Ruleset_Ptr r)\n {\n LOCAL_FLAG(old_at_root_without_rule, at_root_without_rule);\n\n if (in_keyframes) {\n Block_Ptr bb = operator()(r->block());\n Keyframe_Rule_Obj k = SASS_MEMORY_NEW(Keyframe_Rule, r->pstate(), bb);\n if (r->selector()) {\n if (Selector_List_Ptr s = r->selector()) {\n selector_stack.push_back(0);\n k->name(s->eval(eval));\n selector_stack.pop_back();\n }\n }\n return k.detach();\n }\n\n // reset when leaving scope\n LOCAL_FLAG(at_root_without_rule, false);\n\n // `&` is allowed in `@at-root`!\n bool has_parent_selector = false;\n for (size_t i = 0, L = selector_stack.size(); i < L && !has_parent_selector; i++) {\n Selector_List_Obj ll = selector_stack.at(i);\n has_parent_selector = ll != 0 && ll->length() > 0;\n }\n\n Selector_List_Obj sel = r->selector();\n if (sel) sel = sel->eval(eval);\n\n // check for parent selectors in base level rules\n if (r->is_root() || (block_stack.back() && block_stack.back()->is_root())) {\n if (Selector_List_Ptr selector_list = Cast(r->selector())) {\n for (Complex_Selector_Obj complex_selector : selector_list->elements()) {\n Complex_Selector_Ptr tail = complex_selector;\n while (tail) {\n if (tail->head()) for (Simple_Selector_Obj header : tail->head()->elements()) {\n Parent_Selector_Ptr ptr = Cast(header);\n if (ptr == NULL || (!ptr->real() || has_parent_selector)) continue;\n std::string sel_str(complex_selector->to_string(ctx.c_options));\n error(\"Base-level rules cannot contain the parent-selector-referencing character '&'.\", header->pstate(), traces);\n }\n tail = tail->tail();\n }\n }\n }\n }\n else {\n if (sel->length() == 0 || sel->has_parent_ref()) {\n if (sel->has_real_parent_ref() && !has_parent_selector) {\n error(\"Base-level rules cannot contain the parent-selector-referencing character '&'.\", sel->pstate(), traces);\n }\n }\n }\n\n // do not connect parent again\n sel->remove_parent_selectors();\n selector_stack.push_back(sel);\n Env env(environment());\n if (block_stack.back()->is_root()) {\n env_stack.push_back(&env);\n }\n sel->set_media_block(media_block_stack.back());\n Block_Obj blk = 0;\n if (r->block()) blk = operator()(r->block());\n Ruleset_Ptr rr = SASS_MEMORY_NEW(Ruleset,\n r->pstate(),\n sel,\n blk);\n selector_stack.pop_back();\n if (block_stack.back()->is_root()) {\n env_stack.pop_back();\n }\n\n rr->is_root(r->is_root());\n rr->tabs(r->tabs());\n\n return rr;\n }\n\n Statement_Ptr Expand::operator()(Supports_Block_Ptr f)\n {\n Expression_Obj condition = f->condition()->perform(&eval);\n Supports_Block_Obj ff = SASS_MEMORY_NEW(Supports_Block,\n f->pstate(),\n Cast(condition),\n operator()(f->block()));\n return ff.detach();\n }\n\n Statement_Ptr Expand::operator()(Media_Block_Ptr m)\n {\n Media_Block_Obj cpy = SASS_MEMORY_COPY(m);\n // Media_Blocks are prone to have circular references\n // Copy could leak memory if it does not get picked up\n // Looks like we are able to reset block reference for copy\n // Good as it will ensure a low memory overhead for this fix\n // So this is a cheap solution with a minimal price\n ctx.ast_gc.push_back(cpy); cpy->block(0);\n Expression_Obj mq = eval(m->media_queries());\n std::string str_mq(mq->to_string(ctx.c_options));\n char* str = sass_copy_c_string(str_mq.c_str());\n ctx.strings.push_back(str);\n Parser p(Parser::from_c_str(str, ctx, traces, mq->pstate()));\n mq = p.parse_media_queries(); // re-assign now\n cpy->media_queries(mq);\n media_block_stack.push_back(cpy);\n Block_Obj blk = operator()(m->block());\n Media_Block_Ptr mm = SASS_MEMORY_NEW(Media_Block,\n m->pstate(),\n mq,\n blk);\n media_block_stack.pop_back();\n mm->tabs(m->tabs());\n return mm;\n }\n\n Statement_Ptr Expand::operator()(At_Root_Block_Ptr a)\n {\n Block_Obj ab = a->block();\n Expression_Obj ae = a->expression();\n\n if (ae) ae = ae->perform(&eval);\n else ae = SASS_MEMORY_NEW(At_Root_Query, a->pstate());\n\n LOCAL_FLAG(at_root_without_rule, true);\n LOCAL_FLAG(in_keyframes, false);\n\n ;\n\n Block_Obj bb = ab ? operator()(ab) : NULL;\n At_Root_Block_Obj aa = SASS_MEMORY_NEW(At_Root_Block,\n a->pstate(),\n bb,\n Cast(ae));\n return aa.detach();\n }\n\n Statement_Ptr Expand::operator()(Directive_Ptr a)\n {\n LOCAL_FLAG(in_keyframes, a->is_keyframes());\n Block_Ptr ab = a->block();\n Selector_List_Ptr as = a->selector();\n Expression_Ptr av = a->value();\n selector_stack.push_back(0);\n if (av) av = av->perform(&eval);\n if (as) as = eval(as);\n selector_stack.pop_back();\n Block_Ptr bb = ab ? operator()(ab) : NULL;\n Directive_Ptr aa = SASS_MEMORY_NEW(Directive,\n a->pstate(),\n a->keyword(),\n as,\n bb,\n av);\n return aa;\n }\n\n Statement_Ptr Expand::operator()(Declaration_Ptr d)\n {\n Block_Obj ab = d->block();\n String_Obj old_p = d->property();\n Expression_Obj prop = old_p->perform(&eval);\n String_Obj new_p = Cast(prop);\n // we might get a color back\n if (!new_p) {\n std::string str(prop->to_string(ctx.c_options));\n new_p = SASS_MEMORY_NEW(String_Constant, old_p->pstate(), str);\n }\n Expression_Obj value = d->value();\n if (value) value = value->perform(&eval);\n Block_Obj bb = ab ? operator()(ab) : NULL;\n if (!bb) {\n if (!value || (value->is_invisible() && !d->is_important())) return 0;\n }\n Declaration_Ptr decl = SASS_MEMORY_NEW(Declaration,\n d->pstate(),\n new_p,\n value,\n d->is_important(),\n d->is_custom_property(),\n bb);\n decl->tabs(d->tabs());\n return decl;\n }\n\n Statement_Ptr Expand::operator()(Assignment_Ptr a)\n {\n Env* env = environment();\n const std::string& var(a->variable());\n if (a->is_global()) {\n if (a->is_default()) {\n if (env->has_global(var)) {\n Expression_Obj e = Cast(env->get_global(var));\n if (!e || e->concrete_type() == Expression::NULL_VAL) {\n env->set_global(var, a->value()->perform(&eval));\n }\n }\n else {\n env->set_global(var, a->value()->perform(&eval));\n }\n }\n else {\n env->set_global(var, a->value()->perform(&eval));\n }\n }\n else if (a->is_default()) {\n if (env->has_lexical(var)) {\n auto cur = env;\n while (cur && cur->is_lexical()) {\n if (cur->has_local(var)) {\n if (AST_Node_Obj node = cur->get_local(var)) {\n Expression_Obj e = Cast(node);\n if (!e || e->concrete_type() == Expression::NULL_VAL) {\n cur->set_local(var, a->value()->perform(&eval));\n }\n }\n else {\n throw std::runtime_error(\"Env not in sync\");\n }\n return 0;\n }\n cur = cur->parent();\n }\n throw std::runtime_error(\"Env not in sync\");\n }\n else if (env->has_global(var)) {\n if (AST_Node_Obj node = env->get_global(var)) {\n Expression_Obj e = Cast(node);\n if (!e || e->concrete_type() == Expression::NULL_VAL) {\n env->set_global(var, a->value()->perform(&eval));\n }\n }\n }\n else if (env->is_lexical()) {\n env->set_local(var, a->value()->perform(&eval));\n }\n else {\n env->set_local(var, a->value()->perform(&eval));\n }\n }\n else {\n env->set_lexical(var, a->value()->perform(&eval));\n }\n return 0;\n }\n\n Statement_Ptr Expand::operator()(Import_Ptr imp)\n {\n Import_Obj result = SASS_MEMORY_NEW(Import, imp->pstate());\n if (imp->import_queries() && imp->import_queries()->size()) {\n Expression_Obj ex = imp->import_queries()->perform(&eval);\n result->import_queries(Cast(ex));\n }\n for ( size_t i = 0, S = imp->urls().size(); i < S; ++i) {\n result->urls().push_back(imp->urls()[i]->perform(&eval));\n }\n // all resources have been dropped for Input_Stubs\n // for ( size_t i = 0, S = imp->incs().size(); i < S; ++i) {}\n return result.detach();\n }\n\n Statement_Ptr Expand::operator()(Import_Stub_Ptr i)\n {\n traces.push_back(Backtrace(i->pstate()));\n // get parent node from call stack\n AST_Node_Obj parent = call_stack.back();\n if (Cast(parent) == NULL) {\n error(\"Import directives may not be used within control directives or mixins.\", i->pstate(), traces);\n }\n // we don't seem to need that actually afterall\n Sass_Import_Entry import = sass_make_import(\n i->imp_path().c_str(),\n i->abs_path().c_str(),\n 0, 0\n );\n ctx.import_stack.push_back(import);\n\n Block_Obj trace_block = SASS_MEMORY_NEW(Block, i->pstate());\n Trace_Obj trace = SASS_MEMORY_NEW(Trace, i->pstate(), i->imp_path(), trace_block, 'i');\n block_stack.back()->append(trace);\n block_stack.push_back(trace_block);\n\n const std::string& abs_path(i->resource().abs_path);\n append_block(ctx.sheets.at(abs_path).root);\n sass_delete_import(ctx.import_stack.back());\n ctx.import_stack.pop_back();\n block_stack.pop_back();\n traces.pop_back();\n return 0;\n }\n\n Statement_Ptr Expand::operator()(Warning_Ptr w)\n {\n // eval handles this too, because warnings may occur in functions\n w->perform(&eval);\n return 0;\n }\n\n Statement_Ptr Expand::operator()(Error_Ptr e)\n {\n // eval handles this too, because errors may occur in functions\n e->perform(&eval);\n return 0;\n }\n\n Statement_Ptr Expand::operator()(Debug_Ptr d)\n {\n // eval handles this too, because warnings may occur in functions\n d->perform(&eval);\n return 0;\n }\n\n Statement_Ptr Expand::operator()(Comment_Ptr c)\n {\n if (ctx.output_style() == COMPRESSED) {\n // comments should not be evaluated in compact\n // https://github.com/sass/libsass/issues/2359\n if (!c->is_important()) return NULL;\n }\n eval.is_in_comment = true;\n Comment_Ptr rv = SASS_MEMORY_NEW(Comment, c->pstate(), Cast(c->text()->perform(&eval)), c->is_important());\n eval.is_in_comment = false;\n // TODO: eval the text, once we're parsing/storing it as a String_Schema\n return rv;\n }\n\n Statement_Ptr Expand::operator()(If_Ptr i)\n {\n Env env(environment(), true);\n env_stack.push_back(&env);\n call_stack.push_back(i);\n Expression_Obj rv = i->predicate()->perform(&eval);\n if (*rv) {\n append_block(i->block());\n }\n else {\n Block_Ptr alt = i->alternative();\n if (alt) append_block(alt);\n }\n call_stack.pop_back();\n env_stack.pop_back();\n return 0;\n }\n\n // For does not create a new env scope\n // But iteration vars are reset afterwards\n Statement_Ptr Expand::operator()(For_Ptr f)\n {\n std::string variable(f->variable());\n Expression_Obj low = f->lower_bound()->perform(&eval);\n if (low->concrete_type() != Expression::NUMBER) {\n traces.push_back(Backtrace(low->pstate()));\n throw Exception::TypeMismatch(traces, *low, \"integer\");\n }\n Expression_Obj high = f->upper_bound()->perform(&eval);\n if (high->concrete_type() != Expression::NUMBER) {\n traces.push_back(Backtrace(high->pstate()));\n throw Exception::TypeMismatch(traces, *high, \"integer\");\n }\n Number_Obj sass_start = Cast(low);\n Number_Obj sass_end = Cast(high);\n // check if units are valid for sequence\n if (sass_start->unit() != sass_end->unit()) {\n std::stringstream msg; msg << \"Incompatible units: '\"\n << sass_start->unit() << \"' and '\"\n << sass_end->unit() << \"'.\";\n error(msg.str(), low->pstate(), traces);\n }\n double start = sass_start->value();\n double end = sass_end->value();\n // only create iterator once in this environment\n Env env(environment(), true);\n env_stack.push_back(&env);\n call_stack.push_back(f);\n Block_Ptr body = f->block();\n if (start < end) {\n if (f->is_inclusive()) ++end;\n for (double i = start;\n i < end;\n ++i) {\n Number_Obj it = SASS_MEMORY_NEW(Number, low->pstate(), i, sass_end->unit());\n env.set_local(variable, it);\n append_block(body);\n }\n } else {\n if (f->is_inclusive()) --end;\n for (double i = start;\n i > end;\n --i) {\n Number_Obj it = SASS_MEMORY_NEW(Number, low->pstate(), i, sass_end->unit());\n env.set_local(variable, it);\n append_block(body);\n }\n }\n call_stack.pop_back();\n env_stack.pop_back();\n return 0;\n }\n\n // Eval does not create a new env scope\n // But iteration vars are reset afterwards\n Statement_Ptr Expand::operator()(Each_Ptr e)\n {\n std::vector variables(e->variables());\n Expression_Obj expr = e->list()->perform(&eval);\n List_Obj list = 0;\n Map_Obj map;\n if (expr->concrete_type() == Expression::MAP) {\n map = Cast(expr);\n }\n else if (Selector_List_Ptr ls = Cast(expr)) {\n Listize listize;\n Expression_Obj rv = ls->perform(&listize);\n list = Cast(rv);\n }\n else if (expr->concrete_type() != Expression::LIST) {\n list = SASS_MEMORY_NEW(List, expr->pstate(), 1, SASS_COMMA);\n list->append(expr);\n }\n else {\n list = Cast(expr);\n }\n // remember variables and then reset them\n Env env(environment(), true);\n env_stack.push_back(&env);\n call_stack.push_back(e);\n Block_Ptr body = e->block();\n\n if (map) {\n for (auto key : map->keys()) {\n Expression_Obj k = key->perform(&eval);\n Expression_Obj v = map->at(key)->perform(&eval);\n\n if (variables.size() == 1) {\n List_Obj variable = SASS_MEMORY_NEW(List, map->pstate(), 2, SASS_SPACE);\n variable->append(k);\n variable->append(v);\n env.set_local(variables[0], variable);\n } else {\n env.set_local(variables[0], k);\n env.set_local(variables[1], v);\n }\n append_block(body);\n }\n }\n else {\n // bool arglist = list->is_arglist();\n if (list->length() == 1 && Cast(list)) {\n list = Cast(list);\n }\n for (size_t i = 0, L = list->length(); i < L; ++i) {\n Expression_Obj item = list->at(i);\n // unwrap value if the expression is an argument\n if (Argument_Obj arg = Cast(item)) item = arg->value();\n // check if we got passed a list of args (investigate)\n if (List_Obj scalars = Cast(item)) {\n if (variables.size() == 1) {\n List_Obj var = scalars;\n // if (arglist) var = (*scalars)[0];\n env.set_local(variables[0], var);\n } else {\n for (size_t j = 0, K = variables.size(); j < K; ++j) {\n Expression_Obj res = j >= scalars->length()\n ? SASS_MEMORY_NEW(Null, expr->pstate())\n : (*scalars)[j]->perform(&eval);\n env.set_local(variables[j], res);\n }\n }\n } else {\n if (variables.size() > 0) {\n env.set_local(variables.at(0), item);\n for (size_t j = 1, K = variables.size(); j < K; ++j) {\n Expression_Obj res = SASS_MEMORY_NEW(Null, expr->pstate());\n env.set_local(variables[j], res);\n }\n }\n }\n append_block(body);\n }\n }\n call_stack.pop_back();\n env_stack.pop_back();\n return 0;\n }\n\n Statement_Ptr Expand::operator()(While_Ptr w)\n {\n Expression_Obj pred = w->predicate();\n Block_Ptr body = w->block();\n Env env(environment(), true);\n env_stack.push_back(&env);\n call_stack.push_back(w);\n Expression_Obj cond = pred->perform(&eval);\n while (!cond->is_false()) {\n append_block(body);\n cond = pred->perform(&eval);\n }\n call_stack.pop_back();\n env_stack.pop_back();\n return 0;\n }\n\n Statement_Ptr Expand::operator()(Return_Ptr r)\n {\n error(\"@return may only be used within a function\", r->pstate(), traces);\n return 0;\n }\n\n\n void Expand::expand_selector_list(Selector_Obj s, Selector_List_Obj extender) {\n\n if (Selector_List_Obj sl = Cast(s)) {\n for (Complex_Selector_Obj complex_selector : sl->elements()) {\n Complex_Selector_Obj tail = complex_selector;\n while (tail) {\n if (tail->head()) for (Simple_Selector_Obj header : tail->head()->elements()) {\n if (Cast(header) == NULL) continue; // skip all others\n std::string sel_str(complex_selector->to_string(ctx.c_options));\n error(\"Can't extend \" + sel_str + \": can't extend parent selectors\", header->pstate(), traces);\n }\n tail = tail->tail();\n }\n }\n }\n\n\n Selector_List_Obj contextualized = Cast(s->perform(&eval));\n if (contextualized == false) return;\n for (auto complex_sel : contextualized->elements()) {\n Complex_Selector_Obj c = complex_sel;\n if (!c->head() || c->tail()) {\n std::string sel_str(contextualized->to_string(ctx.c_options));\n error(\"Can't extend \" + sel_str + \": can't extend nested selectors\", c->pstate(), traces);\n }\n Compound_Selector_Obj target = c->head();\n if (contextualized->is_optional()) target->is_optional(true);\n for (size_t i = 0, L = extender->length(); i < L; ++i) {\n Complex_Selector_Obj sel = (*extender)[i];\n if (!(sel->head() && sel->head()->length() > 0 &&\n Cast((*sel->head())[0])))\n {\n Compound_Selector_Obj hh = SASS_MEMORY_NEW(Compound_Selector, (*extender)[i]->pstate());\n hh->media_block((*extender)[i]->media_block());\n Complex_Selector_Obj ssel = SASS_MEMORY_NEW(Complex_Selector, (*extender)[i]->pstate());\n ssel->media_block((*extender)[i]->media_block());\n if (sel->has_line_feed()) ssel->has_line_feed(true);\n Parent_Selector_Obj ps = SASS_MEMORY_NEW(Parent_Selector, (*extender)[i]->pstate());\n ps->media_block((*extender)[i]->media_block());\n hh->append(ps);\n ssel->tail(sel);\n ssel->head(hh);\n sel = ssel;\n }\n // if (c->has_line_feed()) sel->has_line_feed(true);\n ctx.subset_map.put(target, std::make_pair(sel, target));\n }\n }\n\n }\n\n Statement* Expand::operator()(Extension_Ptr e)\n {\n if (Selector_List_Ptr extender = selector()) {\n Selector_List_Ptr sl = e->selector();\n // abort on invalid selector\n if (sl == NULL) return NULL;\n if (Selector_Schema_Ptr schema = sl->schema()) {\n if (schema->has_real_parent_ref()) {\n // put root block on stack again (ignore parents)\n // selector schema must not connect in eval!\n block_stack.push_back(block_stack.at(1));\n sl = eval(sl->schema());\n block_stack.pop_back();\n } else {\n selector_stack.push_back(0);\n sl = eval(sl->schema());\n selector_stack.pop_back();\n }\n }\n for (Complex_Selector_Obj cs : sl->elements()) {\n if (!cs.isNull() && !cs->head().isNull()) {\n cs->head()->media_block(media_block_stack.back());\n }\n }\n selector_stack.push_back(0);\n expand_selector_list(sl, extender);\n selector_stack.pop_back();\n }\n return 0;\n }\n\n Statement_Ptr Expand::operator()(Definition_Ptr d)\n {\n Env* env = environment();\n Definition_Obj dd = SASS_MEMORY_COPY(d);\n env->local_frame()[d->name() +\n (d->type() == Definition::MIXIN ? \"[m]\" : \"[f]\")] = dd;\n\n if (d->type() == Definition::FUNCTION && (\n Prelexer::calc_fn_call(d->name().c_str()) ||\n d->name() == \"element\" ||\n d->name() == \"expression\" ||\n d->name() == \"url\"\n )) {\n deprecated(\n \"Naming a function \\\"\" + d->name() + \"\\\" is disallowed and will be an error in future versions of Sass.\",\n \"This name conflicts with an existing CSS function with special parse rules.\",\n false, d->pstate()\n );\n }\n\n // set the static link so we can have lexical scoping\n dd->environment(env);\n return 0;\n }\n\n Statement_Ptr Expand::operator()(Mixin_Call_Ptr c)\n {\n if (recursions > maxRecursion) {\n throw Exception::StackError(traces, *c);\n }\n\n recursions ++;\n\n Env* env = environment();\n std::string full_name(c->name() + \"[m]\");\n if (!env->has(full_name)) {\n error(\"no mixin named \" + c->name(), c->pstate(), traces);\n }\n Definition_Obj def = Cast((*env)[full_name]);\n Block_Obj body = def->block();\n Parameters_Obj params = def->parameters();\n\n if (c->block() && c->name() != \"@content\" && !body->has_content()) {\n error(\"Mixin \\\"\" + c->name() + \"\\\" does not accept a content block.\", c->pstate(), traces);\n }\n Expression_Obj rv = c->arguments()->perform(&eval);\n Arguments_Obj args = Cast(rv);\n std::string msg(\", in mixin `\" + c->name() + \"`\");\n traces.push_back(Backtrace(c->pstate(), msg));\n ctx.callee_stack.push_back({\n c->name().c_str(),\n c->pstate().path,\n c->pstate().line + 1,\n c->pstate().column + 1,\n SASS_CALLEE_MIXIN,\n { env }\n });\n\n Env new_env(def->environment());\n env_stack.push_back(&new_env);\n if (c->block()) {\n // represent mixin content blocks as thunks/closures\n Definition_Obj thunk = SASS_MEMORY_NEW(Definition,\n c->pstate(),\n \"@content\",\n SASS_MEMORY_NEW(Parameters, c->pstate()),\n c->block(),\n Definition::MIXIN);\n thunk->environment(env);\n new_env.local_frame()[\"@content[m]\"] = thunk;\n }\n\n bind(std::string(\"Mixin\"), c->name(), params, args, &ctx, &new_env, &eval);\n\n Block_Obj trace_block = SASS_MEMORY_NEW(Block, c->pstate());\n Trace_Obj trace = SASS_MEMORY_NEW(Trace, c->pstate(), c->name(), trace_block);\n\n env->set_global(\"is_in_mixin\", bool_true);\n if (Block_Ptr pr = block_stack.back()) {\n trace_block->is_root(pr->is_root());\n }\n block_stack.push_back(trace_block);\n for (auto bb : body->elements()) {\n if (Ruleset_Ptr r = Cast(bb)) {\n r->is_root(trace_block->is_root());\n }\n Statement_Obj ith = bb->perform(this);\n if (ith) trace->block()->append(ith);\n }\n block_stack.pop_back();\n env->del_global(\"is_in_mixin\");\n\n ctx.callee_stack.pop_back();\n env_stack.pop_back();\n traces.pop_back();\n\n recursions --;\n return trace.detach();\n }\n\n Statement_Ptr Expand::operator()(Content_Ptr c)\n {\n Env* env = environment();\n // convert @content directives into mixin calls to the underlying thunk\n if (!env->has(\"@content[m]\")) return 0;\n\n if (block_stack.back()->is_root()) {\n selector_stack.push_back(0);\n }\n\n Mixin_Call_Obj call = SASS_MEMORY_NEW(Mixin_Call,\n c->pstate(),\n \"@content\",\n SASS_MEMORY_NEW(Arguments, c->pstate()));\n\n Trace_Obj trace = Cast(call->perform(this));\n\n if (block_stack.back()->is_root()) {\n selector_stack.pop_back();\n }\n\n return trace.detach();\n }\n\n // produce an error if something is not implemented\n inline Statement_Ptr Expand::fallback_impl(AST_Node_Ptr n)\n {\n std::string err =std:: string(\"`Expand` doesn't handle \") + typeid(*n).name();\n String_Quoted_Obj msg = SASS_MEMORY_NEW(String_Quoted, ParserState(\"[WARN]\"), err);\n error(\"unknown internal error; please contact the LibSass maintainers\", n->pstate(), traces);\n return SASS_MEMORY_NEW(Warning, ParserState(\"[WARN]\"), msg);\n }\n\n // process and add to last block on stack\n inline void Expand::append_block(Block_Ptr b)\n {\n if (b->is_root()) call_stack.push_back(b);\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Ptr stm = b->at(i);\n Statement_Obj ith = stm->perform(this);\n if (ith) block_stack.back()->append(ith);\n }\n if (b->is_root()) call_stack.pop_back();\n }\n\n}\n" }, { "path": "libsass-build/expand.hpp", "content": "#ifndef SASS_EXPAND_H\n#define SASS_EXPAND_H\n\n#include \n\n#include \"ast.hpp\"\n#include \"eval.hpp\"\n#include \"operation.hpp\"\n#include \"environment.hpp\"\n\nnamespace Sass {\n\n class Listize;\n class Context;\n class Eval;\n struct Backtrace;\n\n class Expand : public Operation_CRTP {\n public:\n\n Env* environment();\n Selector_List_Obj selector();\n\n Context& ctx;\n Backtraces& traces;\n Eval eval;\n size_t recursions;\n bool in_keyframes;\n bool at_root_without_rule;\n bool old_at_root_without_rule;\n\n // it's easier to work with vectors\n std::vector env_stack;\n std::vector block_stack;\n std::vector call_stack;\n std::vector selector_stack;\n std::vector media_block_stack;\n\n Boolean_Obj bool_true;\n\n Statement_Ptr fallback_impl(AST_Node_Ptr n);\n\n private:\n void expand_selector_list(Selector_Obj, Selector_List_Obj extender);\n\n public:\n Expand(Context&, Env*, std::vector* stack = NULL);\n ~Expand() { }\n\n Block_Ptr operator()(Block_Ptr);\n Statement_Ptr operator()(Ruleset_Ptr);\n Statement_Ptr operator()(Media_Block_Ptr);\n Statement_Ptr operator()(Supports_Block_Ptr);\n Statement_Ptr operator()(At_Root_Block_Ptr);\n Statement_Ptr operator()(Directive_Ptr);\n Statement_Ptr operator()(Declaration_Ptr);\n Statement_Ptr operator()(Assignment_Ptr);\n Statement_Ptr operator()(Import_Ptr);\n Statement_Ptr operator()(Import_Stub_Ptr);\n Statement_Ptr operator()(Warning_Ptr);\n Statement_Ptr operator()(Error_Ptr);\n Statement_Ptr operator()(Debug_Ptr);\n Statement_Ptr operator()(Comment_Ptr);\n Statement_Ptr operator()(If_Ptr);\n Statement_Ptr operator()(For_Ptr);\n Statement_Ptr operator()(Each_Ptr);\n Statement_Ptr operator()(While_Ptr);\n Statement_Ptr operator()(Return_Ptr);\n Statement_Ptr operator()(Extension_Ptr);\n Statement_Ptr operator()(Definition_Ptr);\n Statement_Ptr operator()(Mixin_Call_Ptr);\n Statement_Ptr operator()(Content_Ptr);\n\n template \n Statement_Ptr fallback(U x) { return fallback_impl(x); }\n\n void append_block(Block_Ptr);\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/extend.cpp", "content": "#include \"sass.hpp\"\n#include \"extend.hpp\"\n#include \"context.hpp\"\n#include \"backtrace.hpp\"\n#include \"paths.hpp\"\n#include \"parser.hpp\"\n#include \"expand.hpp\"\n#include \"node.hpp\"\n#include \"sass_util.hpp\"\n#include \"remove_placeholders.hpp\"\n#include \"debug.hpp\"\n#include \n#include \n#include \n\n/*\n NOTES:\n\n - The print* functions print to cerr. This allows our testing frameworks (like sass-spec) to ignore the output, which\n is very helpful when debugging. The format of the output is mainly to wrap things in square brackets to match what\n ruby already outputs (to make comparisons easier).\n\n - For the direct porting effort, we're trying to port method-for-method until we get all the tests passing.\n Where applicable, I've tried to include the ruby code above the function for reference until all our tests pass.\n The ruby code isn't always directly portable, so I've tried to include any modified ruby code that was actually\n used for the porting.\n\n - DO NOT try to optimize yet. We get a tremendous benefit out of comparing the output of each stage of the extend to the ruby\n output at the same stage. This makes it much easier to determine where problems are. Try to keep as close to\n the ruby code as you can until we have all the sass-spec tests passing. Then, we should optimize. However, if you see\n something that could probably be optimized, let's not forget it. Add a // TODO: or // IMPROVEMENT: comment.\n\n - Coding conventions in this file (these may need to be changed before merging back into master)\n - Very basic hungarian notation:\n p prefix for pointers (pSelector)\n no prefix for value types and references (selector)\n - Use STL iterators where possible\n - prefer verbose naming over terse naming\n - use typedefs for STL container types for make maintenance easier\n\n - You may see a lot of comments that say \"// TODO: is this the correct combinator?\". See the comment referring to combinators\n in extendCompoundSelector for a more extensive explanation of my confusion. I think our divergence in data model from ruby\n sass causes this to be necessary.\n\n\n GLOBAL TODOS:\n\n - wrap the contents of the print functions in DEBUG preprocesser conditionals so they will be optimized away in non-debug mode.\n\n - consider making the extend* functions member functions to avoid passing around ctx and subset_map map around. This has the\n drawback that the implementation details of the operator are then exposed to the outside world, which is not ideal and\n can cause additional compile time dependencies.\n\n - mark the helper methods in this file static to given them compilation unit linkage.\n\n - implement parent directive matching\n\n - fix compilation warnings for unused Extend members if we really don't need those references anymore.\n */\n\n\nnamespace Sass {\n\n\n\n#ifdef DEBUG\n\n // TODO: move the ast specific ostream operators into ast.hpp/ast.cpp\n std::ostream& operator<<(std::ostream& os, const Complex_Selector::Combinator combinator) {\n switch (combinator) {\n case Complex_Selector::ANCESTOR_OF: os << \"\\\" \\\"\"; break;\n case Complex_Selector::PARENT_OF: os << \"\\\">\\\"\"; break;\n case Complex_Selector::PRECEDES: os << \"\\\"~\\\"\"; break;\n case Complex_Selector::ADJACENT_TO: os << \"\\\"+\\\"\"; break;\n case Complex_Selector::REFERENCE: os << \"\\\"/\\\"\"; break;\n }\n\n return os;\n }\n\n\n std::ostream& operator<<(std::ostream& os, Compound_Selector& compoundSelector) {\n for (size_t i = 0, L = compoundSelector.length(); i < L; ++i) {\n if (i > 0) os << \", \";\n os << compoundSelector[i]->to_string();\n }\n return os;\n }\n\n std::ostream& operator<<(std::ostream& os, Simple_Selector& simpleSelector) {\n os << simpleSelector.to_string();\n return os;\n }\n\n // Print a string representation of a Compound_Selector\n static void printSimpleSelector(Simple_Selector* pSimpleSelector, const char* message=NULL, bool newline=true) {\n\n if (message) {\n std::cerr << message;\n }\n\n if (pSimpleSelector) {\n std::cerr << \"[\" << *pSimpleSelector << \"]\";\n } else {\n std::cerr << \"NULL\";\n }\n\n if (newline) {\n std::cerr << std::endl;\n }\n }\n\n // Print a string representation of a Compound_Selector\n static void printCompoundSelector(Compound_Selector_Ptr pCompoundSelector, const char* message=NULL, bool newline=true) {\n\n if (message) {\n std::cerr << message;\n }\n\n if (pCompoundSelector) {\n std::cerr << \"[\" << *pCompoundSelector << \"]\";\n } else {\n std::cerr << \"NULL\";\n }\n\n if (newline) {\n std::cerr << std::endl;\n }\n }\n\n\n std::ostream& operator<<(std::ostream& os, Complex_Selector& complexSelector) {\n\n os << \"[\";\n Complex_Selector_Ptr pIter = &complexSelector;\n bool first = true;\n while (pIter) {\n if (pIter->combinator() != Complex_Selector::ANCESTOR_OF) {\n if (!first) {\n os << \", \";\n }\n first = false;\n os << pIter->combinator();\n }\n\n if (!first) {\n os << \", \";\n }\n first = false;\n\n if (pIter->head()) {\n os << pIter->head()->to_string();\n } else {\n os << \"NULL_HEAD\";\n }\n\n pIter = pIter->tail();\n }\n os << \"]\";\n\n return os;\n }\n\n\n // Print a string representation of a Complex_Selector\n static void printComplexSelector(Complex_Selector_Ptr pComplexSelector, const char* message=NULL, bool newline=true) {\n\n if (message) {\n std::cerr << message;\n }\n\n if (pComplexSelector) {\n std::cerr << *pComplexSelector;\n } else {\n std::cerr << \"NULL\";\n }\n\n if (newline) {\n std::cerr << std::endl;\n }\n }\n\n static void printSelsNewSeqPairCollection(SubSetMapLookups& collection, const char* message=NULL, bool newline=true) {\n\n if (message) {\n std::cerr << message;\n }\n bool first = true;\n std::cerr << \"[\";\n for(SubSetMapLookup& pair : collection) {\n if (first) {\n first = false;\n } else {\n std::cerr << \", \";\n }\n std::cerr << \"[\";\n Compound_Selector_Ptr pSels = pair.first;\n Complex_Selector_Ptr pNewSelector = pair.second;\n std::cerr << \"[\" << *pSels << \"], \";\n printComplexSelector(pNewSelector, NULL, false);\n }\n std::cerr << \"]\";\n\n if (newline) {\n std::cerr << std::endl;\n }\n }\n\n // Print a string representation of a ComplexSelectorSet\n static void printSourcesSet(ComplexSelectorSet& sources, const char* message=NULL, bool newline=true) {\n\n if (message) {\n std::cerr << message;\n }\n\n // Convert to a deque of strings so we can sort since order doesn't matter in a set. This should cut down on\n // the differences we see when debug printing.\n typedef std::deque SourceStrings;\n SourceStrings sourceStrings;\n for (ComplexSelectorSet::iterator iterator = sources.begin(), iteratorEnd = sources.end(); iterator != iteratorEnd; ++iterator) {\n Complex_Selector_Ptr pSource = *iterator;\n std::stringstream sstream;\n sstream << complexSelectorToNode(pSource);\n sourceStrings.push_back(sstream.str());\n }\n\n // Sort to get consistent output\n std::sort(sourceStrings.begin(), sourceStrings.end());\n\n std::cerr << \"ComplexSelectorSet[\";\n for (SourceStrings::iterator iterator = sourceStrings.begin(), iteratorEnd = sourceStrings.end(); iterator != iteratorEnd; ++iterator) {\n std::string source = *iterator;\n if (iterator != sourceStrings.begin()) {\n std::cerr << \", \";\n }\n std::cerr << source;\n }\n std::cerr << \"]\";\n\n if (newline) {\n std::cerr << std::endl;\n }\n }\n\n\n std::ostream& operator<<(std::ostream& os, SubSetMapPairs& entries) {\n os << \"SUBSET_MAP_ENTRIES[\";\n\n for (SubSetMapPairs::iterator iterator = entries.begin(), endIterator = entries.end(); iterator != endIterator; ++iterator) {\n Complex_Selector_Obj pExtComplexSelector = iterator->first; // The selector up to where the @extend is (ie, the thing to merge)\n Compound_Selector_Obj pExtCompoundSelector = iterator->second; // The stuff after the @extend\n\n if (iterator != entries.begin()) {\n os << \", \";\n }\n\n os << \"(\";\n\n if (pExtComplexSelector) {\n std::cerr << *pExtComplexSelector;\n } else {\n std::cerr << \"NULL\";\n }\n\n os << \" -> \";\n\n if (pExtCompoundSelector) {\n std::cerr << *pExtCompoundSelector;\n } else {\n std::cerr << \"NULL\";\n }\n\n os << \")\";\n\n }\n\n os << \"]\";\n\n return os;\n }\n#endif\n\n static bool parentSuperselector(Complex_Selector_Ptr pOne, Complex_Selector_Ptr pTwo) {\n // TODO: figure out a better way to create a Complex_Selector from scratch\n // TODO: There's got to be a better way. This got ugly quick...\n Element_Selector_Obj fakeParent = SASS_MEMORY_NEW(Element_Selector, ParserState(\"[FAKE]\"), \"temp\");\n Compound_Selector_Obj fakeHead = SASS_MEMORY_NEW(Compound_Selector, ParserState(\"[FAKE]\"), 1 /*size*/);\n fakeHead->elements().push_back(fakeParent);\n Complex_Selector_Obj fakeParentContainer = SASS_MEMORY_NEW(Complex_Selector, ParserState(\"[FAKE]\"), Complex_Selector::ANCESTOR_OF, fakeHead /*head*/, NULL /*tail*/);\n\n pOne->set_innermost(fakeParentContainer, Complex_Selector::ANCESTOR_OF);\n pTwo->set_innermost(fakeParentContainer, Complex_Selector::ANCESTOR_OF);\n\n bool isSuperselector = pOne->is_superselector_of(pTwo);\n\n pOne->clear_innermost();\n pTwo->clear_innermost();\n\n return isSuperselector;\n }\n\n void nodeToComplexSelectorDeque(const Node& node, ComplexSelectorDeque& out) {\n for (NodeDeque::iterator iter = node.collection()->begin(), iterEnd = node.collection()->end(); iter != iterEnd; iter++) {\n Node& child = *iter;\n out.push_back(nodeToComplexSelector(child));\n }\n }\n\n Node complexSelectorDequeToNode(const ComplexSelectorDeque& deque) {\n Node result = Node::createCollection();\n\n for (ComplexSelectorDeque::const_iterator iter = deque.begin(), iterEnd = deque.end(); iter != iterEnd; iter++) {\n Complex_Selector_Obj pChild = *iter;\n result.collection()->push_back(complexSelectorToNode(pChild));\n }\n\n return result;\n }\n\n class LcsCollectionComparator {\n public:\n LcsCollectionComparator() {}\n\n bool operator()(Complex_Selector_Obj pOne, Complex_Selector_Obj pTwo, Complex_Selector_Obj& pOut) const {\n /*\n This code is based on the following block from ruby sass' subweave\n do |s1, s2|\n next s1 if s1 == s2\n next unless s1.first.is_a?(SimpleSequence) && s2.first.is_a?(SimpleSequence)\n next s2 if parent_superselector?(s1, s2)\n next s1 if parent_superselector?(s2, s1)\n end\n */\n\n if (*pOne == *pTwo) {\n pOut = pOne;\n return true;\n }\n\n if (pOne->combinator() != Complex_Selector::ANCESTOR_OF || pTwo->combinator() != Complex_Selector::ANCESTOR_OF) {\n return false;\n }\n\n if (parentSuperselector(pOne, pTwo)) {\n pOut = pTwo;\n return true;\n }\n\n if (parentSuperselector(pTwo, pOne)) {\n pOut = pOne;\n return true;\n }\n\n return false;\n }\n };\n\n\n /*\n This is the equivalent of ruby's Sass::Util.lcs_backtrace.\n\n # Computes a single longest common subsequence for arrays x and y.\n # Algorithm from http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Reading_out_an_LCS\n */\n void lcs_backtrace(const LCSTable& c, ComplexSelectorDeque& x, ComplexSelectorDeque& y, int i, int j, const LcsCollectionComparator& comparator, ComplexSelectorDeque& out) {\n //DEBUG_PRINTLN(LCS, \"LCSBACK: X=\" << x << \" Y=\" << y << \" I=\" << i << \" J=\" << j)\n // TODO: make printComplexSelectorDeque and use DEBUG_EXEC AND DEBUG_PRINTLN HERE to get equivalent output\n\n if (i == 0 || j == 0) {\n DEBUG_PRINTLN(LCS, \"RETURNING EMPTY\")\n return;\n }\n\n\n Complex_Selector_Obj pCompareOut;\n if (comparator(x[i], y[j], pCompareOut)) {\n DEBUG_PRINTLN(LCS, \"RETURNING AFTER ELEM COMPARE\")\n lcs_backtrace(c, x, y, i - 1, j - 1, comparator, out);\n out.push_back(pCompareOut);\n return;\n }\n\n if (c[i][j - 1] > c[i - 1][j]) {\n DEBUG_PRINTLN(LCS, \"RETURNING AFTER TABLE COMPARE\")\n lcs_backtrace(c, x, y, i, j - 1, comparator, out);\n return;\n }\n\n DEBUG_PRINTLN(LCS, \"FINAL RETURN\")\n lcs_backtrace(c, x, y, i - 1, j, comparator, out);\n return;\n }\n\n /*\n This is the equivalent of ruby's Sass::Util.lcs_table.\n\n # Calculates the memoization table for the Least Common Subsequence algorithm.\n # Algorithm from http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Computing_the_length_of_the_LCS\n */\n void lcs_table(const ComplexSelectorDeque& x, const ComplexSelectorDeque& y, const LcsCollectionComparator& comparator, LCSTable& out) {\n //DEBUG_PRINTLN(LCS, \"LCSTABLE: X=\" << x << \" Y=\" << y)\n // TODO: make printComplexSelectorDeque and use DEBUG_EXEC AND DEBUG_PRINTLN HERE to get equivalent output\n\n LCSTable c(x.size(), std::vector(y.size()));\n\n // These shouldn't be necessary since the vector will be initialized to 0 already.\n // x.size.times {|i| c[i][0] = 0}\n // y.size.times {|j| c[0][j] = 0}\n\n for (size_t i = 1; i < x.size(); i++) {\n for (size_t j = 1; j < y.size(); j++) {\n Complex_Selector_Obj pCompareOut;\n\n if (comparator(x[i], y[j], pCompareOut)) {\n c[i][j] = c[i - 1][j - 1] + 1;\n } else {\n c[i][j] = std::max(c[i][j - 1], c[i - 1][j]);\n }\n }\n }\n\n out = c;\n }\n\n /*\n This is the equivalent of ruby's Sass::Util.lcs.\n\n # Computes a single longest common subsequence for `x` and `y`.\n # If there are more than one longest common subsequences,\n # the one returned is that which starts first in `x`.\n\n # @param x [NodeCollection]\n # @param y [NodeCollection]\n # @comparator An equality check between elements of `x` and `y`.\n # @return [NodeCollection] The LCS\n\n http://en.wikipedia.org/wiki/Longest_common_subsequence_problem\n */\n void lcs(ComplexSelectorDeque& x, ComplexSelectorDeque& y, const LcsCollectionComparator& comparator, ComplexSelectorDeque& out) {\n //DEBUG_PRINTLN(LCS, \"LCS: X=\" << x << \" Y=\" << y)\n // TODO: make printComplexSelectorDeque and use DEBUG_EXEC AND DEBUG_PRINTLN HERE to get equivalent output\n\n x.push_front(NULL);\n y.push_front(NULL);\n\n LCSTable table;\n lcs_table(x, y, comparator, table);\n\n return lcs_backtrace(table, x, y, static_cast(x.size()) - 1, static_cast(y.size()) - 1, comparator, out);\n }\n\n\n /*\n This is the equivalent of ruby's Sequence.trim.\n\n The following is the modified version of the ruby code that was more portable to C++. You\n should be able to drop it into ruby 3.2.19 and get the same results from ruby sass.\n\n # Avoid truly horrific quadratic behavior. TODO: I think there\n # may be a way to get perfect trimming without going quadratic.\n return seqses if seqses.size > 100\n\n # Keep the results in a separate array so we can be sure we aren't\n # comparing against an already-trimmed selector. This ensures that two\n # identical selectors don't mutually trim one another.\n result = seqses.dup\n\n # This is n^2 on the sequences, but only comparing between\n # separate sequences should limit the quadratic behavior.\n seqses.each_with_index do |seqs1, i|\n tempResult = []\n\n for seq1 in seqs1 do\n max_spec = 0\n for seq in _sources(seq1) do\n max_spec = [max_spec, seq.specificity].max\n end\n\n\n isMoreSpecificOuter = false\n for seqs2 in result do\n if seqs1.equal?(seqs2) then\n next\n end\n\n # Second Law of Extend: the specificity of a generated selector\n # should never be less than the specificity of the extending\n # selector.\n #\n # See https://github.com/nex3/sass/issues/324.\n isMoreSpecificInner = false\n for seq2 in seqs2 do\n isMoreSpecificInner = _specificity(seq2) >= max_spec && _superselector?(seq2, seq1)\n if isMoreSpecificInner then\n break\n end\n end\n\n if isMoreSpecificInner then\n isMoreSpecificOuter = true\n break\n end\n end\n\n if !isMoreSpecificOuter then\n tempResult.push(seq1)\n end\n end\n\n result[i] = tempResult\n\n end\n\n result\n */\n /*\n - IMPROVEMENT: We could probably work directly in the output trimmed deque.\n */\n Node Extend::trim(Node& seqses, bool isReplace) {\n // See the comments in the above ruby code before embarking on understanding this function.\n\n // Avoid poor performance in extreme cases.\n if (seqses.collection()->size() > 100) {\n return seqses;\n }\n\n\n DEBUG_PRINTLN(TRIM, \"TRIM: \" << seqses)\n\n\n Node result = Node::createCollection();\n result.plus(seqses);\n\n DEBUG_PRINTLN(TRIM, \"RESULT INITIAL: \" << result)\n\n // Normally we use the standard STL iterators, but in this case, we need to access the result collection by index since we're\n // iterating the input collection, computing a value, and then setting the result in the output collection. We have to keep track\n // of the index manually.\n int toTrimIndex = 0;\n\n for (NodeDeque::iterator seqsesIter = seqses.collection()->begin(), seqsesIterEnd = seqses.collection()->end(); seqsesIter != seqsesIterEnd; ++seqsesIter) {\n Node& seqs1 = *seqsesIter;\n\n DEBUG_PRINTLN(TRIM, \"SEQS1: \" << seqs1 << \" \" << toTrimIndex)\n\n Node tempResult = Node::createCollection();\n tempResult.got_line_feed = seqs1.got_line_feed;\n\n for (NodeDeque::iterator seqs1Iter = seqs1.collection()->begin(), seqs1EndIter = seqs1.collection()->end(); seqs1Iter != seqs1EndIter; ++seqs1Iter) {\n Node& seq1 = *seqs1Iter;\n\n Complex_Selector_Obj pSeq1 = nodeToComplexSelector(seq1);\n\n // Compute the maximum specificity. This requires looking at the \"sources\" of the sequence. See SimpleSequence.sources in the ruby code\n // for a good description of sources.\n //\n // TODO: I'm pretty sure there's a bug in the sources code. It was implemented for sass-spec's 182_test_nested_extend_loop test.\n // While the test passes, I compared the state of each trim call to verify correctness. The last trim call had incorrect sources. We\n // had an extra source that the ruby version did not have. Without a failing test case, this is going to be extra hard to find. My\n // best guess at this point is that we're cloning an object somewhere and maintaining the sources when we shouldn't be. This is purely\n // a guess though.\n unsigned long maxSpecificity = isReplace ? pSeq1->specificity() : 0;\n ComplexSelectorSet sources = pSeq1->sources();\n\n DEBUG_PRINTLN(TRIM, \"TRIM SEQ1: \" << seq1)\n DEBUG_EXEC(TRIM, printSourcesSet(sources, \"TRIM SOURCES: \"))\n\n for (ComplexSelectorSet::iterator sourcesSetIterator = sources.begin(), sourcesSetIteratorEnd = sources.end(); sourcesSetIterator != sourcesSetIteratorEnd; ++sourcesSetIterator) {\n const Complex_Selector_Obj& pCurrentSelector = *sourcesSetIterator;\n maxSpecificity = std::max(maxSpecificity, pCurrentSelector->specificity());\n }\n\n DEBUG_PRINTLN(TRIM, \"MAX SPECIFICITY: \" << maxSpecificity)\n\n bool isMoreSpecificOuter = false;\n\n int resultIndex = 0;\n\n for (NodeDeque::iterator resultIter = result.collection()->begin(), resultIterEnd = result.collection()->end(); resultIter != resultIterEnd; ++resultIter) {\n Node& seqs2 = *resultIter;\n\n DEBUG_PRINTLN(TRIM, \"SEQS1: \" << seqs1)\n DEBUG_PRINTLN(TRIM, \"SEQS2: \" << seqs2)\n\n // Do not compare the same sequence to itself. The ruby call we're trying to\n // emulate is: seqs1.equal?(seqs2). equal? is an object comparison, not an equivalency comparision.\n // Since we have the same pointers in seqes and results, we can do a pointer comparision. seqs1 is\n // derived from seqses and seqs2 is derived from result.\n if (seqs1.collection() == seqs2.collection()) {\n DEBUG_PRINTLN(TRIM, \"CONTINUE\")\n continue;\n }\n\n bool isMoreSpecificInner = false;\n\n for (NodeDeque::iterator seqs2Iter = seqs2.collection()->begin(), seqs2IterEnd = seqs2.collection()->end(); seqs2Iter != seqs2IterEnd; ++seqs2Iter) {\n Node& seq2 = *seqs2Iter;\n\n Complex_Selector_Obj pSeq2 = nodeToComplexSelector(seq2);\n\n DEBUG_PRINTLN(TRIM, \"SEQ2 SPEC: \" << pSeq2->specificity())\n DEBUG_PRINTLN(TRIM, \"IS SPEC: \" << pSeq2->specificity() << \" >= \" << maxSpecificity << \" \" << (pSeq2->specificity() >= maxSpecificity ? \"true\" : \"false\"))\n DEBUG_PRINTLN(TRIM, \"IS SUPER: \" << (pSeq2->is_superselector_of(pSeq1) ? \"true\" : \"false\"))\n\n isMoreSpecificInner = pSeq2->specificity() >= maxSpecificity && pSeq2->is_superselector_of(pSeq1);\n\n if (isMoreSpecificInner) {\n DEBUG_PRINTLN(TRIM, \"FOUND MORE SPECIFIC\")\n break;\n }\n }\n\n // If we found something more specific, we're done. Let the outer loop know and stop iterating.\n if (isMoreSpecificInner) {\n isMoreSpecificOuter = true;\n break;\n }\n\n resultIndex++;\n }\n\n if (!isMoreSpecificOuter) {\n DEBUG_PRINTLN(TRIM, \"PUSHING: \" << seq1)\n tempResult.collection()->push_back(seq1);\n }\n\n }\n\n DEBUG_PRINTLN(TRIM, \"RESULT BEFORE ASSIGN: \" << result)\n DEBUG_PRINTLN(TRIM, \"TEMP RESULT: \" << toTrimIndex << \" \" << tempResult)\n (*result.collection())[toTrimIndex] = tempResult;\n\n toTrimIndex++;\n\n DEBUG_PRINTLN(TRIM, \"RESULT: \" << result)\n }\n\n return result;\n }\n\n\n\n static bool parentSuperselector(const Node& one, const Node& two) {\n // TODO: figure out a better way to create a Complex_Selector from scratch\n // TODO: There's got to be a better way. This got ugly quick...\n Element_Selector_Obj fakeParent = SASS_MEMORY_NEW(Element_Selector, ParserState(\"[FAKE]\"), \"temp\");\n Compound_Selector_Obj fakeHead = SASS_MEMORY_NEW(Compound_Selector, ParserState(\"[FAKE]\"), 1 /*size*/);\n fakeHead->elements().push_back(fakeParent);\n Complex_Selector_Obj fakeParentContainer = SASS_MEMORY_NEW(Complex_Selector, ParserState(\"[FAKE]\"), Complex_Selector::ANCESTOR_OF, fakeHead /*head*/, NULL /*tail*/);\n\n Complex_Selector_Obj pOneWithFakeParent = nodeToComplexSelector(one);\n pOneWithFakeParent->set_innermost(fakeParentContainer, Complex_Selector::ANCESTOR_OF);\n Complex_Selector_Obj pTwoWithFakeParent = nodeToComplexSelector(two);\n pTwoWithFakeParent->set_innermost(fakeParentContainer, Complex_Selector::ANCESTOR_OF);\n\n return pOneWithFakeParent->is_superselector_of(pTwoWithFakeParent);\n }\n\n\n class ParentSuperselectorChunker {\n public:\n ParentSuperselectorChunker(Node& lcs) : mLcs(lcs) {}\n Node& mLcs;\n\n bool operator()(const Node& seq) const {\n // {|s| parent_superselector?(s.first, lcs.first)}\n if (seq.collection()->size() == 0) return false;\n return parentSuperselector(seq.collection()->front(), mLcs.collection()->front());\n }\n };\n\n class SubweaveEmptyChunker {\n public:\n bool operator()(const Node& seq) const {\n // {|s| s.empty?}\n\n return seq.collection()->empty();\n }\n };\n\n /*\n # Takes initial subsequences of `seq1` and `seq2` and returns all\n # orderings of those subsequences. The initial subsequences are determined\n # by a block.\n #\n # Destructively removes the initial subsequences of `seq1` and `seq2`.\n #\n # For example, given `(A B C | D E)` and `(1 2 | 3 4 5)` (with `|`\n # denoting the boundary of the initial subsequence), this would return\n # `[(A B C 1 2), (1 2 A B C)]`. The sequences would then be `(D E)` and\n # `(3 4 5)`.\n #\n # @param seq1 [Array]\n # @param seq2 [Array]\n # @yield [a] Used to determine when to cut off the initial subsequences.\n # Called repeatedly for each sequence until it returns true.\n # @yieldparam a [Array] A final subsequence of one input sequence after\n # cutting off some initial subsequence.\n # @yieldreturn [Boolean] Whether or not to cut off the initial subsequence\n # here.\n # @return [Array] All possible orderings of the initial subsequences.\n def chunks(seq1, seq2)\n chunk1 = []\n chunk1 << seq1.shift until yield seq1\n chunk2 = []\n chunk2 << seq2.shift until yield seq2\n return [] if chunk1.empty? && chunk2.empty?\n return [chunk2] if chunk1.empty?\n return [chunk1] if chunk2.empty?\n [chunk1 + chunk2, chunk2 + chunk1]\n end\n */\n template\n static Node chunks(Node& seq1, Node& seq2, const ChunkerType& chunker) {\n Node chunk1 = Node::createCollection();\n while (seq1.collection()->size() && !chunker(seq1)) {\n chunk1.collection()->push_back(seq1.collection()->front());\n seq1.collection()->pop_front();\n }\n\n Node chunk2 = Node::createCollection();\n while (!seq2.collection()->empty() && !chunker(seq2)) {\n chunk2.collection()->push_back(seq2.collection()->front());\n seq2.collection()->pop_front();\n }\n\n if (chunk1.collection()->empty() && chunk2.collection()->empty()) {\n DEBUG_PRINTLN(CHUNKS, \"RETURNING BOTH EMPTY\")\n return Node::createCollection();\n }\n\n if (chunk1.collection()->empty()) {\n Node chunk2Wrapper = Node::createCollection();\n chunk2Wrapper.collection()->push_back(chunk2);\n DEBUG_PRINTLN(CHUNKS, \"RETURNING ONE EMPTY\")\n return chunk2Wrapper;\n }\n\n if (chunk2.collection()->empty()) {\n Node chunk1Wrapper = Node::createCollection();\n chunk1Wrapper.collection()->push_back(chunk1);\n DEBUG_PRINTLN(CHUNKS, \"RETURNING TWO EMPTY\")\n return chunk1Wrapper;\n }\n\n Node perms = Node::createCollection();\n\n Node firstPermutation = Node::createCollection();\n firstPermutation.collection()->insert(firstPermutation.collection()->end(), chunk1.collection()->begin(), chunk1.collection()->end());\n firstPermutation.collection()->insert(firstPermutation.collection()->end(), chunk2.collection()->begin(), chunk2.collection()->end());\n perms.collection()->push_back(firstPermutation);\n\n Node secondPermutation = Node::createCollection();\n secondPermutation.collection()->insert(secondPermutation.collection()->end(), chunk2.collection()->begin(), chunk2.collection()->end());\n secondPermutation.collection()->insert(secondPermutation.collection()->end(), chunk1.collection()->begin(), chunk1.collection()->end());\n perms.collection()->push_back(secondPermutation);\n\n DEBUG_PRINTLN(CHUNKS, \"RETURNING PERM\")\n\n return perms;\n }\n\n\n static Node groupSelectors(Node& seq) {\n Node newSeq = Node::createCollection();\n\n Node tail = Node::createCollection();\n tail.plus(seq);\n\n while (!tail.collection()->empty()) {\n Node head = Node::createCollection();\n\n do {\n head.collection()->push_back(tail.collection()->front());\n tail.collection()->pop_front();\n } while (!tail.collection()->empty() && (head.collection()->back().isCombinator() || tail.collection()->front().isCombinator()));\n\n newSeq.collection()->push_back(head);\n }\n\n return newSeq;\n }\n\n\n static void getAndRemoveInitialOps(Node& seq, Node& ops) {\n NodeDeque& seqCollection = *(seq.collection());\n NodeDeque& opsCollection = *(ops.collection());\n\n while (seqCollection.size() > 0 && seqCollection.front().isCombinator()) {\n opsCollection.push_back(seqCollection.front());\n seqCollection.pop_front();\n }\n }\n\n\n static void getAndRemoveFinalOps(Node& seq, Node& ops) {\n NodeDeque& seqCollection = *(seq.collection());\n NodeDeque& opsCollection = *(ops.collection());\n\n while (seqCollection.size() > 0 && seqCollection.back().isCombinator()) {\n opsCollection.push_back(seqCollection.back()); // Purposefully reversed to match ruby code\n seqCollection.pop_back();\n }\n }\n\n\n /*\n def merge_initial_ops(seq1, seq2)\n ops1, ops2 = [], []\n ops1 << seq1.shift while seq1.first.is_a?(String)\n ops2 << seq2.shift while seq2.first.is_a?(String)\n\n newline = false\n newline ||= !!ops1.shift if ops1.first == \"\\n\"\n newline ||= !!ops2.shift if ops2.first == \"\\n\"\n\n # If neither sequence is a subsequence of the other, they cannot be\n # merged successfully\n lcs = Sass::Util.lcs(ops1, ops2)\n return unless lcs == ops1 || lcs == ops2\n return (newline ? [\"\\n\"] : []) + (ops1.size > ops2.size ? ops1 : ops2)\n end\n */\n static Node mergeInitialOps(Node& seq1, Node& seq2) {\n Node ops1 = Node::createCollection();\n Node ops2 = Node::createCollection();\n\n getAndRemoveInitialOps(seq1, ops1);\n getAndRemoveInitialOps(seq2, ops2);\n\n // TODO: Do we have this information available to us?\n // newline = false\n // newline ||= !!ops1.shift if ops1.first == \"\\n\"\n // newline ||= !!ops2.shift if ops2.first == \"\\n\"\n\n // If neither sequence is a subsequence of the other, they cannot be merged successfully\n DefaultLcsComparator lcsDefaultComparator;\n Node opsLcs = lcs(ops1, ops2, lcsDefaultComparator);\n\n if (!(opsLcs == ops1 || opsLcs == ops2)) {\n return Node::createNil();\n }\n\n // TODO: more newline logic\n // return (newline ? [\"\\n\"] : []) + (ops1.size > ops2.size ? ops1 : ops2)\n\n return (ops1.collection()->size() > ops2.collection()->size() ? ops1 : ops2);\n }\n\n\n /*\n def merge_final_ops(seq1, seq2, res = [])\n\n\n # This code looks complicated, but it's actually just a bunch of special\n # cases for interactions between different combinators.\n op1, op2 = ops1.first, ops2.first\n if op1 && op2\n sel1 = seq1.pop\n sel2 = seq2.pop\n if op1 == '~' && op2 == '~'\n if sel1.superselector?(sel2)\n res.unshift sel2, '~'\n elsif sel2.superselector?(sel1)\n res.unshift sel1, '~'\n else\n merged = sel1.unify(sel2.members, sel2.subject?)\n res.unshift [\n [sel1, '~', sel2, '~'],\n [sel2, '~', sel1, '~'],\n ([merged, '~'] if merged)\n ].compact\n end\n elsif (op1 == '~' && op2 == '+') || (op1 == '+' && op2 == '~')\n if op1 == '~'\n tilde_sel, plus_sel = sel1, sel2\n else\n tilde_sel, plus_sel = sel2, sel1\n end\n\n if tilde_sel.superselector?(plus_sel)\n res.unshift plus_sel, '+'\n else\n merged = plus_sel.unify(tilde_sel.members, tilde_sel.subject?)\n res.unshift [\n [tilde_sel, '~', plus_sel, '+'],\n ([merged, '+'] if merged)\n ].compact\n end\n elsif op1 == '>' && %w[~ +].include?(op2)\n res.unshift sel2, op2\n seq1.push sel1, op1\n elsif op2 == '>' && %w[~ +].include?(op1)\n res.unshift sel1, op1\n seq2.push sel2, op2\n elsif op1 == op2\n return unless merged = sel1.unify(sel2.members, sel2.subject?)\n res.unshift merged, op1\n else\n # Unknown selector combinators can't be unified\n return\n end\n return merge_final_ops(seq1, seq2, res)\n elsif op1\n seq2.pop if op1 == '>' && seq2.last && seq2.last.superselector?(seq1.last)\n res.unshift seq1.pop, op1\n return merge_final_ops(seq1, seq2, res)\n else # op2\n seq1.pop if op2 == '>' && seq1.last && seq1.last.superselector?(seq2.last)\n res.unshift seq2.pop, op2\n return merge_final_ops(seq1, seq2, res)\n end\n end\n */\n static Node mergeFinalOps(Node& seq1, Node& seq2, Node& res) {\n\n Node ops1 = Node::createCollection();\n Node ops2 = Node::createCollection();\n\n getAndRemoveFinalOps(seq1, ops1);\n getAndRemoveFinalOps(seq2, ops2);\n\n // TODO: do we have newlines to remove?\n // ops1.reject! {|o| o == \"\\n\"}\n // ops2.reject! {|o| o == \"\\n\"}\n\n if (ops1.collection()->empty() && ops2.collection()->empty()) {\n return res;\n }\n\n if (ops1.collection()->size() > 1 || ops2.collection()->size() > 1) {\n DefaultLcsComparator lcsDefaultComparator;\n Node opsLcs = lcs(ops1, ops2, lcsDefaultComparator);\n\n // If there are multiple operators, something hacky's going on. If one is a supersequence of the other, use that, otherwise give up.\n\n if (!(opsLcs == ops1 || opsLcs == ops2)) {\n return Node::createNil();\n }\n\n if (ops1.collection()->size() > ops2.collection()->size()) {\n res.collection()->insert(res.collection()->begin(), ops1.collection()->rbegin(), ops1.collection()->rend());\n } else {\n res.collection()->insert(res.collection()->begin(), ops2.collection()->rbegin(), ops2.collection()->rend());\n }\n\n return res;\n }\n\n if (!ops1.collection()->empty() && !ops2.collection()->empty()) {\n\n Node op1 = ops1.collection()->front();\n Node op2 = ops2.collection()->front();\n\n Node sel1 = seq1.collection()->back();\n seq1.collection()->pop_back();\n\n Node sel2 = seq2.collection()->back();\n seq2.collection()->pop_back();\n\n if (op1.combinator() == Complex_Selector::PRECEDES && op2.combinator() == Complex_Selector::PRECEDES) {\n\n if (sel1.selector()->is_superselector_of(sel2.selector())) {\n\n res.collection()->push_front(op1 /*PRECEDES - could have been op2 as well*/);\n res.collection()->push_front(sel2);\n\n } else if (sel2.selector()->is_superselector_of(sel1.selector())) {\n\n res.collection()->push_front(op1 /*PRECEDES - could have been op2 as well*/);\n res.collection()->push_front(sel1);\n\n } else {\n\n DEBUG_PRINTLN(ALL, \"sel1: \" << sel1)\n DEBUG_PRINTLN(ALL, \"sel2: \" << sel2)\n\n Complex_Selector_Obj pMergedWrapper = SASS_MEMORY_CLONE(sel1.selector()); // Clone the Complex_Selector to get back to something we can transform to a node once we replace the head with the unification result\n // TODO: does subject matter? Ruby: return unless merged = sel1.unify(sel2.members, sel2.subject?)\n Compound_Selector_Ptr pMerged = sel1.selector()->head()->unify_with(sel2.selector()->head());\n pMergedWrapper->head(pMerged);\n\n DEBUG_EXEC(ALL, printCompoundSelector(pMerged, \"MERGED: \"))\n\n Node newRes = Node::createCollection();\n\n Node firstPerm = Node::createCollection();\n firstPerm.collection()->push_back(sel1);\n firstPerm.collection()->push_back(Node::createCombinator(Complex_Selector::PRECEDES));\n firstPerm.collection()->push_back(sel2);\n firstPerm.collection()->push_back(Node::createCombinator(Complex_Selector::PRECEDES));\n newRes.collection()->push_back(firstPerm);\n\n Node secondPerm = Node::createCollection();\n secondPerm.collection()->push_back(sel2);\n secondPerm.collection()->push_back(Node::createCombinator(Complex_Selector::PRECEDES));\n secondPerm.collection()->push_back(sel1);\n secondPerm.collection()->push_back(Node::createCombinator(Complex_Selector::PRECEDES));\n newRes.collection()->push_back(secondPerm);\n\n if (pMerged) {\n Node mergedPerm = Node::createCollection();\n mergedPerm.collection()->push_back(Node::createSelector(pMergedWrapper));\n mergedPerm.collection()->push_back(Node::createCombinator(Complex_Selector::PRECEDES));\n newRes.collection()->push_back(mergedPerm);\n }\n\n res.collection()->push_front(newRes);\n\n DEBUG_PRINTLN(ALL, \"RESULT: \" << res)\n\n }\n\n } else if (((op1.combinator() == Complex_Selector::PRECEDES && op2.combinator() == Complex_Selector::ADJACENT_TO)) || ((op1.combinator() == Complex_Selector::ADJACENT_TO && op2.combinator() == Complex_Selector::PRECEDES))) {\n\n Node tildeSel = sel1;\n Node plusSel = sel2;\n Node plusOp = op2;\n if (op1.combinator() != Complex_Selector::PRECEDES) {\n tildeSel = sel2;\n plusSel = sel1;\n plusOp = op1;\n }\n\n if (tildeSel.selector()->is_superselector_of(plusSel.selector())) {\n\n res.collection()->push_front(plusOp);\n res.collection()->push_front(plusSel);\n\n } else {\n\n DEBUG_PRINTLN(ALL, \"PLUS SEL: \" << plusSel)\n DEBUG_PRINTLN(ALL, \"TILDE SEL: \" << tildeSel)\n\n Complex_Selector_Obj pMergedWrapper = SASS_MEMORY_CLONE(plusSel.selector()); // Clone the Complex_Selector to get back to something we can transform to a node once we replace the head with the unification result\n // TODO: does subject matter? Ruby: merged = plus_sel.unify(tilde_sel.members, tilde_sel.subject?)\n Compound_Selector_Ptr pMerged = plusSel.selector()->head()->unify_with(tildeSel.selector()->head());\n pMergedWrapper->head(pMerged);\n\n DEBUG_EXEC(ALL, printCompoundSelector(pMerged, \"MERGED: \"))\n\n Node newRes = Node::createCollection();\n\n Node firstPerm = Node::createCollection();\n firstPerm.collection()->push_back(tildeSel);\n firstPerm.collection()->push_back(Node::createCombinator(Complex_Selector::PRECEDES));\n firstPerm.collection()->push_back(plusSel);\n firstPerm.collection()->push_back(Node::createCombinator(Complex_Selector::ADJACENT_TO));\n newRes.collection()->push_back(firstPerm);\n\n if (pMerged) {\n Node mergedPerm = Node::createCollection();\n mergedPerm.collection()->push_back(Node::createSelector(pMergedWrapper));\n mergedPerm.collection()->push_back(Node::createCombinator(Complex_Selector::ADJACENT_TO));\n newRes.collection()->push_back(mergedPerm);\n }\n\n res.collection()->push_front(newRes);\n\n DEBUG_PRINTLN(ALL, \"RESULT: \" << res)\n\n }\n } else if (op1.combinator() == Complex_Selector::PARENT_OF && (op2.combinator() == Complex_Selector::PRECEDES || op2.combinator() == Complex_Selector::ADJACENT_TO)) {\n\n res.collection()->push_front(op2);\n res.collection()->push_front(sel2);\n\n seq1.collection()->push_back(sel1);\n seq1.collection()->push_back(op1);\n\n } else if (op2.combinator() == Complex_Selector::PARENT_OF && (op1.combinator() == Complex_Selector::PRECEDES || op1.combinator() == Complex_Selector::ADJACENT_TO)) {\n\n res.collection()->push_front(op1);\n res.collection()->push_front(sel1);\n\n seq2.collection()->push_back(sel2);\n seq2.collection()->push_back(op2);\n\n } else if (op1.combinator() == op2.combinator()) {\n\n DEBUG_PRINTLN(ALL, \"sel1: \" << sel1)\n DEBUG_PRINTLN(ALL, \"sel2: \" << sel2)\n\n Complex_Selector_Obj pMergedWrapper = SASS_MEMORY_CLONE(sel1.selector()); // Clone the Complex_Selector to get back to something we can transform to a node once we replace the head with the unification result\n // TODO: does subject matter? Ruby: return unless merged = sel1.unify(sel2.members, sel2.subject?)\n Compound_Selector_Ptr pMerged = sel1.selector()->head()->unify_with(sel2.selector()->head());\n pMergedWrapper->head(pMerged);\n\n DEBUG_EXEC(ALL, printCompoundSelector(pMerged, \"MERGED: \"))\n\n if (!pMerged) {\n return Node::createNil();\n }\n\n res.collection()->push_front(op1);\n res.collection()->push_front(Node::createSelector(pMergedWrapper));\n\n DEBUG_PRINTLN(ALL, \"RESULT: \" << res)\n\n } else {\n return Node::createNil();\n }\n\n return mergeFinalOps(seq1, seq2, res);\n\n } else if (!ops1.collection()->empty()) {\n\n Node op1 = ops1.collection()->front();\n\n if (op1.combinator() == Complex_Selector::PARENT_OF && !seq2.collection()->empty() && seq2.collection()->back().selector()->is_superselector_of(seq1.collection()->back().selector())) {\n seq2.collection()->pop_back();\n }\n\n // TODO: consider unshift(NodeCollection, Node)\n res.collection()->push_front(op1);\n res.collection()->push_front(seq1.collection()->back());\n seq1.collection()->pop_back();\n\n return mergeFinalOps(seq1, seq2, res);\n\n } else { // !ops2.collection()->empty()\n\n Node op2 = ops2.collection()->front();\n\n if (op2.combinator() == Complex_Selector::PARENT_OF && !seq1.collection()->empty() && seq1.collection()->back().selector()->is_superselector_of(seq2.collection()->back().selector())) {\n seq1.collection()->pop_back();\n }\n\n res.collection()->push_front(op2);\n res.collection()->push_front(seq2.collection()->back());\n seq2.collection()->pop_back();\n\n return mergeFinalOps(seq1, seq2, res);\n\n }\n\n }\n\n\n /*\n This is the equivalent of ruby's Sequence.subweave.\n\n Here is the original subweave code for reference during porting.\n\n def subweave(seq1, seq2)\n return [seq2] if seq1.empty?\n return [seq1] if seq2.empty?\n\n seq1, seq2 = seq1.dup, seq2.dup\n return unless init = merge_initial_ops(seq1, seq2)\n return unless fin = merge_final_ops(seq1, seq2)\n seq1 = group_selectors(seq1)\n seq2 = group_selectors(seq2)\n lcs = Sass::Util.lcs(seq2, seq1) do |s1, s2|\n next s1 if s1 == s2\n next unless s1.first.is_a?(SimpleSequence) && s2.first.is_a?(SimpleSequence)\n next s2 if parent_superselector?(s1, s2)\n next s1 if parent_superselector?(s2, s1)\n end\n\n diff = [[init]]\n until lcs.empty?\n diff << chunks(seq1, seq2) {|s| parent_superselector?(s.first, lcs.first)} << [lcs.shift]\n seq1.shift\n seq2.shift\n end\n diff << chunks(seq1, seq2) {|s| s.empty?}\n diff += fin.map {|sel| sel.is_a?(Array) ? sel : [sel]}\n diff.reject! {|c| c.empty?}\n\n result = Sass::Util.paths(diff).map {|p| p.flatten}.reject {|p| path_has_two_subjects?(p)}\n\n result\n end\n */\n Node subweave(Node& one, Node& two) {\n // Check for the simple cases\n if (one.collection()->size() == 0) {\n Node out = Node::createCollection();\n out.collection()->push_back(two);\n return out;\n }\n if (two.collection()->size() == 0) {\n Node out = Node::createCollection();\n out.collection()->push_back(one);\n return out;\n }\n\n Node seq1 = Node::createCollection();\n seq1.plus(one);\n Node seq2 = Node::createCollection();\n seq2.plus(two);\n\n DEBUG_PRINTLN(SUBWEAVE, \"SUBWEAVE ONE: \" << seq1)\n DEBUG_PRINTLN(SUBWEAVE, \"SUBWEAVE TWO: \" << seq2)\n\n Node init = mergeInitialOps(seq1, seq2);\n if (init.isNil()) {\n return Node::createNil();\n }\n\n DEBUG_PRINTLN(SUBWEAVE, \"INIT: \" << init)\n\n Node res = Node::createCollection();\n Node fin = mergeFinalOps(seq1, seq2, res);\n if (fin.isNil()) {\n return Node::createNil();\n }\n\n DEBUG_PRINTLN(SUBWEAVE, \"FIN: \" << fin)\n\n\n // Moving this line up since fin isn't modified between now and when it happened before\n // fin.map {|sel| sel.is_a?(Array) ? sel : [sel]}\n\n for (NodeDeque::iterator finIter = fin.collection()->begin(), finEndIter = fin.collection()->end();\n finIter != finEndIter; ++finIter) {\n\n Node& childNode = *finIter;\n\n if (!childNode.isCollection()) {\n Node wrapper = Node::createCollection();\n wrapper.collection()->push_back(childNode);\n childNode = wrapper;\n }\n\n }\n\n DEBUG_PRINTLN(SUBWEAVE, \"FIN MAPPED: \" << fin)\n\n\n\n Node groupSeq1 = groupSelectors(seq1);\n DEBUG_PRINTLN(SUBWEAVE, \"SEQ1: \" << groupSeq1)\n\n Node groupSeq2 = groupSelectors(seq2);\n DEBUG_PRINTLN(SUBWEAVE, \"SEQ2: \" << groupSeq2)\n\n\n ComplexSelectorDeque groupSeq1Converted;\n nodeToComplexSelectorDeque(groupSeq1, groupSeq1Converted);\n\n ComplexSelectorDeque groupSeq2Converted;\n nodeToComplexSelectorDeque(groupSeq2, groupSeq2Converted);\n\n ComplexSelectorDeque out;\n LcsCollectionComparator collectionComparator;\n lcs(groupSeq2Converted, groupSeq1Converted, collectionComparator, out);\n Node seqLcs = complexSelectorDequeToNode(out);\n\n DEBUG_PRINTLN(SUBWEAVE, \"SEQLCS: \" << seqLcs)\n\n\n Node initWrapper = Node::createCollection();\n initWrapper.collection()->push_back(init);\n Node diff = Node::createCollection();\n diff.collection()->push_back(initWrapper);\n\n DEBUG_PRINTLN(SUBWEAVE, \"DIFF INIT: \" << diff)\n\n\n while (!seqLcs.collection()->empty()) {\n ParentSuperselectorChunker superselectorChunker(seqLcs);\n Node chunksResult = chunks(groupSeq1, groupSeq2, superselectorChunker);\n diff.collection()->push_back(chunksResult);\n\n Node lcsWrapper = Node::createCollection();\n lcsWrapper.collection()->push_back(seqLcs.collection()->front());\n seqLcs.collection()->pop_front();\n diff.collection()->push_back(lcsWrapper);\n\n if (groupSeq1.collection()->size()) groupSeq1.collection()->pop_front();\n if (groupSeq2.collection()->size()) groupSeq2.collection()->pop_front();\n }\n\n DEBUG_PRINTLN(SUBWEAVE, \"DIFF POST LCS: \" << diff)\n\n\n DEBUG_PRINTLN(SUBWEAVE, \"CHUNKS: ONE=\" << groupSeq1 << \" TWO=\" << groupSeq2)\n\n\n SubweaveEmptyChunker emptyChunker;\n Node chunksResult = chunks(groupSeq1, groupSeq2, emptyChunker);\n diff.collection()->push_back(chunksResult);\n\n\n DEBUG_PRINTLN(SUBWEAVE, \"DIFF POST CHUNKS: \" << diff)\n\n\n diff.collection()->insert(diff.collection()->end(), fin.collection()->begin(), fin.collection()->end());\n\n DEBUG_PRINTLN(SUBWEAVE, \"DIFF POST FIN MAPPED: \" << diff)\n\n // JMA - filter out the empty nodes (use a new collection, since iterator erase() invalidates the old collection)\n Node diffFiltered = Node::createCollection();\n for (NodeDeque::iterator diffIter = diff.collection()->begin(), diffEndIter = diff.collection()->end();\n diffIter != diffEndIter; ++diffIter) {\n Node& node = *diffIter;\n if (node.collection() && !node.collection()->empty()) {\n diffFiltered.collection()->push_back(node);\n }\n }\n diff = diffFiltered;\n\n DEBUG_PRINTLN(SUBWEAVE, \"DIFF POST REJECT: \" << diff)\n\n\n Node pathsResult = paths(diff);\n\n DEBUG_PRINTLN(SUBWEAVE, \"PATHS: \" << pathsResult)\n\n\n // We're flattening in place\n for (NodeDeque::iterator pathsIter = pathsResult.collection()->begin(), pathsEndIter = pathsResult.collection()->end();\n pathsIter != pathsEndIter; ++pathsIter) {\n\n Node& child = *pathsIter;\n child = flatten(child);\n }\n\n DEBUG_PRINTLN(SUBWEAVE, \"FLATTENED: \" << pathsResult)\n\n\n /*\n TODO: implement\n rejected = mapped.reject {|p| path_has_two_subjects?(p)}\n $stderr.puts \"REJECTED: #{rejected}\"\n */\n\n\n return pathsResult;\n\n }\n /*\n // disabled to avoid clang warning [-Wunused-function]\n static Node subweaveNaive(const Node& one, const Node& two) {\n Node out = Node::createCollection();\n\n // Check for the simple cases\n if (one.isNil()) {\n out.collection()->push_back(two.klone());\n } else if (two.isNil()) {\n out.collection()->push_back(one.klone());\n } else {\n // Do the naive implementation. pOne = A B and pTwo = C D ...yields... A B C D and C D A B\n // See https://gist.github.com/nex3/7609394 for details.\n\n Node firstPerm = one.klone();\n Node twoCloned = two.klone();\n firstPerm.plus(twoCloned);\n out.collection()->push_back(firstPerm);\n\n Node secondPerm = two.klone();\n Node oneCloned = one.klone();\n secondPerm.plus(oneCloned );\n out.collection()->push_back(secondPerm);\n }\n\n return out;\n }\n */\n\n\n /*\n This is the equivalent of ruby's Sequence.weave.\n\n The following is the modified version of the ruby code that was more portable to C++. You\n should be able to drop it into ruby 3.2.19 and get the same results from ruby sass.\n\n def weave(path)\n # This function works by moving through the selector path left-to-right,\n # building all possible prefixes simultaneously. These prefixes are\n # `befores`, while the remaining parenthesized suffixes is `afters`.\n befores = [[]]\n afters = path.dup\n\n until afters.empty?\n current = afters.shift.dup\n last_current = [current.pop]\n\n tempResult = []\n\n for before in befores do\n sub = subweave(before, current)\n if sub.nil?\n next\n end\n\n for seqs in sub do\n tempResult.push(seqs + last_current)\n end\n end\n\n befores = tempResult\n\n end\n\n return befores\n end\n */\n /*\n def weave(path)\n befores = [[]]\n afters = path.dup\n\n until afters.empty?\n current = afters.shift.dup\n\n last_current = [current.pop]\n\n\n tempResult = []\n\n for before in befores do\n sub = subweave(before, current)\n\n if sub.nil?\n next []\n end\n\n\n for seqs in sub do\n toPush = seqs + last_current\n\n tempResult.push(seqs + last_current)\n end\n\n end\n\n befores = tempResult\n\n end\n\n return befores\n end\n */\n Node Extend::weave(Node& path) {\n\n DEBUG_PRINTLN(WEAVE, \"WEAVE: \" << path)\n\n Node befores = Node::createCollection();\n befores.collection()->push_back(Node::createCollection());\n\n Node afters = Node::createCollection();\n afters.plus(path);\n\n while (!afters.collection()->empty()) {\n Node current = afters.collection()->front().klone();\n afters.collection()->pop_front();\n DEBUG_PRINTLN(WEAVE, \"CURRENT: \" << current)\n if (current.collection()->size() == 0) continue;\n\n Node last_current = Node::createCollection();\n last_current.collection()->push_back(current.collection()->back());\n current.collection()->pop_back();\n DEBUG_PRINTLN(WEAVE, \"CURRENT POST POP: \" << current)\n DEBUG_PRINTLN(WEAVE, \"LAST CURRENT: \" << last_current)\n\n Node tempResult = Node::createCollection();\n\n for (NodeDeque::iterator beforesIter = befores.collection()->begin(), beforesEndIter = befores.collection()->end(); beforesIter != beforesEndIter; beforesIter++) {\n Node& before = *beforesIter;\n\n Node sub = subweave(before, current);\n\n DEBUG_PRINTLN(WEAVE, \"SUB: \" << sub)\n\n if (sub.isNil()) {\n return Node::createCollection();\n }\n\n for (NodeDeque::iterator subIter = sub.collection()->begin(), subEndIter = sub.collection()->end(); subIter != subEndIter; subIter++) {\n Node& seqs = *subIter;\n\n Node toPush = Node::createCollection();\n toPush.plus(seqs);\n toPush.plus(last_current);\n\n // move line feed from inner to outer selector (very hacky indeed)\n if (last_current.collection() && last_current.collection()->front().selector()) {\n toPush.got_line_feed = last_current.collection()->front().got_line_feed;\n last_current.collection()->front().selector()->has_line_feed(false);\n last_current.collection()->front().got_line_feed = false;\n }\n\n tempResult.collection()->push_back(toPush);\n\n }\n }\n\n befores = tempResult;\n\n }\n\n return befores;\n }\n\n\n\n /*\n This is the equivalent of ruby's SimpleSequence.do_extend.\n\n // TODO: I think I have some modified ruby code to put here. Check.\n */\n /*\n ISSUES:\n - Previous TODO: Do we need to group the results by extender?\n - What does subject do in?: next unless unified = seq.members.last.unify(self_without_sel, subject?)\n - IMPROVEMENT: The search for uniqueness at the end is not ideal since it's has to loop over everything...\n - IMPROVEMENT: Check if the final search for uniqueness is doing anything that extendComplexSelector isn't already doing...\n */\n template\n class GroupByToAFunctor {\n public:\n KeyType operator()(SubSetMapPair& extPair) const {\n Complex_Selector_Obj pSelector = extPair.first;\n return pSelector;\n }\n };\n Node Extend::extendCompoundSelector(Compound_Selector_Ptr pSelector, CompoundSelectorSet& seen, bool isReplace) {\n\n /* this turned out to be too much overhead\n probably due to holding a \"Node\" object\n // check if we already extended this selector\n // we can do this since subset_map is \"static\"\n auto memoized = memoizeCompound.find(pSelector);\n if (memoized != memoizeCompound.end()) {\n return memoized->second.klone();\n }\n */\n\n DEBUG_EXEC(EXTEND_COMPOUND, printCompoundSelector(pSelector, \"EXTEND COMPOUND: \"))\n // TODO: Ruby has another loop here to skip certain members?\n\n // let RESULTS be an empty list of complex selectors\n Node results = Node::createCollection();\n // extendedSelectors.got_line_feed = true;\n\n SubSetMapPairs entries = subset_map.get_v(pSelector);\n\n GroupByToAFunctor extPairKeyFunctor;\n SubSetMapResults arr;\n group_by_to_a(entries, extPairKeyFunctor, arr);\n\n SubSetMapLookups holder;\n\n // for each (EXTENDER, TARGET) in MAP.get(COMPOUND):\n for (SubSetMapResult& groupedPair : arr) {\n\n Complex_Selector_Obj seq = groupedPair.first;\n SubSetMapPairs& group = groupedPair.second;\n\n DEBUG_EXEC(EXTEND_COMPOUND, printComplexSelector(seq, \"SEQ: \"))\n\n Compound_Selector_Obj pSels = SASS_MEMORY_NEW(Compound_Selector, pSelector->pstate());\n for (SubSetMapPair& pair : group) {\n pair.second->extended(true);\n pSels->concat(pair.second);\n }\n\n DEBUG_EXEC(EXTEND_COMPOUND, printCompoundSelector(pSels, \"SELS: \"))\n\n // The selector up to where the @extend is (ie, the thing to merge)\n Complex_Selector_Ptr pExtComplexSelector = seq;\n\n // TODO: This can return a Compound_Selector with no elements. Should that just be returning NULL?\n // RUBY: self_without_sel = Sass::Util.array_minus(members, sels)\n Compound_Selector_Obj pSelectorWithoutExtendSelectors = pSelector->minus(pSels);\n\n DEBUG_EXEC(EXTEND_COMPOUND, printCompoundSelector(pSelector, \"MEMBERS: \"))\n DEBUG_EXEC(EXTEND_COMPOUND, printCompoundSelector(pSelectorWithoutExtendSelectors, \"SELF_WO_SEL: \"))\n\n Compound_Selector_Obj pInnermostCompoundSelector = pExtComplexSelector->last()->head();\n\n if (!pInnermostCompoundSelector) {\n pInnermostCompoundSelector = SASS_MEMORY_NEW(Compound_Selector, pSelector->pstate());\n }\n Compound_Selector_Obj pUnifiedSelector = pInnermostCompoundSelector->unify_with(pSelectorWithoutExtendSelectors);\n\n DEBUG_EXEC(EXTEND_COMPOUND, printCompoundSelector(pInnermostCompoundSelector, \"LHS: \"))\n DEBUG_EXEC(EXTEND_COMPOUND, printCompoundSelector(pSelectorWithoutExtendSelectors, \"RHS: \"))\n DEBUG_EXEC(EXTEND_COMPOUND, printCompoundSelector(pUnifiedSelector, \"UNIFIED: \"))\n\n // RUBY: next unless unified\n if (!pUnifiedSelector || pUnifiedSelector->length() == 0) {\n continue;\n }\n\n // TODO: implement the parent directive match (if necessary based on test failures)\n // next if group.map {|e, _| check_directives_match!(e, parent_directives)}.none?\n\n // TODO: This seems a little fishy to me. See if it causes any problems. From the ruby, we should be able to just\n // get rid of the last Compound_Selector and replace it with this one. I think the reason this code is more\n // complex is that Complex_Selector contains a combinator, but in ruby combinators have already been filtered\n // out and aren't operated on.\n Complex_Selector_Obj pNewSelector = SASS_MEMORY_CLONE(pExtComplexSelector); // ->first();\n\n Complex_Selector_Obj pNewInnerMost = SASS_MEMORY_NEW(Complex_Selector, pSelector->pstate(), Complex_Selector::ANCESTOR_OF, pUnifiedSelector, NULL);\n\n Complex_Selector::Combinator combinator = pNewSelector->clear_innermost();\n pNewSelector->set_innermost(pNewInnerMost, combinator);\n\n#ifdef DEBUG\n ComplexSelectorSet debugSet;\n debugSet = pNewSelector->sources();\n if (debugSet.size() > 0) {\n throw std::runtime_error(\"The new selector should start with no sources. Something needs to be cloned to fix this.\");\n }\n debugSet = pExtComplexSelector->sources();\n if (debugSet.size() > 0) {\n throw std::runtime_error(\"The extension selector from our subset map should not have sources. These will bleed to the new selector. Something needs to be cloned to fix this.\");\n }\n#endif\n\n\n // if (pSelector && pSelector->has_line_feed()) pNewInnerMost->has_line_feed(true);\n // Set the sources on our new Complex_Selector to the sources of this simple sequence plus the thing we're extending.\n DEBUG_PRINTLN(EXTEND_COMPOUND, \"SOURCES SETTING ON NEW SEQ: \" << complexSelectorToNode(pNewSelector))\n\n DEBUG_EXEC(EXTEND_COMPOUND, ComplexSelectorSet oldSet = pNewSelector->sources(); printSourcesSet(oldSet, \"SOURCES NEW SEQ BEGIN: \"))\n\n // I actually want to create a copy here (performance!)\n ComplexSelectorSet newSourcesSet = pSelector->sources(); // XXX\n DEBUG_EXEC(EXTEND_COMPOUND, printSourcesSet(newSourcesSet, \"SOURCES THIS EXTEND: \"))\n\n newSourcesSet.insert(pExtComplexSelector);\n DEBUG_EXEC(EXTEND_COMPOUND, printSourcesSet(newSourcesSet, \"SOURCES WITH NEW SOURCE: \"))\n\n // RUBY: new_seq.add_sources!(sources + [seq])\n pNewSelector->addSources(newSourcesSet);\n\n DEBUG_EXEC(EXTEND_COMPOUND, ComplexSelectorSet newSet = pNewSelector->sources(); printSourcesSet(newSet, \"SOURCES ON NEW SELECTOR AFTER ADD: \"))\n DEBUG_EXEC(EXTEND_COMPOUND, printSourcesSet(pSelector->sources(), \"SOURCES THIS EXTEND WHICH SHOULD BE SAME STILL: \"))\n\n\n if (pSels->has_line_feed()) pNewSelector->has_line_feed(true);\n\n holder.push_back(std::make_pair(pSels, pNewSelector));\n }\n\n\n for (SubSetMapLookup& pair : holder) {\n\n Compound_Selector_Obj pSels = pair.first;\n Complex_Selector_Obj pNewSelector = pair.second;\n\n\n // RUBY??: next [] if seen.include?(sels)\n if (seen.find(pSels) != seen.end()) {\n continue;\n }\n\n\n CompoundSelectorSet recurseSeen(seen);\n recurseSeen.insert(pSels);\n\n\n DEBUG_PRINTLN(EXTEND_COMPOUND, \"RECURSING DO EXTEND: \" << complexSelectorToNode(pNewSelector))\n Node recurseExtendedSelectors = extendComplexSelector(pNewSelector, recurseSeen, isReplace, false); // !:isOriginal\n\n DEBUG_PRINTLN(EXTEND_COMPOUND, \"RECURSING DO EXTEND RETURN: \" << recurseExtendedSelectors)\n\n for (NodeDeque::iterator iterator = recurseExtendedSelectors.collection()->begin(), endIterator = recurseExtendedSelectors.collection()->end();\n iterator != endIterator; ++iterator) {\n Node newSelector = *iterator;\n\n// DEBUG_PRINTLN(EXTEND_COMPOUND, \"EXTENDED AT THIS POINT: \" << results)\n// DEBUG_PRINTLN(EXTEND_COMPOUND, \"SELECTOR EXISTS ALREADY: \" << newSelector << \" \" << results.contains(newSelector, false /*simpleSelectorOrderDependent*/));\n\n if (!results.contains(newSelector)) {\n// DEBUG_PRINTLN(EXTEND_COMPOUND, \"ADDING NEW SELECTOR\")\n results.collection()->push_back(newSelector);\n }\n }\n }\n\n DEBUG_EXEC(EXTEND_COMPOUND, printCompoundSelector(pSelector, \"EXTEND COMPOUND END: \"))\n\n // this turned out to be too much overhead\n // memory results in a map table - since extending is very expensive\n // memoizeCompound.insert(std::pair(pSelector, results));\n\n return results;\n }\n\n\n // check if selector has something to be extended by subset_map\n bool Extend::complexSelectorHasExtension(Complex_Selector_Ptr selector, CompoundSelectorSet& seen) {\n\n bool hasExtension = false;\n\n Complex_Selector_Obj pIter = selector;\n\n while (!hasExtension && pIter) {\n Compound_Selector_Obj pHead = pIter->head();\n\n if (pHead) {\n SubSetMapPairs entries = subset_map.get_v(pHead);\n for (SubSetMapPair ext : entries) {\n // check if both selectors have the same media block parent\n // if (ext.first->media_block() == pComplexSelector->media_block()) continue;\n if (ext.second->media_block() == 0) continue;\n if (pHead->media_block() &&\n ext.second->media_block()->media_queries() &&\n pHead->media_block()->media_queries()\n ) {\n std::string query_left(ext.second->media_block()->media_queries()->to_string());\n std::string query_right(pHead->media_block()->media_queries()->to_string());\n if (query_left == query_right) continue;\n }\n\n // fail if one goes across media block boundaries\n std::stringstream err;\n std::string cwd(Sass::File::get_cwd());\n ParserState pstate(ext.second->pstate());\n std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));\n err << \"You may not @extend an outer selector from within @media.\\n\";\n err << \"You may only @extend selectors within the same directive.\\n\";\n err << \"From \\\"@extend \" << ext.second->to_string() << \"\\\"\";\n err << \" on line \" << pstate.line+1 << \" of \" << rel_path << \"\\n\";\n error(err.str(), selector->pstate(), eval->exp.traces);\n }\n if (entries.size() > 0) hasExtension = true;\n }\n\n pIter = pIter->tail();\n }\n\n return hasExtension;\n }\n\n\n /*\n This is the equivalent of ruby's Sequence.do_extend.\n\n // TODO: I think I have some modified ruby code to put here. Check.\n */\n /*\n ISSUES:\n - check to automatically include combinators doesn't transfer over to libsass' data model where\n the combinator and compound selector are one unit\n next [[sseq_or_op]] unless sseq_or_op.is_a?(SimpleSequence)\n */\n Node Extend::extendComplexSelector(Complex_Selector_Ptr selector, CompoundSelectorSet& seen, bool isReplace, bool isOriginal) {\n\n // check if we already extended this selector\n // we can do this since subset_map is \"static\"\n auto memoized = memoizeComplex.find(selector);\n if (memoized != memoizeComplex.end()) {\n return memoized->second;\n }\n\n // convert the input selector to extend node format\n Node complexSelector = complexSelectorToNode(selector);\n DEBUG_PRINTLN(EXTEND_COMPLEX, \"EXTEND COMPLEX: \" << complexSelector)\n\n // let CHOICES be an empty list of selector-lists\n // create new collection to hold the results\n Node choices = Node::createCollection();\n\n // for each compound selector COMPOUND in COMPLEX:\n for (Node& sseqOrOp : *complexSelector.collection()) {\n\n DEBUG_PRINTLN(EXTEND_COMPLEX, \"LOOP: \" << sseqOrOp)\n\n // If it's not a selector (meaning it's a combinator), just include it automatically\n // RUBY: next [[sseq_or_op]] unless sseq_or_op.is_a?(SimpleSequence)\n if (!sseqOrOp.isSelector()) {\n // Wrap our Combinator in two collections to match ruby. This is essentially making a collection Node\n // with one collection child. The collection child represents a Complex_Selector that is only a combinator.\n Node outer = Node::createCollection();\n Node inner = Node::createCollection();\n outer.collection()->push_back(inner);\n inner.collection()->push_back(sseqOrOp);\n choices.collection()->push_back(outer);\n continue;\n }\n\n // verified now that node is a valid selector\n Complex_Selector_Obj sseqSel = sseqOrOp.selector();\n Compound_Selector_Obj sseqHead = sseqSel->head();\n\n // let EXTENDED be extend_compound(COMPOUND, SEEN)\n // extend the compound selector against the given subset_map\n // RUBY: extended = sseq_or_op.do_extend(extends, parent_directives, replace, seen)\n Node extended = extendCompoundSelector(sseqHead, seen, isReplace); // slow(17%)!\n if (sseqOrOp.got_line_feed) extended.got_line_feed = true;\n DEBUG_PRINTLN(EXTEND_COMPLEX, \"EXTENDED: \" << extended)\n\n // Prepend the Compound_Selector based on the choices logic; choices seems to be extend but with a ruby\n // Array instead of a Sequence due to the member mapping: choices = extended.map {|seq| seq.members}\n // RUBY: extended.first.add_sources!([self]) if original && !has_placeholder?\n if (isOriginal && !selector->has_placeholder()) {\n ComplexSelectorSet srcset;\n srcset.insert(selector);\n sseqSel->addSources(srcset);\n // DEBUG_PRINTLN(EXTEND_COMPLEX, \"ADD SOURCES: \" << *pComplexSelector)\n }\n\n bool isSuperselector = false;\n // if no complex selector in EXTENDED is a superselector of COMPOUND:\n for (Node& childNode : *extended.collection()) {\n Complex_Selector_Obj pExtensionSelector = nodeToComplexSelector(childNode);\n if (pExtensionSelector->is_superselector_of(sseqSel)) {\n isSuperselector = true;\n break;\n }\n }\n\n if (!isSuperselector) {\n // add a complex selector composed only of COMPOUND to EXTENDED\n if (sseqOrOp.got_line_feed) sseqSel->has_line_feed(sseqOrOp.got_line_feed);\n extended.collection()->push_front(complexSelectorToNode(sseqSel));\n }\n\n DEBUG_PRINTLN(EXTEND_COMPLEX, \"CHOICES UNSHIFTED: \" << extended)\n\n // add EXTENDED to CHOICES\n // Aggregate our current extensions\n choices.collection()->push_back(extended);\n }\n\n\n DEBUG_PRINTLN(EXTEND_COMPLEX, \"EXTENDED NOT EXPANDED: \" << choices)\n\n\n\n // Ruby Equivalent: paths\n Node paths = Sass::paths(choices);\n\n DEBUG_PRINTLN(EXTEND_COMPLEX, \"PATHS: \" << paths)\n\n // let WEAVES be an empty list of selector lists\n Node weaves = Node::createCollection();\n\n // for each list of complex selectors PATH in paths(CHOICES):\n for (Node& path : *paths.collection()) {\n // add weave(PATH) to WEAVES\n Node weaved = weave(path); // slow(12%)!\n weaved.got_line_feed = path.got_line_feed;\n weaves.collection()->push_back(weaved);\n }\n\n DEBUG_PRINTLN(EXTEND_COMPLEX, \"WEAVES: \" << weaves)\n\n // Ruby Equivalent: trim\n Node trimmed(trim(weaves, isReplace)); // slow(19%)!\n\n DEBUG_PRINTLN(EXTEND_COMPLEX, \"TRIMMED: \" << trimmed)\n\n // Ruby Equivalent: flatten\n Node flattened(flatten(trimmed, 1));\n\n DEBUG_PRINTLN(EXTEND_COMPLEX, \">>>>> EXTENDED: \" << extendedSelectors)\n DEBUG_PRINTLN(EXTEND_COMPLEX, \"EXTEND COMPLEX END: \" << complexSelector)\n\n // memory results in a map table - since extending is very expensive\n memoizeComplex.insert(std::pair(selector, flattened));\n\n // return trim(WEAVES)\n return flattened;\n }\n\n\n\n /*\n This is the equivalent of ruby's CommaSequence.do_extend.\n */\n // We get a selector list with has something to extend and a subset_map with\n // all extenders. Pick the ones that match our selectors in the list.\n Selector_List_Ptr Extend::extendSelectorList(Selector_List_Obj pSelectorList, bool isReplace, bool& extendedSomething, CompoundSelectorSet& seen) {\n\n Selector_List_Obj pNewSelectors = SASS_MEMORY_NEW(Selector_List, pSelectorList->pstate(), pSelectorList->length());\n\n // check if we already extended this selector\n // we can do this since subset_map is \"static\"\n auto memoized = memoizeList.find(pSelectorList);\n if (memoized != memoizeList.end()) {\n extendedSomething = true;\n return memoized->second;\n }\n\n extendedSomething = false;\n // process each comlplex selector in the selector list.\n // Find the ones that can be extended by given subset_map.\n for (size_t index = 0, length = pSelectorList->length(); index < length; index++) {\n Complex_Selector_Obj pSelector = (*pSelectorList)[index];\n\n // ruby sass seems to keep a list of things that have extensions and then only extend those. We don't currently do that.\n // Since it's not that expensive to check if an extension exists in the subset map and since it can be relatively expensive to\n // run through the extend code (which does a data model transformation), check if there is anything to extend before doing\n // the extend. We might be able to optimize extendComplexSelector, but this approach keeps us closer to ruby sass (which helps\n // when debugging).\n if (!complexSelectorHasExtension(pSelector, seen)) {\n pNewSelectors->append(pSelector);\n continue;\n }\n\n // complexSelectorHasExtension was true!\n extendedSomething = true;\n\n // now do the actual extension of the complex selector\n Node extendedSelectors = extendComplexSelector(pSelector, seen, isReplace, true);\n\n if (!pSelector->has_placeholder()) {\n Node nSelector(complexSelectorToNode(pSelector));\n if (!extendedSelectors.contains(nSelector)) {\n pNewSelectors->append(pSelector);\n continue;\n }\n }\n\n bool doReplace = isReplace;\n for (Node& childNode : *extendedSelectors.collection()) {\n // When it is a replace, skip the first one, unless there is only one\n if(doReplace && extendedSelectors.collection()->size() > 1 ) {\n doReplace = false;\n continue;\n }\n pNewSelectors->append(nodeToComplexSelector(childNode));\n }\n }\n\n Remove_Placeholders remove_placeholders;\n // it seems that we have to remove the place holders early here\n // normally we do this as the very last step (compare to ruby sass)\n pNewSelectors = remove_placeholders.remove_placeholders(pNewSelectors);\n\n // unwrap all wrapped selectors with inner lists\n for (Complex_Selector_Obj cur : pNewSelectors->elements()) {\n // process tails\n while (cur) {\n // process header\n if (cur->head() && seen.find(cur->head()) == seen.end()) {\n CompoundSelectorSet recseen(seen);\n recseen.insert(cur->head());\n // create a copy since we add multiple items if stuff get unwrapped\n Compound_Selector_Obj cpy_head = SASS_MEMORY_NEW(Compound_Selector, cur->pstate());\n for (Simple_Selector_Obj hs : *cur->head()) {\n if (Wrapped_Selector_Obj ws = Cast(hs)) {\n ws->selector(SASS_MEMORY_CLONE(ws->selector()));\n if (Selector_List_Obj sl = Cast(ws->selector())) {\n // special case for ruby ass\n if (sl->empty()) {\n // this seems inconsistent but it is how ruby sass seems to remove parentheses\n cpy_head->append(SASS_MEMORY_NEW(Element_Selector, hs->pstate(), ws->name()));\n }\n // has wrapped not selectors\n else if (ws->name() == \":not\") {\n // extend the inner list of wrapped selector\n bool extended = false;\n Selector_List_Obj ext_sl = extendSelectorList(sl, false, extended, recseen);\n for (size_t i = 0; i < ext_sl->length(); i += 1) {\n if (Complex_Selector_Obj ext_cs = ext_sl->at(i)) {\n // create clones for wrapped selector and the inner list\n Wrapped_Selector_Obj cpy_ws = SASS_MEMORY_COPY(ws);\n Selector_List_Obj cpy_ws_sl = SASS_MEMORY_NEW(Selector_List, sl->pstate());\n // remove parent selectors from inner selector\n Compound_Selector_Obj ext_head = NULL;\n if (ext_cs->first()) ext_head = ext_cs->first()->head();\n if (ext_head && ext_head && ext_head->length() > 0) {\n cpy_ws_sl->append(ext_cs->first());\n }\n // assign list to clone\n cpy_ws->selector(cpy_ws_sl);\n // append the clone\n cpy_head->append(cpy_ws);\n }\n }\n if (eval && extended) {\n eval->exp.selector_stack.push_back(pNewSelectors);\n cpy_head->perform(eval);\n eval->exp.selector_stack.pop_back();\n }\n }\n // has wrapped selectors\n else {\n Wrapped_Selector_Obj cpy_ws = SASS_MEMORY_COPY(ws);\n Selector_List_Obj ext_sl = extendSelectorList(sl, recseen);\n cpy_ws->selector(ext_sl);\n cpy_head->append(cpy_ws);\n }\n } else {\n cpy_head->append(hs);\n }\n } else {\n cpy_head->append(hs);\n }\n }\n // replace header\n cur->head(cpy_head);\n }\n // process tail\n cur = cur->tail();\n }\n }\n\n // memory results in a map table - since extending is very expensive\n memoizeList.insert(std::pair(pSelectorList, pNewSelectors));\n\n return pNewSelectors.detach();\n\n }\n\n\n bool shouldExtendBlock(Block_Obj b) {\n\n // If a block is empty, there's no reason to extend it since any rules placed on this block\n // won't have any output. The main benefit of this is for structures like:\n //\n // .a {\n // .b {\n // x: y;\n // }\n // }\n //\n // We end up visiting two rulesets (one with the selector .a and the other with the selector .a .b).\n // In this case, we don't want to try to pull rules onto .a since they won't get output anyway since\n // there are no child statements. However .a .b should have extensions applied.\n\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj stm = b->at(i);\n\n if (Cast(stm)) {\n // Do nothing. This doesn't count as a statement that causes extension since we'll\n // iterate over this rule set in a future visit and try to extend it.\n }\n else {\n return true;\n }\n }\n\n return false;\n\n }\n\n\n // Extend a ruleset by extending the selectors and updating them on the ruleset. The block's rules don't need to change.\n // Every Ruleset in the whole tree is calling this function. We decide if there\n // was is @extend that matches our selector. If we find one, we will go further\n // and call the extend magic for our selector. The subset_map contains all blocks\n // where @extend was found. Pick the ones that match our selector!\n void Extend::extendObjectWithSelectorAndBlock(Ruleset_Ptr pObject) {\n\n DEBUG_PRINTLN(EXTEND_OBJECT, \"FOUND SELECTOR: \" << Cast(pObject->selector())->to_string())\n\n // Ruby sass seems to filter nodes that don't have any content well before we get here.\n // I'm not sure the repercussions of doing so, so for now, let's just not extend things\n // that won't be output later. Profiling shows this may us 0.2% or so.\n if (!shouldExtendBlock(pObject->block())) {\n DEBUG_PRINTLN(EXTEND_OBJECT, \"RETURNING WITHOUT EXTEND ATTEMPT\")\n return;\n }\n\n bool extendedSomething = false;\n\n CompoundSelectorSet seen;\n Selector_List_Obj pNewSelectorList = extendSelectorList(pObject->selector(), false, extendedSomething, seen);\n\n if (extendedSomething && pNewSelectorList) {\n DEBUG_PRINTLN(EXTEND_OBJECT, \"EXTEND ORIGINAL SELECTORS: \" << pObject->selector()->to_string())\n DEBUG_PRINTLN(EXTEND_OBJECT, \"EXTEND SETTING NEW SELECTORS: \" << pNewSelectorList->to_string())\n pNewSelectorList->remove_parent_selectors();\n pObject->selector(pNewSelectorList);\n } else {\n DEBUG_PRINTLN(EXTEND_OBJECT, \"EXTEND DID NOT TRY TO EXTEND ANYTHING\")\n }\n }\n\n Extend::Extend(Subset_Map& ssm)\n : subset_map(ssm), eval(NULL)\n { }\n\n void Extend::setEval(Eval& e) {\n eval = &e;\n }\n\n void Extend::operator()(Block_Ptr b)\n {\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj stm = b->at(i);\n stm->perform(this);\n }\n // do final check if everything was extended\n // we set `extended` flag on extended selectors\n if (b->is_root()) {\n // debug_subset_map(subset_map);\n for(auto const &it : subset_map.values()) {\n Complex_Selector_Ptr sel = NULL;\n Compound_Selector_Ptr ext = NULL;\n if (it.first) sel = it.first->first();\n if (it.second) ext = it.second;\n if (ext && (ext->extended() || ext->is_optional())) continue;\n std::string str_sel(sel ? sel->to_string({ NESTED, 5 }) : \"NULL\");\n std::string str_ext(ext ? ext->to_string({ NESTED, 5 }) : \"NULL\");\n // debug_ast(sel, \"sel: \");\n // debug_ast(ext, \"ext: \");\n error(\"\\\"\" + str_sel + \"\\\" failed to @extend \\\"\" + str_ext + \"\\\".\\n\"\n \"The selector \\\"\" + str_ext + \"\\\" was not found.\\n\"\n \"Use \\\"@extend \" + str_ext + \" !optional\\\" if the\"\n \" extend should be able to fail.\", (ext ? ext->pstate() : NULL), eval->exp.traces);\n }\n }\n\n }\n\n void Extend::operator()(Ruleset_Ptr pRuleset)\n {\n extendObjectWithSelectorAndBlock( pRuleset );\n pRuleset->block()->perform(this);\n }\n\n void Extend::operator()(Supports_Block_Ptr pFeatureBlock)\n {\n pFeatureBlock->block()->perform(this);\n }\n\n void Extend::operator()(Media_Block_Ptr pMediaBlock)\n {\n pMediaBlock->block()->perform(this);\n }\n\n void Extend::operator()(Directive_Ptr a)\n {\n // Selector_List_Ptr ls = Cast(a->selector());\n // selector_stack.push_back(ls);\n if (a->block()) a->block()->perform(this);\n // exp.selector_stack.pop_back();\n }\n}\n" }, { "path": "libsass-build/extend.hpp", "content": "#ifndef SASS_EXTEND_H\n#define SASS_EXTEND_H\n\n#include \n#include \n\n#include \"ast.hpp\"\n#include \"node.hpp\"\n#include \"eval.hpp\"\n#include \"operation.hpp\"\n#include \"subset_map.hpp\"\n#include \"ast_fwd_decl.hpp\"\n\nnamespace Sass {\n\n Node subweave(Node& one, Node& two);\n\n class Extend : public Operation_CRTP {\n\n Subset_Map& subset_map;\n Eval* eval;\n\n void fallback_impl(AST_Node_Ptr n) { }\n\n private:\n\n std::unordered_map<\n Selector_List_Obj, // key\n Selector_List_Obj, // value\n HashNodes, // hasher\n CompareNodes // compare\n > memoizeList;\n\n std::unordered_map<\n Complex_Selector_Obj, // key\n Node, // value\n HashNodes, // hasher\n CompareNodes // compare\n > memoizeComplex;\n\n /* this turned out to be too much overhead\n re-evaluate once we store an ast selector\n std::unordered_map<\n Compound_Selector_Obj, // key\n Node, // value\n HashNodes, // hasher\n CompareNodes // compare\n > memoizeCompound;\n */\n\n void extendObjectWithSelectorAndBlock(Ruleset_Ptr pObject);\n Node extendComplexSelector(Complex_Selector_Ptr sel, CompoundSelectorSet& seen, bool isReplace, bool isOriginal);\n Node extendCompoundSelector(Compound_Selector_Ptr sel, CompoundSelectorSet& seen, bool isReplace);\n bool complexSelectorHasExtension(Complex_Selector_Ptr selector, CompoundSelectorSet& seen);\n Node trim(Node& seqses, bool isReplace);\n Node weave(Node& path);\n\n public:\n void setEval(Eval& eval);\n Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, bool isReplace, bool& extendedSomething, CompoundSelectorSet& seen);\n Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, bool isReplace = false) {\n bool extendedSomething = false;\n CompoundSelectorSet seen;\n return extendSelectorList(pSelectorList, isReplace, extendedSomething, seen);\n }\n Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, CompoundSelectorSet& seen) {\n bool isReplace = false;\n bool extendedSomething = false;\n return extendSelectorList(pSelectorList, isReplace, extendedSomething, seen);\n }\n Extend(Subset_Map&);\n ~Extend() { }\n\n void operator()(Block_Ptr);\n void operator()(Ruleset_Ptr);\n void operator()(Supports_Block_Ptr);\n void operator()(Media_Block_Ptr);\n void operator()(Directive_Ptr);\n\n template \n void fallback(U x) { return fallback_impl(x); }\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/file.cpp", "content": "#include \"sass.hpp\"\n#ifdef _WIN32\n# ifdef __MINGW32__\n# ifndef off64_t\n# define off64_t _off64_t /* Workaround for http://sourceforge.net/p/mingw/bugs/2024/ */\n# endif\n# endif\n# include \n# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)\n#else\n# include \n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"file.hpp\"\n#include \"context.hpp\"\n#include \"prelexer.hpp\"\n#include \"utf8_string.hpp\"\n#include \"sass_functions.hpp\"\n#include \"sass2scss.h\"\n\n#ifdef _WIN32\n# include \n\n# ifdef _MSC_VER\n# include \ninline static std::string wstring_to_string(const std::wstring& wstr)\n{\n std::wstring_convert, wchar_t> wchar_converter;\n return wchar_converter.to_bytes(wstr);\n}\n# else // mingw(/gcc) does not support C++11's codecvt yet.\ninline static std::string wstring_to_string(const std::wstring &wstr)\n{\n int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);\n std::string strTo(size_needed, 0);\n WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL);\n return strTo;\n}\n# endif\n#endif\n\nnamespace Sass {\n namespace File {\n\n // return the current directory\n // always with forward slashes\n // always with trailing slash\n std::string get_cwd()\n {\n const size_t wd_len = 4096;\n #ifndef _WIN32\n char wd[wd_len];\n char* pwd = getcwd(wd, wd_len);\n // we should check error for more detailed info (e.g. ENOENT)\n // http://man7.org/linux/man-pages/man2/getcwd.2.html#ERRORS\n if (pwd == NULL) throw Exception::OperationError(\"cwd gone missing\");\n std::string cwd = pwd;\n #else\n wchar_t wd[wd_len];\n wchar_t* pwd = _wgetcwd(wd, wd_len);\n if (pwd == NULL) throw Exception::OperationError(\"cwd gone missing\");\n std::string cwd = wstring_to_string(pwd);\n //convert backslashes to forward slashes\n replace(cwd.begin(), cwd.end(), '\\\\', '/');\n #endif\n if (cwd[cwd.length() - 1] != '/') cwd += '/';\n return cwd;\n }\n\n // test if path exists and is a file\n bool file_exists(const std::string& path)\n {\n #ifdef _WIN32\n wchar_t resolved[32768];\n // windows unicode filepaths are encoded in utf16\n std::string abspath(join_paths(get_cwd(), path));\n std::wstring wpath(UTF_8::convert_to_utf16(\"\\\\\\\\?\\\\\" + abspath));\n std::replace(wpath.begin(), wpath.end(), '/', '\\\\');\n DWORD rv = GetFullPathNameW(wpath.c_str(), 32767, resolved, NULL);\n if (rv > 32767) throw Exception::OperationError(\"Path is too long\");\n if (rv == 0) throw Exception::OperationError(\"Path could not be resolved\");\n DWORD dwAttrib = GetFileAttributesW(resolved);\n return (dwAttrib != INVALID_FILE_ATTRIBUTES &&\n (!(dwAttrib & FILE_ATTRIBUTE_DIRECTORY)));\n #else\n struct stat st_buf;\n return (stat (path.c_str(), &st_buf) == 0) &&\n (!S_ISDIR (st_buf.st_mode));\n #endif\n }\n\n // return if given path is absolute\n // works with *nix and windows paths\n bool is_absolute_path(const std::string& path)\n {\n #ifdef _WIN32\n if (path.length() >= 2 && isalpha(path[0]) && path[1] == ':') return true;\n #endif\n size_t i = 0;\n // check if we have a protocol\n if (path[i] && Prelexer::is_alpha(path[i])) {\n // skip over all alphanumeric characters\n while (path[i] && Prelexer::is_alnum(path[i])) ++i;\n i = i && path[i] == ':' ? i + 1 : 0;\n }\n return path[i] == '/';\n }\n\n // helper function to find the last directory seperator\n inline size_t find_last_folder_separator(const std::string& path, size_t limit = std::string::npos)\n {\n size_t pos;\n size_t pos_p = path.find_last_of('/', limit);\n #ifdef _WIN32\n size_t pos_w = path.find_last_of('\\\\', limit);\n #else\n size_t pos_w = std::string::npos;\n #endif\n if (pos_p != std::string::npos && pos_w != std::string::npos) {\n pos = std::max(pos_p, pos_w);\n }\n else if (pos_p != std::string::npos) {\n pos = pos_p;\n }\n else {\n pos = pos_w;\n }\n return pos;\n }\n\n // return only the directory part of path\n std::string dir_name(const std::string& path)\n {\n size_t pos = find_last_folder_separator(path);\n if (pos == std::string::npos) return \"\";\n else return path.substr(0, pos+1);\n }\n\n // return only the filename part of path\n std::string base_name(const std::string& path)\n {\n size_t pos = find_last_folder_separator(path);\n if (pos == std::string::npos) return path;\n else return path.substr(pos+1);\n }\n\n // do a logical clean up of the path\n // no physical check on the filesystem\n std::string make_canonical_path (std::string path)\n {\n\n // declarations\n size_t pos;\n\n #ifdef _WIN32\n //convert backslashes to forward slashes\n replace(path.begin(), path.end(), '\\\\', '/');\n #endif\n\n pos = 0; // remove all self references inside the path string\n while((pos = path.find(\"/./\", pos)) != std::string::npos) path.erase(pos, 2);\n\n // remove all leading and trailing self references\n while(path.length() > 1 && path.substr(0, 2) == \"./\") path.erase(0, 2);\n while((pos = path.length()) > 1 && path.substr(pos - 2) == \"/.\") path.erase(pos - 2);\n\n\n size_t proto = 0;\n // check if we have a protocol\n if (path[proto] && Prelexer::is_alpha(path[proto])) {\n // skip over all alphanumeric characters\n while (path[proto] && Prelexer::is_alnum(path[proto++])) {}\n // then skip over the mandatory colon\n if (proto && path[proto] == ':') ++ proto;\n }\n\n // then skip over start slashes\n while (path[proto++] == '/') {}\n\n pos = proto; // collapse multiple delimiters into a single one\n while((pos = path.find(\"//\", pos)) != std::string::npos) path.erase(pos, 1);\n\n return path;\n\n }\n\n // join two path segments cleanly together\n // but only if right side is not absolute yet\n std::string join_paths(std::string l, std::string r)\n {\n\n #ifdef _WIN32\n // convert Windows backslashes to URL forward slashes\n replace(l.begin(), l.end(), '\\\\', '/');\n replace(r.begin(), r.end(), '\\\\', '/');\n #endif\n\n if (l.empty()) return r;\n if (r.empty()) return l;\n\n if (is_absolute_path(r)) return r;\n if (l[l.length()-1] != '/') l += '/';\n\n // this does a logical cleanup of the right hand path\n // Note that this does collapse x/../y sections into y.\n // This is by design. If /foo on your system is a symlink\n // to /bar/baz, then /foo/../cd is actually /bar/cd,\n // not /cd as a naive ../ removal would give you.\n // will only work on leading double dot dirs on rhs\n // therefore it is safe if lhs is already resolved cwd\n while ((r.length() > 3) && ((r.substr(0, 3) == \"../\") || (r.substr(0, 3)) == \"..\\\\\")) {\n size_t L = l.length(), pos = find_last_folder_separator(l, L - 2);\n bool is_slash = pos + 2 == L && (l[pos+1] == '/' || l[pos+1] == '\\\\');\n bool is_self = pos + 3 == L && (l[pos+1] == '.');\n if (!is_self && !is_slash) r = r.substr(3);\n else if (pos == std::string::npos) break;\n l = l.substr(0, pos == std::string::npos ? pos : pos + 1);\n }\n\n return l + r;\n }\n\n std::string path_for_console(const std::string& rel_path, const std::string& abs_path, const std::string& orig_path)\n {\n // magic algorith goes here!!\n\n // if the file is outside this directory show the absolute path\n if (rel_path.substr(0, 3) == \"../\") {\n return orig_path;\n }\n // this seems to work most of the time\n return abs_path == orig_path ? abs_path : rel_path;\n }\n\n // create an absolute path by resolving relative paths with cwd\n std::string rel2abs(const std::string& path, const std::string& base, const std::string& cwd)\n {\n return make_canonical_path(join_paths(join_paths(cwd + \"/\", base + \"/\"), path));\n }\n\n // create a path that is relative to the given base directory\n // path and base will first be resolved against cwd to make them absolute\n std::string abs2rel(const std::string& path, const std::string& base, const std::string& cwd)\n {\n\n std::string abs_path = rel2abs(path, cwd);\n std::string abs_base = rel2abs(base, cwd);\n\n size_t proto = 0;\n // check if we have a protocol\n if (path[proto] && Prelexer::is_alpha(path[proto])) {\n // skip over all alphanumeric characters\n while (path[proto] && Prelexer::is_alnum(path[proto++])) {}\n // then skip over the mandatory colon\n if (proto && path[proto] == ':') ++ proto;\n }\n\n // distinguish between windows absolute paths and valid protocols\n // we assume that protocols must at least have two chars to be valid\n if (proto && path[proto++] == '/' && proto > 3) return path;\n\n #ifdef _WIN32\n // absolute link must have a drive letter, and we know that we\n // can only create relative links if both are on the same drive\n if (abs_base[0] != abs_path[0]) return abs_path;\n #endif\n\n std::string stripped_uri = \"\";\n std::string stripped_base = \"\";\n\n size_t index = 0;\n size_t minSize = std::min(abs_path.size(), abs_base.size());\n for (size_t i = 0; i < minSize; ++i) {\n #ifdef FS_CASE_SENSITIVE\n if (abs_path[i] != abs_base[i]) break;\n #else\n // compare the charactes in a case insensitive manner\n // windows fs is only case insensitive in ascii ranges\n if (tolower(abs_path[i]) != tolower(abs_base[i])) break;\n #endif\n if (abs_path[i] == '/') index = i + 1;\n }\n for (size_t i = index; i < abs_path.size(); ++i) {\n stripped_uri += abs_path[i];\n }\n for (size_t i = index; i < abs_base.size(); ++i) {\n stripped_base += abs_base[i];\n }\n\n size_t left = 0;\n size_t directories = 0;\n for (size_t right = 0; right < stripped_base.size(); ++right) {\n if (stripped_base[right] == '/') {\n if (stripped_base.substr(left, 2) != \"..\") {\n ++directories;\n }\n else if (directories > 1) {\n --directories;\n }\n else {\n directories = 0;\n }\n left = right + 1;\n }\n }\n\n std::string result = \"\";\n for (size_t i = 0; i < directories; ++i) {\n result += \"../\";\n }\n result += stripped_uri;\n\n return result;\n }\n\n // Resolution order for ambiguous imports:\n // (1) filename as given\n // (2) underscore + given\n // (3) underscore + given + extension\n // (4) given + extension\n std::vector resolve_includes(const std::string& root, const std::string& file, const std::vector& exts)\n {\n std::string filename = join_paths(root, file);\n // split the filename\n std::string base(dir_name(file));\n std::string name(base_name(file));\n std::vector includes;\n // create full path (maybe relative)\n std::string rel_path(join_paths(base, name));\n std::string abs_path(join_paths(root, rel_path));\n if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });\n // next test variation with underscore\n rel_path = join_paths(base, \"_\" + name);\n abs_path = join_paths(root, rel_path);\n if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });\n // next test exts plus underscore\n for(auto ext : exts) {\n rel_path = join_paths(base, \"_\" + name + ext);\n abs_path = join_paths(root, rel_path);\n if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });\n }\n // next test plain name with exts\n for(auto ext : exts) {\n rel_path = join_paths(base, name + ext);\n abs_path = join_paths(root, rel_path);\n if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });\n }\n // nothing found\n return includes;\n }\n\n std::vector find_files(const std::string& file, const std::vector paths)\n {\n std::vector includes;\n for (std::string path : paths) {\n std::string abs_path(join_paths(path, file));\n if (file_exists(abs_path)) includes.push_back(abs_path);\n }\n return includes;\n }\n\n std::vector find_files(const std::string& file, struct Sass_Compiler* compiler)\n {\n // get the last import entry to get current base directory\n // struct Sass_Options* options = sass_compiler_get_options(compiler);\n Sass_Import_Entry import = sass_compiler_get_last_import(compiler);\n const std::vector& incs = compiler->cpp_ctx->include_paths;\n // create the vector with paths to lookup\n std::vector paths(1 + incs.size());\n paths.push_back(dir_name(import->abs_path));\n paths.insert(paths.end(), incs.begin(), incs.end());\n // dispatch to find files in paths\n return find_files(file, paths);\n }\n\n // helper function to search one file in all include paths\n // this is normally not used internally by libsass (C-API sugar)\n std::string find_file(const std::string& file, const std::vector paths)\n {\n if (file.empty()) return file;\n auto res = find_files(file, paths);\n return res.empty() ? \"\" : res.front();\n }\n\n // helper function to resolve a filename\n std::string find_include(const std::string& file, const std::vector paths)\n {\n // search in every include path for a match\n for (size_t i = 0, S = paths.size(); i < S; ++i)\n {\n std::vector resolved(resolve_includes(paths[i], file));\n if (resolved.size()) return resolved[0].abs_path;\n }\n // nothing found\n return std::string(\"\");\n }\n\n // try to load the given filename\n // returned memory must be freed\n // will auto convert .sass files\n char* read_file(const std::string& path)\n {\n #ifdef _WIN32\n BYTE* pBuffer;\n DWORD dwBytes;\n wchar_t resolved[32768];\n // windows unicode filepaths are encoded in utf16\n std::string abspath(join_paths(get_cwd(), path));\n std::wstring wpath(UTF_8::convert_to_utf16(\"\\\\\\\\?\\\\\" + abspath));\n std::replace(wpath.begin(), wpath.end(), '/', '\\\\');\n DWORD rv = GetFullPathNameW(wpath.c_str(), 32767, resolved, NULL);\n if (rv > 32767) throw Exception::OperationError(\"Path is too long\");\n if (rv == 0) throw Exception::OperationError(\"Path could not be resolved\");\n HANDLE hFile = CreateFileW(resolved, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);\n if (hFile == INVALID_HANDLE_VALUE) return 0;\n DWORD dwFileLength = GetFileSize(hFile, NULL);\n if (dwFileLength == INVALID_FILE_SIZE) return 0;\n // allocate an extra byte for the null char\n // and another one for edge-cases in lexer\n pBuffer = (BYTE*)malloc((dwFileLength+2)*sizeof(BYTE));\n ReadFile(hFile, pBuffer, dwFileLength, &dwBytes, NULL);\n pBuffer[dwFileLength+0] = '\\0';\n pBuffer[dwFileLength+1] = '\\0';\n CloseHandle(hFile);\n // just convert from unsigned char*\n char* contents = (char*) pBuffer;\n #else\n struct stat st;\n if (stat(path.c_str(), &st) == -1 || S_ISDIR(st.st_mode)) return 0;\n std::ifstream file(path.c_str(), std::ios::in | std::ios::binary | std::ios::ate);\n char* contents = 0;\n if (file.is_open()) {\n size_t size = file.tellg();\n // allocate an extra byte for the null char\n // and another one for edge-cases in lexer\n contents = (char*) malloc((size+2)*sizeof(char));\n file.seekg(0, std::ios::beg);\n file.read(contents, size);\n contents[size+0] = '\\0';\n contents[size+1] = '\\0';\n file.close();\n }\n #endif\n std::string extension;\n if (path.length() > 5) {\n extension = path.substr(path.length() - 5, 5);\n }\n for(size_t i=0; i split_path_list(const char* str)\n {\n std::vector paths;\n if (str == NULL) return paths;\n // find delimiter via prelexer (return zero at end)\n const char* end = Prelexer::find_first(str);\n // search until null delimiter\n while (end) {\n // add path from current position to delimiter\n paths.push_back(std::string(str, end - str));\n str = end + 1; // skip delimiter\n end = Prelexer::find_first(str);\n }\n // add path from current position to end\n paths.push_back(std::string(str));\n // return back\n return paths;\n }\n\n }\n}\n" }, { "path": "libsass-build/file.hpp", "content": "#ifndef SASS_FILE_H\n#define SASS_FILE_H\n\n#include \n#include \n\n#include \"sass/context.h\"\n#include \"ast_fwd_decl.hpp\"\n\nnamespace Sass {\n\n namespace File {\n\n // return the current directory\n // always with forward slashes\n std::string get_cwd();\n\n // test if path exists and is a file\n bool file_exists(const std::string& file);\n\n // return if given path is absolute\n // works with *nix and windows paths\n bool is_absolute_path(const std::string& path);\n\n // return only the directory part of path\n std::string dir_name(const std::string& path);\n\n // return only the filename part of path\n std::string base_name(const std::string&);\n\n // do a locigal clean up of the path\n // no physical check on the filesystem\n std::string make_canonical_path (std::string path);\n\n // join two path segments cleanly together\n // but only if right side is not absolute yet\n std::string join_paths(std::string root, std::string name);\n\n // if the relative path is outside of the cwd we want want to\n // show the absolute path in console messages\n std::string path_for_console(const std::string& rel_path, const std::string& abs_path, const std::string& orig_path);\n\n // create an absolute path by resolving relative paths with cwd\n std::string rel2abs(const std::string& path, const std::string& base = \".\", const std::string& cwd = get_cwd());\n\n // create a path that is relative to the given base directory\n // path and base will first be resolved against cwd to make them absolute\n std::string abs2rel(const std::string& path, const std::string& base = \".\", const std::string& cwd = get_cwd());\n\n // helper function to resolve a filename\n // searching without variations in all paths\n std::string find_file(const std::string& file, struct Sass_Compiler* options);\n std::string find_file(const std::string& file, const std::vector paths);\n\n // helper function to resolve a include filename\n // this has the original resolve logic for sass include\n std::string find_include(const std::string& file, const std::vector paths);\n\n // split a path string delimited by semicolons or colons (OS dependent)\n std::vector split_path_list(const char* paths);\n\n // try to load the given filename\n // returned memory must be freed\n // will auto convert .sass files\n char* read_file(const std::string& file);\n\n }\n\n // requested import\n class Importer {\n public:\n // requested import path\n std::string imp_path;\n // parent context path\n std::string ctx_path;\n // base derived from context path\n // this really just acts as a cache\n std::string base_path;\n public:\n Importer(std::string imp_path, std::string ctx_path)\n : imp_path(File::make_canonical_path(imp_path)),\n ctx_path(File::make_canonical_path(ctx_path)),\n base_path(File::dir_name(ctx_path))\n { }\n };\n\n // a resolved include (final import)\n class Include : public Importer {\n public:\n // resolved absolute path\n std::string abs_path;\n public:\n Include(const Importer& imp, std::string abs_path)\n : Importer(imp), abs_path(abs_path)\n { }\n };\n\n // a loaded resource\n class Resource {\n public:\n // the file contents\n char* contents;\n // conected sourcemap\n char* srcmap;\n public:\n Resource(char* contents, char* srcmap)\n : contents(contents), srcmap(srcmap)\n { }\n };\n\n // parsed stylesheet from loaded resource\n class StyleSheet : public Resource {\n public:\n // parsed root block\n Block_Obj root;\n public:\n StyleSheet(const Resource& res, Block_Obj root)\n : Resource(res), root(root)\n { }\n };\n\n namespace File {\n\n static std::vector defaultExtensions = { \".scss\", \".sass\", \".css\" };\n\n std::vector resolve_includes(const std::string& root, const std::string& file,\n const std::vector& exts = defaultExtensions);\n\n }\n\n}\n\n#endif\n" }, { "path": "libsass-build/functions.cpp", "content": "#include \"sass.hpp\"\n#include \"functions.hpp\"\n#include \"ast.hpp\"\n#include \"context.hpp\"\n#include \"backtrace.hpp\"\n#include \"parser.hpp\"\n#include \"constants.hpp\"\n#include \"inspect.hpp\"\n#include \"extend.hpp\"\n#include \"eval.hpp\"\n#include \"util.hpp\"\n#include \"expand.hpp\"\n#include \"operators.hpp\"\n#include \"utf8_string.hpp\"\n#include \"sass/base.h\"\n#include \"utf8.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#ifdef __MINGW32__\n#include \"windows.h\"\n#include \"wincrypt.h\"\n#endif\n\n#define ARG(argname, argtype) get_arg(argname, env, sig, pstate, traces)\n#define ARGM(argname, argtype, ctx) get_arg_m(argname, env, sig, pstate, traces, ctx)\n\n// return a number object (copied since we want to have reduced units)\n#define ARGN(argname) get_arg_n(argname, env, sig, pstate, traces) // Number copy\n\n// special function for weird hsla percent (10px == 10% == 10 != 0.1)\n#define ARGVAL(argname) get_arg_val(argname, env, sig, pstate, traces) // double\n\n// macros for common ranges (u mean unsigned or upper, r for full range)\n#define DARG_U_FACT(argname) get_arg_r(argname, env, sig, pstate, traces, - 0.0, 1.0) // double\n#define DARG_R_FACT(argname) get_arg_r(argname, env, sig, pstate, traces, - 1.0, 1.0) // double\n#define DARG_U_BYTE(argname) get_arg_r(argname, env, sig, pstate, traces, - 0.0, 255.0) // double\n#define DARG_R_BYTE(argname) get_arg_r(argname, env, sig, pstate, traces, - 255.0, 255.0) // double\n#define DARG_U_PRCT(argname) get_arg_r(argname, env, sig, pstate, traces, - 0.0, 100.0) // double\n#define DARG_R_PRCT(argname) get_arg_r(argname, env, sig, pstate, traces, - 100.0, 100.0) // double\n\n// macros for color related inputs (rbg and alpha/opacity values)\n#define COLOR_NUM(argname) color_num(argname, env, sig, pstate, traces) // double\n#define ALPHA_NUM(argname) alpha_num(argname, env, sig, pstate, traces) // double\n\nnamespace Sass {\n using std::stringstream;\n using std::endl;\n\n Definition_Ptr make_native_function(Signature sig, Native_Function func, Context& ctx)\n {\n Parser sig_parser = Parser::from_c_str(sig, ctx, ctx.traces, ParserState(\"[built-in function]\"));\n sig_parser.lex();\n std::string name(Util::normalize_underscores(sig_parser.lexed));\n Parameters_Obj params = sig_parser.parse_parameters();\n return SASS_MEMORY_NEW(Definition,\n ParserState(\"[built-in function]\"),\n sig,\n name,\n params,\n func,\n false);\n }\n\n Definition_Ptr make_c_function(Sass_Function_Entry c_func, Context& ctx)\n {\n using namespace Prelexer;\n\n const char* sig = sass_function_get_signature(c_func);\n Parser sig_parser = Parser::from_c_str(sig, ctx, ctx.traces, ParserState(\"[c function]\"));\n // allow to overload generic callback plus @warn, @error and @debug with custom functions\n sig_parser.lex < alternatives < identifier, exactly <'*'>,\n exactly < Constants::warn_kwd >,\n exactly < Constants::error_kwd >,\n exactly < Constants::debug_kwd >\n > >();\n std::string name(Util::normalize_underscores(sig_parser.lexed));\n Parameters_Obj params = sig_parser.parse_parameters();\n return SASS_MEMORY_NEW(Definition,\n ParserState(\"[c function]\"),\n sig,\n name,\n params,\n c_func,\n false, true);\n }\n\n std::string function_name(Signature sig)\n {\n std::string str(sig);\n return str.substr(0, str.find('('));\n }\n\n namespace Functions {\n\n inline void handle_utf8_error (const ParserState& pstate, Backtraces traces)\n {\n try {\n throw;\n }\n catch (utf8::invalid_code_point) {\n std::string msg(\"utf8::invalid_code_point\");\n error(msg, pstate, traces);\n }\n catch (utf8::not_enough_room) {\n std::string msg(\"utf8::not_enough_room\");\n error(msg, pstate, traces);\n }\n catch (utf8::invalid_utf8) {\n std::string msg(\"utf8::invalid_utf8\");\n error(msg, pstate, traces);\n }\n catch (...) { throw; }\n }\n\n template \n T* get_arg(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)\n {\n // Minimal error handling -- the expectation is that built-ins will be written correctly!\n T* val = Cast(env[argname]);\n if (!val) {\n std::string msg(\"argument `\");\n msg += argname;\n msg += \"` of `\";\n msg += sig;\n msg += \"` must be a \";\n msg += T::type_name();\n error(msg, pstate, traces);\n }\n return val;\n }\n\n Map_Ptr get_arg_m(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx)\n {\n // Minimal error handling -- the expectation is that built-ins will be written correctly!\n Map_Ptr val = Cast(env[argname]);\n if (val) return val;\n\n List_Ptr lval = Cast(env[argname]);\n if (lval && lval->length() == 0) return SASS_MEMORY_NEW(Map, pstate, 0);\n\n // fallback on get_arg for error handling\n val = get_arg(argname, env, sig, pstate, traces);\n return val;\n }\n\n double get_arg_r(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, double lo, double hi)\n {\n // Minimal error handling -- the expectation is that built-ins will be written correctly!\n Number_Ptr val = get_arg(argname, env, sig, pstate, traces);\n Number tmpnr(val);\n tmpnr.reduce();\n double v = tmpnr.value();\n if (!(lo <= v && v <= hi)) {\n std::stringstream msg;\n msg << \"argument `\" << argname << \"` of `\" << sig << \"` must be between \";\n msg << lo << \" and \" << hi;\n error(msg.str(), pstate, traces);\n }\n return v;\n }\n\n Number_Ptr get_arg_n(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)\n {\n // Minimal error handling -- the expectation is that built-ins will be written correctly!\n Number_Ptr val = get_arg(argname, env, sig, pstate, traces);\n val = SASS_MEMORY_COPY(val);\n val->reduce();\n return val;\n }\n\n double get_arg_v(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)\n {\n // Minimal error handling -- the expectation is that built-ins will be written correctly!\n Number_Ptr val = get_arg(argname, env, sig, pstate, traces);\n Number tmpnr(val);\n tmpnr.reduce();\n /*\n if (tmpnr.unit() == \"%\") {\n tmpnr.value(tmpnr.value() / 100);\n tmpnr.numerators.clear();\n } else {\n if (!tmpnr.is_unitless()) error(\"argument \" + argname + \" of `\" + std::string(sig) + \"` must be unitless\", pstate);\n }\n */\n return tmpnr.value();\n }\n\n double get_arg_val(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)\n {\n // Minimal error handling -- the expectation is that built-ins will be written correctly!\n Number_Ptr val = get_arg(argname, env, sig, pstate, traces);\n Number tmpnr(val);\n tmpnr.reduce();\n return tmpnr.value();\n }\n\n double color_num(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)\n {\n Number_Ptr val = get_arg(argname, env, sig, pstate, traces);\n Number tmpnr(val);\n tmpnr.reduce();\n if (tmpnr.unit() == \"%\") {\n return std::min(std::max(tmpnr.value() * 255 / 100.0, 0.0), 255.0);\n } else {\n return std::min(std::max(tmpnr.value(), 0.0), 255.0);\n }\n }\n\n\n inline double alpha_num(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces) {\n Number_Ptr val = get_arg(argname, env, sig, pstate, traces);\n Number tmpnr(val);\n tmpnr.reduce();\n if (tmpnr.unit() == \"%\") {\n return std::min(std::max(tmpnr.value(), 0.0), 100.0);\n } else {\n return std::min(std::max(tmpnr.value(), 0.0), 1.0);\n }\n }\n\n #define ARGSEL(argname, seltype, contextualize) get_arg_sel(argname, env, sig, pstate, traces, ctx)\n\n template \n T get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx);\n\n template <>\n Selector_List_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx) {\n Expression_Obj exp = ARG(argname, Expression);\n if (exp->concrete_type() == Expression::NULL_VAL) {\n std::stringstream msg;\n msg << argname << \": null is not a valid selector: it must be a string,\\n\";\n msg << \"a list of strings, or a list of lists of strings for `\" << function_name(sig) << \"'\";\n error(msg.str(), pstate, traces);\n }\n if (String_Constant_Ptr str = Cast(exp)) {\n str->quote_mark(0);\n }\n std::string exp_src = exp->to_string(ctx.c_options);\n return Parser::parse_selector(exp_src.c_str(), ctx, traces);\n }\n\n template <>\n Compound_Selector_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx) {\n Expression_Obj exp = ARG(argname, Expression);\n if (exp->concrete_type() == Expression::NULL_VAL) {\n std::stringstream msg;\n msg << argname << \": null is not a string for `\" << function_name(sig) << \"'\";\n error(msg.str(), pstate, traces);\n }\n if (String_Constant_Ptr str = Cast(exp)) {\n str->quote_mark(0);\n }\n std::string exp_src = exp->to_string(ctx.c_options);\n Selector_List_Obj sel_list = Parser::parse_selector(exp_src.c_str(), ctx, traces);\n if (sel_list->length() == 0) return NULL;\n Complex_Selector_Obj first = sel_list->first();\n if (!first->tail()) return first->head();\n return first->tail()->head();\n }\n\n #ifdef __MINGW32__\n uint64_t GetSeed()\n {\n HCRYPTPROV hp = 0;\n BYTE rb[8];\n CryptAcquireContext(&hp, 0, 0, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);\n CryptGenRandom(hp, sizeof(rb), rb);\n CryptReleaseContext(hp, 0);\n\n uint64_t seed;\n memcpy(&seed, &rb[0], sizeof(seed));\n\n return seed;\n }\n #else\n uint64_t GetSeed()\n {\n std::random_device rd;\n return rd();\n }\n #endif\n\n // note: the performance of many implementations of\n // random_device degrades sharply once the entropy pool\n // is exhausted. For practical use, random_device is\n // generally only used to seed a PRNG such as mt19937.\n static std::mt19937 rand(static_cast(GetSeed()));\n\n // features\n static std::set features {\n \"global-variable-shadowing\",\n \"extend-selector-pseudoclass\",\n \"at-error\",\n \"units-level-3\",\n \"custom-property\"\n };\n\n ////////////////\n // RGB FUNCTIONS\n ////////////////\n\n inline bool special_number(String_Constant_Ptr s) {\n if (s) {\n std::string calc(\"calc(\");\n std::string var(\"var(\");\n std::string ss(s->value());\n return std::equal(calc.begin(), calc.end(), ss.begin()) ||\n std::equal(var.begin(), var.end(), ss.begin());\n }\n return false;\n }\n\n Signature rgb_sig = \"rgb($red, $green, $blue)\";\n BUILT_IN(rgb)\n {\n if (\n special_number(Cast(env[\"$red\"])) ||\n special_number(Cast(env[\"$green\"])) ||\n special_number(Cast(env[\"$blue\"]))\n ) {\n return SASS_MEMORY_NEW(String_Constant, pstate, \"rgb(\"\n + env[\"$red\"]->to_string()\n + \", \"\n + env[\"$green\"]->to_string()\n + \", \"\n + env[\"$blue\"]->to_string()\n + \")\"\n );\n }\n\n return SASS_MEMORY_NEW(Color,\n pstate,\n COLOR_NUM(\"$red\"),\n COLOR_NUM(\"$green\"),\n COLOR_NUM(\"$blue\"));\n }\n\n Signature rgba_4_sig = \"rgba($red, $green, $blue, $alpha)\";\n BUILT_IN(rgba_4)\n {\n if (\n special_number(Cast(env[\"$red\"])) ||\n special_number(Cast(env[\"$green\"])) ||\n special_number(Cast(env[\"$blue\"])) ||\n special_number(Cast(env[\"$alpha\"]))\n ) {\n return SASS_MEMORY_NEW(String_Constant, pstate, \"rgba(\"\n + env[\"$red\"]->to_string()\n + \", \"\n + env[\"$green\"]->to_string()\n + \", \"\n + env[\"$blue\"]->to_string()\n + \", \"\n + env[\"$alpha\"]->to_string()\n + \")\"\n );\n }\n\n return SASS_MEMORY_NEW(Color,\n pstate,\n COLOR_NUM(\"$red\"),\n COLOR_NUM(\"$green\"),\n COLOR_NUM(\"$blue\"),\n ALPHA_NUM(\"$alpha\"));\n }\n\n Signature rgba_2_sig = \"rgba($color, $alpha)\";\n BUILT_IN(rgba_2)\n {\n if (\n special_number(Cast(env[\"$color\"]))\n ) {\n return SASS_MEMORY_NEW(String_Constant, pstate, \"rgba(\"\n + env[\"$color\"]->to_string()\n + \", \"\n + env[\"$alpha\"]->to_string()\n + \")\"\n );\n }\n\n Color_Ptr c_arg = ARG(\"$color\", Color);\n\n if (\n special_number(Cast(env[\"$alpha\"]))\n ) {\n std::stringstream strm;\n strm << \"rgba(\"\n << (int)c_arg->r() << \", \"\n << (int)c_arg->g() << \", \"\n << (int)c_arg->b() << \", \"\n << env[\"$alpha\"]->to_string()\n << \")\";\n return SASS_MEMORY_NEW(String_Constant, pstate, strm.str());\n }\n\n Color_Ptr new_c = SASS_MEMORY_COPY(c_arg);\n new_c->a(ALPHA_NUM(\"$alpha\"));\n new_c->disp(\"\");\n return new_c;\n }\n\n Signature red_sig = \"red($color)\";\n BUILT_IN(red)\n { return SASS_MEMORY_NEW(Number, pstate, ARG(\"$color\", Color)->r()); }\n\n Signature green_sig = \"green($color)\";\n BUILT_IN(green)\n { return SASS_MEMORY_NEW(Number, pstate, ARG(\"$color\", Color)->g()); }\n\n Signature blue_sig = \"blue($color)\";\n BUILT_IN(blue)\n { return SASS_MEMORY_NEW(Number, pstate, ARG(\"$color\", Color)->b()); }\n\n Color* colormix(Context& ctx, ParserState& pstate, Color* color1, Color* color2, double weight) {\n double p = weight/100;\n double w = 2*p - 1;\n double a = color1->a() - color2->a();\n\n double w1 = (((w * a == -1) ? w : (w + a)/(1 + w*a)) + 1)/2.0;\n double w2 = 1 - w1;\n\n return SASS_MEMORY_NEW(Color,\n pstate,\n Sass::round(w1*color1->r() + w2*color2->r(), ctx.c_options.precision),\n Sass::round(w1*color1->g() + w2*color2->g(), ctx.c_options.precision),\n Sass::round(w1*color1->b() + w2*color2->b(), ctx.c_options.precision),\n color1->a()*p + color2->a()*(1-p));\n }\n\n Signature mix_sig = \"mix($color-1, $color-2, $weight: 50%)\";\n BUILT_IN(mix)\n {\n Color_Obj color1 = ARG(\"$color-1\", Color);\n Color_Obj color2 = ARG(\"$color-2\", Color);\n double weight = DARG_U_PRCT(\"$weight\");\n return colormix(ctx, pstate, color1, color2, weight);\n\n }\n\n ////////////////\n // HSL FUNCTIONS\n ////////////////\n\n // RGB to HSL helper function\n struct HSL { double h; double s; double l; };\n HSL rgb_to_hsl(double r, double g, double b)\n {\n\n // Algorithm from http://en.wikipedia.org/wiki/wHSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV\n r /= 255.0; g /= 255.0; b /= 255.0;\n\n double max = std::max(r, std::max(g, b));\n double min = std::min(r, std::min(g, b));\n double delta = max - min;\n\n double h = 0;\n double s;\n double l = (max + min) / 2.0;\n\n if (NEAR_EQUAL(max, min)) {\n h = s = 0; // achromatic\n }\n else {\n if (l < 0.5) s = delta / (max + min);\n else s = delta / (2.0 - max - min);\n\n if (r == max) h = (g - b) / delta + (g < b ? 6 : 0);\n else if (g == max) h = (b - r) / delta + 2;\n else if (b == max) h = (r - g) / delta + 4;\n }\n\n HSL hsl_struct;\n hsl_struct.h = h / 6 * 360;\n hsl_struct.s = s * 100;\n hsl_struct.l = l * 100;\n\n return hsl_struct;\n }\n\n // hue to RGB helper function\n double h_to_rgb(double m1, double m2, double h) {\n while (h < 0) h += 1;\n while (h > 1) h -= 1;\n if (h*6.0 < 1) return m1 + (m2 - m1)*h*6;\n if (h*2.0 < 1) return m2;\n if (h*3.0 < 2) return m1 + (m2 - m1) * (2.0/3.0 - h)*6;\n return m1;\n }\n\n Color_Ptr hsla_impl(double h, double s, double l, double a, Context& ctx, ParserState pstate)\n {\n h /= 360.0;\n s /= 100.0;\n l /= 100.0;\n\n if (l < 0) l = 0;\n if (s < 0) s = 0;\n if (l > 1) l = 1;\n if (s > 1) s = 1;\n while (h < 0) h += 1;\n while (h > 1) h -= 1;\n\n // if saturation is exacly zero, we loose\n // information for hue, since it will evaluate\n // to zero if converted back from rgb. Setting\n // saturation to a very tiny number solves this.\n if (s == 0) s = 1e-10;\n\n // Algorithm from the CSS3 spec: http://www.w3.org/TR/css3-color/#hsl-color.\n double m2;\n if (l <= 0.5) m2 = l*(s+1.0);\n else m2 = (l+s)-(l*s);\n double m1 = (l*2.0)-m2;\n // round the results -- consider moving this into the Color constructor\n double r = (h_to_rgb(m1, m2, h + 1.0/3.0) * 255.0);\n double g = (h_to_rgb(m1, m2, h) * 255.0);\n double b = (h_to_rgb(m1, m2, h - 1.0/3.0) * 255.0);\n\n return SASS_MEMORY_NEW(Color, pstate, r, g, b, a);\n }\n\n Signature hsl_sig = \"hsl($hue, $saturation, $lightness)\";\n BUILT_IN(hsl)\n {\n if (\n special_number(Cast(env[\"$hue\"])) ||\n special_number(Cast(env[\"$saturation\"])) ||\n special_number(Cast(env[\"$lightness\"]))\n ) {\n return SASS_MEMORY_NEW(String_Constant, pstate, \"hsl(\"\n + env[\"$hue\"]->to_string()\n + \", \"\n + env[\"$saturation\"]->to_string()\n + \", \"\n + env[\"$lightness\"]->to_string()\n + \")\"\n );\n }\n\n return hsla_impl(ARGVAL(\"$hue\"),\n ARGVAL(\"$saturation\"),\n ARGVAL(\"$lightness\"),\n 1.0,\n ctx,\n pstate);\n }\n\n Signature hsla_sig = \"hsla($hue, $saturation, $lightness, $alpha)\";\n BUILT_IN(hsla)\n {\n if (\n special_number(Cast(env[\"$hue\"])) ||\n special_number(Cast(env[\"$saturation\"])) ||\n special_number(Cast(env[\"$lightness\"])) ||\n special_number(Cast(env[\"$alpha\"]))\n ) {\n return SASS_MEMORY_NEW(String_Constant, pstate, \"hsla(\"\n + env[\"$hue\"]->to_string()\n + \", \"\n + env[\"$saturation\"]->to_string()\n + \", \"\n + env[\"$lightness\"]->to_string()\n + \", \"\n + env[\"$alpha\"]->to_string()\n + \")\"\n );\n }\n\n return hsla_impl(ARGVAL(\"$hue\"),\n ARGVAL(\"$saturation\"),\n ARGVAL(\"$lightness\"),\n ARGVAL(\"$alpha\"),\n ctx,\n pstate);\n }\n\n Signature hue_sig = \"hue($color)\";\n BUILT_IN(hue)\n {\n Color_Ptr rgb_color = ARG(\"$color\", Color);\n HSL hsl_color = rgb_to_hsl(rgb_color->r(),\n rgb_color->g(),\n rgb_color->b());\n return SASS_MEMORY_NEW(Number, pstate, hsl_color.h, \"deg\");\n }\n\n Signature saturation_sig = \"saturation($color)\";\n BUILT_IN(saturation)\n {\n Color_Ptr rgb_color = ARG(\"$color\", Color);\n HSL hsl_color = rgb_to_hsl(rgb_color->r(),\n rgb_color->g(),\n rgb_color->b());\n return SASS_MEMORY_NEW(Number, pstate, hsl_color.s, \"%\");\n }\n\n Signature lightness_sig = \"lightness($color)\";\n BUILT_IN(lightness)\n {\n Color_Ptr rgb_color = ARG(\"$color\", Color);\n HSL hsl_color = rgb_to_hsl(rgb_color->r(),\n rgb_color->g(),\n rgb_color->b());\n return SASS_MEMORY_NEW(Number, pstate, hsl_color.l, \"%\");\n }\n\n Signature adjust_hue_sig = \"adjust-hue($color, $degrees)\";\n BUILT_IN(adjust_hue)\n {\n Color_Ptr rgb_color = ARG(\"$color\", Color);\n double degrees = ARGVAL(\"$degrees\");\n HSL hsl_color = rgb_to_hsl(rgb_color->r(),\n rgb_color->g(),\n rgb_color->b());\n return hsla_impl(hsl_color.h + degrees,\n hsl_color.s,\n hsl_color.l,\n rgb_color->a(),\n ctx,\n pstate);\n }\n\n Signature lighten_sig = \"lighten($color, $amount)\";\n BUILT_IN(lighten)\n {\n Color_Ptr rgb_color = ARG(\"$color\", Color);\n double amount = DARG_U_PRCT(\"$amount\");\n HSL hsl_color = rgb_to_hsl(rgb_color->r(),\n rgb_color->g(),\n rgb_color->b());\n //Check lightness is not negative before lighten it\n double hslcolorL = hsl_color.l;\n if (hslcolorL < 0) {\n hslcolorL = 0;\n }\n\n return hsla_impl(hsl_color.h,\n hsl_color.s,\n hslcolorL + amount,\n rgb_color->a(),\n ctx,\n pstate);\n }\n\n Signature darken_sig = \"darken($color, $amount)\";\n BUILT_IN(darken)\n {\n Color_Ptr rgb_color = ARG(\"$color\", Color);\n double amount = DARG_U_PRCT(\"$amount\");\n HSL hsl_color = rgb_to_hsl(rgb_color->r(),\n rgb_color->g(),\n rgb_color->b());\n\n //Check lightness if not over 100, before darken it\n double hslcolorL = hsl_color.l;\n if (hslcolorL > 100) {\n hslcolorL = 100;\n }\n\n return hsla_impl(hsl_color.h,\n hsl_color.s,\n hslcolorL - amount,\n rgb_color->a(),\n ctx,\n pstate);\n }\n\n Signature saturate_sig = \"saturate($color, $amount: false)\";\n BUILT_IN(saturate)\n {\n // CSS3 filter function overload: pass literal through directly\n if (!Cast(env[\"$amount\"])) {\n return SASS_MEMORY_NEW(String_Quoted, pstate, \"saturate(\" + env[\"$color\"]->to_string(ctx.c_options) + \")\");\n }\n\n double amount = DARG_U_PRCT(\"$amount\");\n Color_Ptr rgb_color = ARG(\"$color\", Color);\n HSL hsl_color = rgb_to_hsl(rgb_color->r(),\n rgb_color->g(),\n rgb_color->b());\n\n double hslcolorS = hsl_color.s + amount;\n\n // Saturation cannot be below 0 or above 100\n if (hslcolorS < 0) {\n hslcolorS = 0;\n }\n if (hslcolorS > 100) {\n hslcolorS = 100;\n }\n\n return hsla_impl(hsl_color.h,\n hslcolorS,\n hsl_color.l,\n rgb_color->a(),\n ctx,\n pstate);\n }\n\n Signature desaturate_sig = \"desaturate($color, $amount)\";\n BUILT_IN(desaturate)\n {\n Color_Ptr rgb_color = ARG(\"$color\", Color);\n double amount = DARG_U_PRCT(\"$amount\");\n HSL hsl_color = rgb_to_hsl(rgb_color->r(),\n rgb_color->g(),\n rgb_color->b());\n\n double hslcolorS = hsl_color.s - amount;\n\n // Saturation cannot be below 0 or above 100\n if (hslcolorS <= 0) {\n hslcolorS = 0;\n }\n if (hslcolorS > 100) {\n hslcolorS = 100;\n }\n\n return hsla_impl(hsl_color.h,\n hslcolorS,\n hsl_color.l,\n rgb_color->a(),\n ctx,\n pstate);\n }\n\n Signature grayscale_sig = \"grayscale($color)\";\n BUILT_IN(grayscale)\n {\n // CSS3 filter function overload: pass literal through directly\n Number_Ptr amount = Cast(env[\"$color\"]);\n if (amount) {\n return SASS_MEMORY_NEW(String_Quoted, pstate, \"grayscale(\" + amount->to_string(ctx.c_options) + \")\");\n }\n\n Color_Ptr rgb_color = ARG(\"$color\", Color);\n HSL hsl_color = rgb_to_hsl(rgb_color->r(),\n rgb_color->g(),\n rgb_color->b());\n return hsla_impl(hsl_color.h,\n 0.0,\n hsl_color.l,\n rgb_color->a(),\n ctx,\n pstate);\n }\n\n Signature complement_sig = \"complement($color)\";\n BUILT_IN(complement)\n {\n Color_Ptr rgb_color = ARG(\"$color\", Color);\n HSL hsl_color = rgb_to_hsl(rgb_color->r(),\n rgb_color->g(),\n rgb_color->b());\n return hsla_impl(hsl_color.h - 180.0,\n hsl_color.s,\n hsl_color.l,\n rgb_color->a(),\n ctx,\n pstate);\n }\n\n Signature invert_sig = \"invert($color, $weight: 100%)\";\n BUILT_IN(invert)\n {\n // CSS3 filter function overload: pass literal through directly\n Number_Ptr amount = Cast(env[\"$color\"]);\n if (amount) {\n return SASS_MEMORY_NEW(String_Quoted, pstate, \"invert(\" + amount->to_string(ctx.c_options) + \")\");\n }\n\n double weight = DARG_U_PRCT(\"$weight\");\n Color_Ptr rgb_color = ARG(\"$color\", Color);\n Color_Obj inv = SASS_MEMORY_NEW(Color,\n pstate,\n 255 - rgb_color->r(),\n 255 - rgb_color->g(),\n 255 - rgb_color->b(),\n rgb_color->a());\n return colormix(ctx, pstate, inv, rgb_color, weight);\n }\n\n ////////////////////\n // OPACITY FUNCTIONS\n ////////////////////\n Signature alpha_sig = \"alpha($color)\";\n Signature opacity_sig = \"opacity($color)\";\n BUILT_IN(alpha)\n {\n String_Constant_Ptr ie_kwd = Cast(env[\"$color\"]);\n if (ie_kwd) {\n return SASS_MEMORY_NEW(String_Quoted, pstate, \"alpha(\" + ie_kwd->value() + \")\");\n }\n\n // CSS3 filter function overload: pass literal through directly\n Number_Ptr amount = Cast(env[\"$color\"]);\n if (amount) {\n return SASS_MEMORY_NEW(String_Quoted, pstate, \"opacity(\" + amount->to_string(ctx.c_options) + \")\");\n }\n\n return SASS_MEMORY_NEW(Number, pstate, ARG(\"$color\", Color)->a());\n }\n\n Signature opacify_sig = \"opacify($color, $amount)\";\n Signature fade_in_sig = \"fade-in($color, $amount)\";\n BUILT_IN(opacify)\n {\n Color_Ptr color = ARG(\"$color\", Color);\n double amount = DARG_U_FACT(\"$amount\");\n double alpha = std::min(color->a() + amount, 1.0);\n return SASS_MEMORY_NEW(Color,\n pstate,\n color->r(),\n color->g(),\n color->b(),\n alpha);\n }\n\n Signature transparentize_sig = \"transparentize($color, $amount)\";\n Signature fade_out_sig = \"fade-out($color, $amount)\";\n BUILT_IN(transparentize)\n {\n Color_Ptr color = ARG(\"$color\", Color);\n double amount = DARG_U_FACT(\"$amount\");\n double alpha = std::max(color->a() - amount, 0.0);\n return SASS_MEMORY_NEW(Color,\n pstate,\n color->r(),\n color->g(),\n color->b(),\n alpha);\n }\n\n ////////////////////////\n // OTHER COLOR FUNCTIONS\n ////////////////////////\n\n Signature adjust_color_sig = \"adjust-color($color, $red: false, $green: false, $blue: false, $hue: false, $saturation: false, $lightness: false, $alpha: false)\";\n BUILT_IN(adjust_color)\n {\n Color_Ptr color = ARG(\"$color\", Color);\n Number_Ptr r = Cast(env[\"$red\"]);\n Number_Ptr g = Cast(env[\"$green\"]);\n Number_Ptr b = Cast(env[\"$blue\"]);\n Number_Ptr h = Cast(env[\"$hue\"]);\n Number_Ptr s = Cast(env[\"$saturation\"]);\n Number_Ptr l = Cast(env[\"$lightness\"]);\n Number_Ptr a = Cast(env[\"$alpha\"]);\n\n bool rgb = r || g || b;\n bool hsl = h || s || l;\n\n if (rgb && hsl) {\n error(\"Cannot specify HSL and RGB values for a color at the same time for `adjust-color'\", pstate, traces);\n }\n if (rgb) {\n double rr = r ? DARG_R_BYTE(\"$red\") : 0;\n double gg = g ? DARG_R_BYTE(\"$green\") : 0;\n double bb = b ? DARG_R_BYTE(\"$blue\") : 0;\n double aa = a ? DARG_R_FACT(\"$alpha\") : 0;\n return SASS_MEMORY_NEW(Color,\n pstate,\n color->r() + rr,\n color->g() + gg,\n color->b() + bb,\n color->a() + aa);\n }\n if (hsl) {\n HSL hsl_struct = rgb_to_hsl(color->r(), color->g(), color->b());\n double ss = s ? DARG_R_PRCT(\"$saturation\") : 0;\n double ll = l ? DARG_R_PRCT(\"$lightness\") : 0;\n double aa = a ? DARG_R_FACT(\"$alpha\") : 0;\n return hsla_impl(hsl_struct.h + (h ? h->value() : 0),\n hsl_struct.s + ss,\n hsl_struct.l + ll,\n color->a() + aa,\n ctx,\n pstate);\n }\n if (a) {\n return SASS_MEMORY_NEW(Color,\n pstate,\n color->r(),\n color->g(),\n color->b(),\n color->a() + (a ? a->value() : 0));\n }\n error(\"not enough arguments for `adjust-color'\", pstate, traces);\n // unreachable\n return color;\n }\n\n Signature scale_color_sig = \"scale-color($color, $red: false, $green: false, $blue: false, $hue: false, $saturation: false, $lightness: false, $alpha: false)\";\n BUILT_IN(scale_color)\n {\n Color_Ptr color = ARG(\"$color\", Color);\n Number_Ptr r = Cast(env[\"$red\"]);\n Number_Ptr g = Cast(env[\"$green\"]);\n Number_Ptr b = Cast(env[\"$blue\"]);\n Number_Ptr h = Cast(env[\"$hue\"]);\n Number_Ptr s = Cast(env[\"$saturation\"]);\n Number_Ptr l = Cast(env[\"$lightness\"]);\n Number_Ptr a = Cast(env[\"$alpha\"]);\n\n bool rgb = r || g || b;\n bool hsl = h || s || l;\n\n if (rgb && hsl) {\n error(\"Cannot specify HSL and RGB values for a color at the same time for `scale-color'\", pstate, traces);\n }\n if (rgb) {\n double rscale = (r ? DARG_R_PRCT(\"$red\") : 0.0) / 100.0;\n double gscale = (g ? DARG_R_PRCT(\"$green\") : 0.0) / 100.0;\n double bscale = (b ? DARG_R_PRCT(\"$blue\") : 0.0) / 100.0;\n double ascale = (a ? DARG_R_PRCT(\"$alpha\") : 0.0) / 100.0;\n return SASS_MEMORY_NEW(Color,\n pstate,\n color->r() + rscale * (rscale > 0.0 ? 255 - color->r() : color->r()),\n color->g() + gscale * (gscale > 0.0 ? 255 - color->g() : color->g()),\n color->b() + bscale * (bscale > 0.0 ? 255 - color->b() : color->b()),\n color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a()));\n }\n if (hsl) {\n double hscale = (h ? DARG_R_PRCT(\"$hue\") : 0.0) / 100.0;\n double sscale = (s ? DARG_R_PRCT(\"$saturation\") : 0.0) / 100.0;\n double lscale = (l ? DARG_R_PRCT(\"$lightness\") : 0.0) / 100.0;\n double ascale = (a ? DARG_R_PRCT(\"$alpha\") : 0.0) / 100.0;\n HSL hsl_struct = rgb_to_hsl(color->r(), color->g(), color->b());\n hsl_struct.h += hscale * (hscale > 0.0 ? 360.0 - hsl_struct.h : hsl_struct.h);\n hsl_struct.s += sscale * (sscale > 0.0 ? 100.0 - hsl_struct.s : hsl_struct.s);\n hsl_struct.l += lscale * (lscale > 0.0 ? 100.0 - hsl_struct.l : hsl_struct.l);\n double alpha = color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a());\n return hsla_impl(hsl_struct.h, hsl_struct.s, hsl_struct.l, alpha, ctx, pstate);\n }\n if (a) {\n double ascale = (DARG_R_PRCT(\"$alpha\")) / 100.0;\n return SASS_MEMORY_NEW(Color,\n pstate,\n color->r(),\n color->g(),\n color->b(),\n color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a()));\n }\n error(\"not enough arguments for `scale-color'\", pstate, traces);\n // unreachable\n return color;\n }\n\n Signature change_color_sig = \"change-color($color, $red: false, $green: false, $blue: false, $hue: false, $saturation: false, $lightness: false, $alpha: false)\";\n BUILT_IN(change_color)\n {\n Color_Ptr color = ARG(\"$color\", Color);\n Number_Ptr r = Cast(env[\"$red\"]);\n Number_Ptr g = Cast(env[\"$green\"]);\n Number_Ptr b = Cast(env[\"$blue\"]);\n Number_Ptr h = Cast(env[\"$hue\"]);\n Number_Ptr s = Cast(env[\"$saturation\"]);\n Number_Ptr l = Cast(env[\"$lightness\"]);\n Number_Ptr a = Cast(env[\"$alpha\"]);\n\n bool rgb = r || g || b;\n bool hsl = h || s || l;\n\n if (rgb && hsl) {\n error(\"Cannot specify HSL and RGB values for a color at the same time for `change-color'\", pstate, traces);\n }\n if (rgb) {\n return SASS_MEMORY_NEW(Color,\n pstate,\n r ? DARG_U_BYTE(\"$red\") : color->r(),\n g ? DARG_U_BYTE(\"$green\") : color->g(),\n b ? DARG_U_BYTE(\"$blue\") : color->b(),\n a ? DARG_U_BYTE(\"$alpha\") : color->a());\n }\n if (hsl) {\n HSL hsl_struct = rgb_to_hsl(color->r(), color->g(), color->b());\n if (h) hsl_struct.h = std::fmod(h->value(), 360.0);\n if (s) hsl_struct.s = DARG_U_PRCT(\"$saturation\");\n if (l) hsl_struct.l = DARG_U_PRCT(\"$lightness\");\n double alpha = a ? DARG_U_FACT(\"$alpha\") : color->a();\n return hsla_impl(hsl_struct.h, hsl_struct.s, hsl_struct.l, alpha, ctx, pstate);\n }\n if (a) {\n double alpha = DARG_U_FACT(\"$alpha\");\n return SASS_MEMORY_NEW(Color,\n pstate,\n color->r(),\n color->g(),\n color->b(),\n alpha);\n }\n error(\"not enough arguments for `change-color'\", pstate, traces);\n // unreachable\n return color;\n }\n\n template \n static double cap_channel(double c) {\n if (c > range) return range;\n else if (c < 0) return 0;\n else return c;\n }\n\n Signature ie_hex_str_sig = \"ie-hex-str($color)\";\n BUILT_IN(ie_hex_str)\n {\n Color_Ptr c = ARG(\"$color\", Color);\n double r = cap_channel<0xff>(c->r());\n double g = cap_channel<0xff>(c->g());\n double b = cap_channel<0xff>(c->b());\n double a = cap_channel<1> (c->a()) * 255;\n\n std::stringstream ss;\n ss << '#' << std::setw(2) << std::setfill('0');\n ss << std::hex << std::setw(2) << static_cast(Sass::round(a, ctx.c_options.precision));\n ss << std::hex << std::setw(2) << static_cast(Sass::round(r, ctx.c_options.precision));\n ss << std::hex << std::setw(2) << static_cast(Sass::round(g, ctx.c_options.precision));\n ss << std::hex << std::setw(2) << static_cast(Sass::round(b, ctx.c_options.precision));\n\n std::string result(ss.str());\n for (size_t i = 0, L = result.length(); i < L; ++i) {\n result[i] = std::toupper(result[i]);\n }\n return SASS_MEMORY_NEW(String_Quoted, pstate, result);\n }\n\n ///////////////////\n // STRING FUNCTIONS\n ///////////////////\n\n Signature unquote_sig = \"unquote($string)\";\n BUILT_IN(sass_unquote)\n {\n AST_Node_Obj arg = env[\"$string\"];\n if (String_Quoted_Ptr string_quoted = Cast(arg)) {\n String_Constant_Ptr result = SASS_MEMORY_NEW(String_Constant, pstate, string_quoted->value());\n // remember if the string was quoted (color tokens)\n result->is_delayed(true); // delay colors\n return result;\n }\n else if (String_Constant_Ptr str = Cast(arg)) {\n return str;\n }\n else if (Expression_Ptr ex = Cast(arg)) {\n Sass_Output_Style oldstyle = ctx.c_options.output_style;\n ctx.c_options.output_style = SASS_STYLE_NESTED;\n std::string val(arg->to_string(ctx.c_options));\n val = Cast(arg) ? \"null\" : val;\n ctx.c_options.output_style = oldstyle;\n\n deprecated_function(\"Passing \" + val + \", a non-string value, to unquote()\", pstate);\n return ex;\n }\n throw std::runtime_error(\"Invalid Data Type for unquote\");\n }\n\n Signature quote_sig = \"quote($string)\";\n BUILT_IN(sass_quote)\n {\n AST_Node_Obj arg = env[\"$string\"];\n // only set quote mark to true if already a string\n if (String_Quoted_Ptr qstr = Cast(arg)) {\n qstr->quote_mark('*');\n return qstr;\n }\n // all other nodes must be converted to a string node\n std::string str(quote(arg->to_string(ctx.c_options), String_Constant::double_quote()));\n String_Quoted_Ptr result = SASS_MEMORY_NEW(String_Quoted, pstate, str);\n result->quote_mark('*');\n return result;\n }\n\n\n Signature str_length_sig = \"str-length($string)\";\n BUILT_IN(str_length)\n {\n size_t len = std::string::npos;\n try {\n String_Constant_Ptr s = ARG(\"$string\", String_Constant);\n len = UTF_8::code_point_count(s->value(), 0, s->value().size());\n\n }\n // handle any invalid utf8 errors\n // other errors will be re-thrown\n catch (...) { handle_utf8_error(pstate, traces); }\n // return something even if we had an error (-1)\n return SASS_MEMORY_NEW(Number, pstate, (double)len);\n }\n\n Signature str_insert_sig = \"str-insert($string, $insert, $index)\";\n BUILT_IN(str_insert)\n {\n std::string str;\n try {\n String_Constant_Ptr s = ARG(\"$string\", String_Constant);\n str = s->value();\n str = unquote(str);\n String_Constant_Ptr i = ARG(\"$insert\", String_Constant);\n std::string ins = i->value();\n ins = unquote(ins);\n double index = ARGVAL(\"$index\");\n size_t len = UTF_8::code_point_count(str, 0, str.size());\n\n if (index > 0 && index <= len) {\n // positive and within string length\n str.insert(UTF_8::offset_at_position(str, static_cast(index) - 1), ins);\n }\n else if (index > len) {\n // positive and past string length\n str += ins;\n }\n else if (index == 0) {\n str = ins + str;\n }\n else if (std::abs(index) <= len) {\n // negative and within string length\n index += len + 1;\n str.insert(UTF_8::offset_at_position(str, static_cast(index)), ins);\n }\n else {\n // negative and past string length\n str = ins + str;\n }\n\n if (String_Quoted_Ptr ss = Cast(s)) {\n if (ss->quote_mark()) str = quote(str);\n }\n }\n // handle any invalid utf8 errors\n // other errors will be re-thrown\n catch (...) { handle_utf8_error(pstate, traces); }\n return SASS_MEMORY_NEW(String_Quoted, pstate, str);\n }\n\n Signature str_index_sig = \"str-index($string, $substring)\";\n BUILT_IN(str_index)\n {\n size_t index = std::string::npos;\n try {\n String_Constant_Ptr s = ARG(\"$string\", String_Constant);\n String_Constant_Ptr t = ARG(\"$substring\", String_Constant);\n std::string str = s->value();\n str = unquote(str);\n std::string substr = t->value();\n substr = unquote(substr);\n\n size_t c_index = str.find(substr);\n if(c_index == std::string::npos) {\n return SASS_MEMORY_NEW(Null, pstate);\n }\n index = UTF_8::code_point_count(str, 0, c_index) + 1;\n }\n // handle any invalid utf8 errors\n // other errors will be re-thrown\n catch (...) { handle_utf8_error(pstate, traces); }\n // return something even if we had an error (-1)\n return SASS_MEMORY_NEW(Number, pstate, (double)index);\n }\n\n Signature str_slice_sig = \"str-slice($string, $start-at, $end-at:-1)\";\n BUILT_IN(str_slice)\n {\n std::string newstr;\n try {\n String_Constant_Ptr s = ARG(\"$string\", String_Constant);\n double start_at = ARGVAL(\"$start-at\");\n double end_at = ARGVAL(\"$end-at\");\n String_Quoted_Ptr ss = Cast(s);\n\n std::string str = unquote(s->value());\n\n size_t size = utf8::distance(str.begin(), str.end());\n\n if (!Cast(env[\"$end-at\"])) {\n end_at = -1;\n }\n\n if (end_at == 0 || (end_at + size) < 0) {\n if (ss && ss->quote_mark()) newstr = quote(\"\");\n return SASS_MEMORY_NEW(String_Quoted, pstate, newstr);\n }\n\n if (end_at < 0) {\n end_at += size + 1;\n if (end_at == 0) end_at = 1;\n }\n if (end_at > size) { end_at = (double)size; }\n if (start_at < 0) {\n start_at += size + 1;\n if (start_at < 0) start_at = 0;\n }\n else if (start_at == 0) { ++ start_at; }\n\n if (start_at <= end_at)\n {\n std::string::iterator start = str.begin();\n utf8::advance(start, start_at - 1, str.end());\n std::string::iterator end = start;\n utf8::advance(end, end_at - start_at + 1, str.end());\n newstr = std::string(start, end);\n }\n if (ss) {\n if(ss->quote_mark()) newstr = quote(newstr);\n }\n }\n // handle any invalid utf8 errors\n // other errors will be re-thrown\n catch (...) { handle_utf8_error(pstate, traces); }\n return SASS_MEMORY_NEW(String_Quoted, pstate, newstr);\n }\n\n Signature to_upper_case_sig = \"to-upper-case($string)\";\n BUILT_IN(to_upper_case)\n {\n String_Constant_Ptr s = ARG(\"$string\", String_Constant);\n std::string str = s->value();\n\n for (size_t i = 0, L = str.length(); i < L; ++i) {\n if (Sass::Util::isAscii(str[i])) {\n str[i] = std::toupper(str[i]);\n }\n }\n\n if (String_Quoted_Ptr ss = Cast(s)) {\n String_Quoted_Ptr cpy = SASS_MEMORY_COPY(ss);\n cpy->value(str);\n return cpy;\n } else {\n return SASS_MEMORY_NEW(String_Quoted, pstate, str);\n }\n }\n\n Signature to_lower_case_sig = \"to-lower-case($string)\";\n BUILT_IN(to_lower_case)\n {\n String_Constant_Ptr s = ARG(\"$string\", String_Constant);\n std::string str = s->value();\n\n for (size_t i = 0, L = str.length(); i < L; ++i) {\n if (Sass::Util::isAscii(str[i])) {\n str[i] = std::tolower(str[i]);\n }\n }\n\n if (String_Quoted_Ptr ss = Cast(s)) {\n String_Quoted_Ptr cpy = SASS_MEMORY_COPY(ss);\n cpy->value(str);\n return cpy;\n } else {\n return SASS_MEMORY_NEW(String_Quoted, pstate, str);\n }\n }\n\n ///////////////////\n // NUMBER FUNCTIONS\n ///////////////////\n\n Signature percentage_sig = \"percentage($number)\";\n BUILT_IN(percentage)\n {\n Number_Obj n = ARGN(\"$number\");\n if (!n->is_unitless()) error(\"argument $number of `\" + std::string(sig) + \"` must be unitless\", pstate, traces);\n return SASS_MEMORY_NEW(Number, pstate, n->value() * 100, \"%\");\n }\n\n Signature round_sig = \"round($number)\";\n BUILT_IN(round)\n {\n Number_Obj r = ARGN(\"$number\");\n r->value(Sass::round(r->value(), ctx.c_options.precision));\n r->pstate(pstate);\n return r.detach();\n }\n\n Signature ceil_sig = \"ceil($number)\";\n BUILT_IN(ceil)\n {\n Number_Obj r = ARGN(\"$number\");\n r->value(std::ceil(r->value()));\n r->pstate(pstate);\n return r.detach();\n }\n\n Signature floor_sig = \"floor($number)\";\n BUILT_IN(floor)\n {\n Number_Obj r = ARGN(\"$number\");\n r->value(std::floor(r->value()));\n r->pstate(pstate);\n return r.detach();\n }\n\n Signature abs_sig = \"abs($number)\";\n BUILT_IN(abs)\n {\n Number_Obj r = ARGN(\"$number\");\n r->value(std::abs(r->value()));\n r->pstate(pstate);\n return r.detach();\n }\n\n Signature min_sig = \"min($numbers...)\";\n BUILT_IN(min)\n {\n List_Ptr arglist = ARG(\"$numbers\", List);\n Number_Obj least = NULL;\n for (size_t i = 0, L = arglist->length(); i < L; ++i) {\n Expression_Obj val = arglist->value_at_index(i);\n Number_Obj xi = Cast(val);\n if (!xi) {\n error(\"\\\"\" + val->to_string(ctx.c_options) + \"\\\" is not a number for `min'\", pstate, traces);\n }\n if (least) {\n if (*xi < *least) least = xi;\n } else least = xi;\n }\n return least.detach();\n }\n\n Signature max_sig = \"max($numbers...)\";\n BUILT_IN(max)\n {\n List_Ptr arglist = ARG(\"$numbers\", List);\n Number_Obj greatest = NULL;\n for (size_t i = 0, L = arglist->length(); i < L; ++i) {\n Expression_Obj val = arglist->value_at_index(i);\n Number_Obj xi = Cast(val);\n if (!xi) {\n error(\"\\\"\" + val->to_string(ctx.c_options) + \"\\\" is not a number for `max'\", pstate, traces);\n }\n if (greatest) {\n if (*greatest < *xi) greatest = xi;\n } else greatest = xi;\n }\n return greatest.detach();\n }\n\n Signature random_sig = \"random($limit:false)\";\n BUILT_IN(random)\n {\n AST_Node_Obj arg = env[\"$limit\"];\n Value_Ptr v = Cast(arg);\n Number_Ptr l = Cast(arg);\n Boolean_Ptr b = Cast(arg);\n if (l) {\n double lv = l->value();\n if (lv < 1) {\n stringstream err;\n err << \"$limit \" << lv << \" must be greater than or equal to 1 for `random'\";\n error(err.str(), pstate, traces);\n }\n bool eq_int = std::fabs(trunc(lv) - lv) < NUMBER_EPSILON;\n if (!eq_int) {\n stringstream err;\n err << \"Expected $limit to be an integer but got \" << lv << \" for `random'\";\n error(err.str(), pstate, traces);\n }\n std::uniform_real_distribution<> distributor(1, lv + 1);\n uint_fast32_t distributed = static_cast(distributor(rand));\n return SASS_MEMORY_NEW(Number, pstate, (double)distributed);\n }\n else if (b) {\n std::uniform_real_distribution<> distributor(0, 1);\n double distributed = static_cast(distributor(rand));\n return SASS_MEMORY_NEW(Number, pstate, distributed);\n } else if (v) {\n traces.push_back(Backtrace(pstate));\n throw Exception::InvalidArgumentType(pstate, traces, \"random\", \"$limit\", \"number\", v);\n } else {\n traces.push_back(Backtrace(pstate));\n throw Exception::InvalidArgumentType(pstate, traces, \"random\", \"$limit\", \"number\");\n }\n }\n\n /////////////////\n // LIST FUNCTIONS\n /////////////////\n\n Signature length_sig = \"length($list)\";\n BUILT_IN(length)\n {\n if (Selector_List_Ptr sl = Cast(env[\"$list\"])) {\n return SASS_MEMORY_NEW(Number, pstate, (double)sl->length());\n }\n Expression_Ptr v = ARG(\"$list\", Expression);\n if (v->concrete_type() == Expression::MAP) {\n Map_Ptr map = Cast(env[\"$list\"]);\n return SASS_MEMORY_NEW(Number, pstate, (double)(map ? map->length() : 1));\n }\n if (v->concrete_type() == Expression::SELECTOR) {\n if (Compound_Selector_Ptr h = Cast(v)) {\n return SASS_MEMORY_NEW(Number, pstate, (double)h->length());\n } else if (Selector_List_Ptr ls = Cast(v)) {\n return SASS_MEMORY_NEW(Number, pstate, (double)ls->length());\n } else {\n return SASS_MEMORY_NEW(Number, pstate, 1);\n }\n }\n\n List_Ptr list = Cast(env[\"$list\"]);\n return SASS_MEMORY_NEW(Number,\n pstate,\n (double)(list ? list->size() : 1));\n }\n\n Signature nth_sig = \"nth($list, $n)\";\n BUILT_IN(nth)\n {\n double nr = ARGVAL(\"$n\");\n Map_Ptr m = Cast(env[\"$list\"]);\n if (Selector_List_Ptr sl = Cast(env[\"$list\"])) {\n size_t len = m ? m->length() : sl->length();\n bool empty = m ? m->empty() : sl->empty();\n if (empty) error(\"argument `$list` of `\" + std::string(sig) + \"` must not be empty\", pstate, traces);\n double index = std::floor(nr < 0 ? len + nr : nr - 1);\n if (index < 0 || index > len - 1) error(\"index out of bounds for `\" + std::string(sig) + \"`\", pstate, traces);\n // return (*sl)[static_cast(index)];\n Listize listize;\n return (*sl)[static_cast(index)]->perform(&listize);\n }\n List_Obj l = Cast(env[\"$list\"]);\n if (nr == 0) error(\"argument `$n` of `\" + std::string(sig) + \"` must be non-zero\", pstate, traces);\n // if the argument isn't a list, then wrap it in a singleton list\n if (!m && !l) {\n l = SASS_MEMORY_NEW(List, pstate, 1);\n l->append(ARG(\"$list\", Expression));\n }\n size_t len = m ? m->length() : l->length();\n bool empty = m ? m->empty() : l->empty();\n if (empty) error(\"argument `$list` of `\" + std::string(sig) + \"` must not be empty\", pstate, traces);\n double index = std::floor(nr < 0 ? len + nr : nr - 1);\n if (index < 0 || index > len - 1) error(\"index out of bounds for `\" + std::string(sig) + \"`\", pstate, traces);\n\n if (m) {\n l = SASS_MEMORY_NEW(List, pstate, 1);\n l->append(m->keys()[static_cast(index)]);\n l->append(m->at(m->keys()[static_cast(index)]));\n return l.detach();\n }\n else {\n Expression_Obj rv = l->value_at_index(static_cast(index));\n rv->set_delayed(false);\n return rv.detach();\n }\n }\n\n Signature set_nth_sig = \"set-nth($list, $n, $value)\";\n BUILT_IN(set_nth)\n {\n Map_Obj m = Cast(env[\"$list\"]);\n List_Obj l = Cast(env[\"$list\"]);\n Number_Obj n = ARG(\"$n\", Number);\n Expression_Obj v = ARG(\"$value\", Expression);\n if (!l) {\n l = SASS_MEMORY_NEW(List, pstate, 1);\n l->append(ARG(\"$list\", Expression));\n }\n if (m) {\n l = m->to_list(pstate);\n }\n if (l->empty()) error(\"argument `$list` of `\" + std::string(sig) + \"` must not be empty\", pstate, traces);\n double index = std::floor(n->value() < 0 ? l->length() + n->value() : n->value() - 1);\n if (index < 0 || index > l->length() - 1) error(\"index out of bounds for `\" + std::string(sig) + \"`\", pstate, traces);\n List_Ptr result = SASS_MEMORY_NEW(List, pstate, l->length(), l->separator(), false, l->is_bracketed());\n for (size_t i = 0, L = l->length(); i < L; ++i) {\n result->append(((i == index) ? v : (*l)[i]));\n }\n return result;\n }\n\n Signature index_sig = \"index($list, $value)\";\n BUILT_IN(index)\n {\n Map_Obj m = Cast(env[\"$list\"]);\n List_Obj l = Cast(env[\"$list\"]);\n Expression_Obj v = ARG(\"$value\", Expression);\n if (!l) {\n l = SASS_MEMORY_NEW(List, pstate, 1);\n l->append(ARG(\"$list\", Expression));\n }\n if (m) {\n l = m->to_list(pstate);\n }\n for (size_t i = 0, L = l->length(); i < L; ++i) {\n if (Operators::eq(l->value_at_index(i), v)) return SASS_MEMORY_NEW(Number, pstate, (double)(i+1));\n }\n return SASS_MEMORY_NEW(Null, pstate);\n }\n\n Signature join_sig = \"join($list1, $list2, $separator: auto, $bracketed: auto)\";\n BUILT_IN(join)\n {\n Map_Obj m1 = Cast(env[\"$list1\"]);\n Map_Obj m2 = Cast(env[\"$list2\"]);\n List_Obj l1 = Cast(env[\"$list1\"]);\n List_Obj l2 = Cast(env[\"$list2\"]);\n String_Constant_Obj sep = ARG(\"$separator\", String_Constant);\n enum Sass_Separator sep_val = (l1 ? l1->separator() : SASS_SPACE);\n Value* bracketed = ARG(\"$bracketed\", Value);\n bool is_bracketed = (l1 ? l1->is_bracketed() : false);\n if (!l1) {\n l1 = SASS_MEMORY_NEW(List, pstate, 1);\n l1->append(ARG(\"$list1\", Expression));\n sep_val = (l2 ? l2->separator() : SASS_SPACE);\n is_bracketed = (l2 ? l2->is_bracketed() : false);\n }\n if (!l2) {\n l2 = SASS_MEMORY_NEW(List, pstate, 1);\n l2->append(ARG(\"$list2\", Expression));\n }\n if (m1) {\n l1 = m1->to_list(pstate);\n sep_val = SASS_COMMA;\n }\n if (m2) {\n l2 = m2->to_list(pstate);\n }\n size_t len = l1->length() + l2->length();\n std::string sep_str = unquote(sep->value());\n if (sep_str == \"space\") sep_val = SASS_SPACE;\n else if (sep_str == \"comma\") sep_val = SASS_COMMA;\n else if (sep_str != \"auto\") error(\"argument `$separator` of `\" + std::string(sig) + \"` must be `space`, `comma`, or `auto`\", pstate, traces);\n String_Constant_Obj bracketed_as_str = Cast(bracketed);\n bool bracketed_is_auto = bracketed_as_str && unquote(bracketed_as_str->value()) == \"auto\";\n if (!bracketed_is_auto) {\n is_bracketed = !bracketed->is_false();\n }\n List_Obj result = SASS_MEMORY_NEW(List, pstate, len, sep_val, false, is_bracketed);\n result->concat(l1);\n result->concat(l2);\n return result.detach();\n }\n\n Signature append_sig = \"append($list, $val, $separator: auto)\";\n BUILT_IN(append)\n {\n Map_Obj m = Cast(env[\"$list\"]);\n List_Obj l = Cast(env[\"$list\"]);\n Expression_Obj v = ARG(\"$val\", Expression);\n if (Selector_List_Ptr sl = Cast(env[\"$list\"])) {\n Listize listize;\n l = Cast(sl->perform(&listize));\n }\n String_Constant_Obj sep = ARG(\"$separator\", String_Constant);\n if (!l) {\n l = SASS_MEMORY_NEW(List, pstate, 1);\n l->append(ARG(\"$list\", Expression));\n }\n if (m) {\n l = m->to_list(pstate);\n }\n List_Ptr result = SASS_MEMORY_COPY(l);\n std::string sep_str(unquote(sep->value()));\n if (sep_str != \"auto\") { // check default first\n if (sep_str == \"space\") result->separator(SASS_SPACE);\n else if (sep_str == \"comma\") result->separator(SASS_COMMA);\n else error(\"argument `$separator` of `\" + std::string(sig) + \"` must be `space`, `comma`, or `auto`\", pstate, traces);\n }\n if (l->is_arglist()) {\n result->append(SASS_MEMORY_NEW(Argument,\n v->pstate(),\n v,\n \"\",\n false,\n false));\n\n } else {\n result->append(v);\n }\n return result;\n }\n\n Signature zip_sig = \"zip($lists...)\";\n BUILT_IN(zip)\n {\n List_Obj arglist = SASS_MEMORY_COPY(ARG(\"$lists\", List));\n size_t shortest = 0;\n for (size_t i = 0, L = arglist->length(); i < L; ++i) {\n List_Obj ith = Cast(arglist->value_at_index(i));\n Map_Obj mith = Cast(arglist->value_at_index(i));\n if (!ith) {\n if (mith) {\n ith = mith->to_list(pstate);\n } else {\n ith = SASS_MEMORY_NEW(List, pstate, 1);\n ith->append(arglist->value_at_index(i));\n }\n if (arglist->is_arglist()) {\n Argument_Obj arg = (Argument_Ptr)(arglist->at(i).ptr()); // XXX\n arg->value(ith);\n } else {\n (*arglist)[i] = ith;\n }\n }\n shortest = (i ? std::min(shortest, ith->length()) : ith->length());\n }\n List_Ptr zippers = SASS_MEMORY_NEW(List, pstate, shortest, SASS_COMMA);\n size_t L = arglist->length();\n for (size_t i = 0; i < shortest; ++i) {\n List_Ptr zipper = SASS_MEMORY_NEW(List, pstate, L);\n for (size_t j = 0; j < L; ++j) {\n zipper->append(Cast(arglist->value_at_index(j))->at(i));\n }\n zippers->append(zipper);\n }\n return zippers;\n }\n\n Signature list_separator_sig = \"list_separator($list)\";\n BUILT_IN(list_separator)\n {\n List_Obj l = Cast(env[\"$list\"]);\n if (!l) {\n l = SASS_MEMORY_NEW(List, pstate, 1);\n l->append(ARG(\"$list\", Expression));\n }\n return SASS_MEMORY_NEW(String_Quoted,\n pstate,\n l->separator() == SASS_COMMA ? \"comma\" : \"space\");\n }\n\n /////////////////\n // MAP FUNCTIONS\n /////////////////\n\n Signature map_get_sig = \"map-get($map, $key)\";\n BUILT_IN(map_get)\n {\n // leaks for \"map-get((), foo)\" if not Obj\n // investigate why this is (unexpected)\n Map_Obj m = ARGM(\"$map\", Map, ctx);\n Expression_Obj v = ARG(\"$key\", Expression);\n try {\n Expression_Obj val = m->at(v);\n if (!val) return SASS_MEMORY_NEW(Null, pstate);\n val->set_delayed(false);\n return val.detach();\n } catch (const std::out_of_range&) {\n return SASS_MEMORY_NEW(Null, pstate);\n }\n catch (...) { throw; }\n }\n\n Signature map_has_key_sig = \"map-has-key($map, $key)\";\n BUILT_IN(map_has_key)\n {\n Map_Obj m = ARGM(\"$map\", Map, ctx);\n Expression_Obj v = ARG(\"$key\", Expression);\n return SASS_MEMORY_NEW(Boolean, pstate, m->has(v));\n }\n\n Signature map_keys_sig = \"map-keys($map)\";\n BUILT_IN(map_keys)\n {\n Map_Obj m = ARGM(\"$map\", Map, ctx);\n List_Ptr result = SASS_MEMORY_NEW(List, pstate, m->length(), SASS_COMMA);\n for ( auto key : m->keys()) {\n result->append(key);\n }\n return result;\n }\n\n Signature map_values_sig = \"map-values($map)\";\n BUILT_IN(map_values)\n {\n Map_Obj m = ARGM(\"$map\", Map, ctx);\n List_Ptr result = SASS_MEMORY_NEW(List, pstate, m->length(), SASS_COMMA);\n for ( auto key : m->keys()) {\n result->append(m->at(key));\n }\n return result;\n }\n\n Signature map_merge_sig = \"map-merge($map1, $map2)\";\n BUILT_IN(map_merge)\n {\n Map_Obj m1 = ARGM(\"$map1\", Map, ctx);\n Map_Obj m2 = ARGM(\"$map2\", Map, ctx);\n\n size_t len = m1->length() + m2->length();\n Map_Ptr result = SASS_MEMORY_NEW(Map, pstate, len);\n // concat not implemented for maps\n *result += m1;\n *result += m2;\n return result;\n }\n\n Signature map_remove_sig = \"map-remove($map, $keys...)\";\n BUILT_IN(map_remove)\n {\n bool remove;\n Map_Obj m = ARGM(\"$map\", Map, ctx);\n List_Obj arglist = ARG(\"$keys\", List);\n Map_Ptr result = SASS_MEMORY_NEW(Map, pstate, 1);\n for (auto key : m->keys()) {\n remove = false;\n for (size_t j = 0, K = arglist->length(); j < K && !remove; ++j) {\n remove = Operators::eq(key, arglist->value_at_index(j));\n }\n if (!remove) *result << std::make_pair(key, m->at(key));\n }\n return result;\n }\n\n Signature keywords_sig = \"keywords($args)\";\n BUILT_IN(keywords)\n {\n List_Obj arglist = SASS_MEMORY_COPY(ARG(\"$args\", List)); // copy\n Map_Obj result = SASS_MEMORY_NEW(Map, pstate, 1);\n for (size_t i = arglist->size(), L = arglist->length(); i < L; ++i) {\n Expression_Obj obj = arglist->at(i);\n Argument_Obj arg = (Argument_Ptr) obj.ptr(); // XXX\n std::string name = std::string(arg->name());\n name = name.erase(0, 1); // sanitize name (remove dollar sign)\n *result << std::make_pair(SASS_MEMORY_NEW(String_Quoted,\n pstate, name),\n arg->value());\n }\n return result.detach();\n }\n\n //////////////////////////\n // INTROSPECTION FUNCTIONS\n //////////////////////////\n\n Signature type_of_sig = \"type-of($value)\";\n BUILT_IN(type_of)\n {\n Expression_Ptr v = ARG(\"$value\", Expression);\n return SASS_MEMORY_NEW(String_Quoted, pstate, v->type());\n }\n\n Signature unit_sig = \"unit($number)\";\n BUILT_IN(unit)\n {\n Number_Obj arg = ARGN(\"$number\");\n std::string str(quote(arg->unit(), '\"'));\n return SASS_MEMORY_NEW(String_Quoted, pstate, str);\n }\n\n Signature unitless_sig = \"unitless($number)\";\n BUILT_IN(unitless)\n {\n Number_Obj arg = ARGN(\"$number\");\n bool unitless = arg->is_unitless();\n return SASS_MEMORY_NEW(Boolean, pstate, unitless);\n }\n\n Signature comparable_sig = \"comparable($number-1, $number-2)\";\n BUILT_IN(comparable)\n {\n Number_Obj n1 = ARGN(\"$number-1\");\n Number_Obj n2 = ARGN(\"$number-2\");\n if (n1->is_unitless() || n2->is_unitless()) {\n return SASS_MEMORY_NEW(Boolean, pstate, true);\n }\n // normalize into main units\n n1->normalize(); n2->normalize();\n Units &lhs_unit = *n1, &rhs_unit = *n2;\n bool is_comparable = (lhs_unit == rhs_unit);\n return SASS_MEMORY_NEW(Boolean, pstate, is_comparable);\n }\n\n Signature variable_exists_sig = \"variable-exists($name)\";\n BUILT_IN(variable_exists)\n {\n std::string s = Util::normalize_underscores(unquote(ARG(\"$name\", String_Constant)->value()));\n\n if(d_env.has(\"$\"+s)) {\n return SASS_MEMORY_NEW(Boolean, pstate, true);\n }\n else {\n return SASS_MEMORY_NEW(Boolean, pstate, false);\n }\n }\n\n Signature global_variable_exists_sig = \"global-variable-exists($name)\";\n BUILT_IN(global_variable_exists)\n {\n std::string s = Util::normalize_underscores(unquote(ARG(\"$name\", String_Constant)->value()));\n\n if(d_env.has_global(\"$\"+s)) {\n return SASS_MEMORY_NEW(Boolean, pstate, true);\n }\n else {\n return SASS_MEMORY_NEW(Boolean, pstate, false);\n }\n }\n\n Signature function_exists_sig = \"function-exists($name)\";\n BUILT_IN(function_exists)\n {\n String_Constant_Ptr ss = Cast(env[\"$name\"]);\n if (!ss) {\n error(\"$name: \" + (env[\"$name\"]->to_string()) + \" is not a string for `function-exists'\", pstate, traces);\n }\n\n std::string name = Util::normalize_underscores(unquote(ss->value()));\n\n if(d_env.has_global(name+\"[f]\")) {\n return SASS_MEMORY_NEW(Boolean, pstate, true);\n }\n else {\n return SASS_MEMORY_NEW(Boolean, pstate, false);\n }\n }\n\n Signature mixin_exists_sig = \"mixin-exists($name)\";\n BUILT_IN(mixin_exists)\n {\n std::string s = Util::normalize_underscores(unquote(ARG(\"$name\", String_Constant)->value()));\n\n if(d_env.has_global(s+\"[m]\")) {\n return SASS_MEMORY_NEW(Boolean, pstate, true);\n }\n else {\n return SASS_MEMORY_NEW(Boolean, pstate, false);\n }\n }\n\n Signature feature_exists_sig = \"feature-exists($name)\";\n BUILT_IN(feature_exists)\n {\n std::string s = unquote(ARG(\"$name\", String_Constant)->value());\n\n if(features.find(s) == features.end()) {\n return SASS_MEMORY_NEW(Boolean, pstate, false);\n }\n else {\n return SASS_MEMORY_NEW(Boolean, pstate, true);\n }\n }\n\n Signature call_sig = \"call($name, $args...)\";\n BUILT_IN(call)\n {\n std::string name;\n Function_Ptr ff = Cast(env[\"$name\"]);\n String_Constant_Ptr ss = Cast(env[\"$name\"]);\n\n if (ss) {\n name = Util::normalize_underscores(unquote(ss->value()));\n std::cerr << \"DEPRECATION WARNING: \";\n std::cerr << \"Passing a string to call() is deprecated and will be illegal\" << std::endl;\n std::cerr << \"in Sass 4.0. Use call(get-function(\" + quote(name) + \")) instead.\" << std::endl;\n std::cerr << std::endl;\n } else if (ff) {\n name = ff->name();\n }\n\n List_Obj arglist = SASS_MEMORY_COPY(ARG(\"$args\", List));\n\n Arguments_Obj args = SASS_MEMORY_NEW(Arguments, pstate);\n // std::string full_name(name + \"[f]\");\n // Definition_Ptr def = d_env.has(full_name) ? Cast((d_env)[full_name]) : 0;\n // Parameters_Ptr params = def ? def->parameters() : 0;\n // size_t param_size = params ? params->length() : 0;\n for (size_t i = 0, L = arglist->length(); i < L; ++i) {\n Expression_Obj expr = arglist->value_at_index(i);\n // if (params && params->has_rest_parameter()) {\n // Parameter_Obj p = param_size > i ? (*params)[i] : 0;\n // List_Ptr list = Cast(expr);\n // if (list && p && !p->is_rest_parameter()) expr = (*list)[0];\n // }\n if (arglist->is_arglist()) {\n Expression_Obj obj = arglist->at(i);\n Argument_Obj arg = (Argument_Ptr) obj.ptr(); // XXX\n args->append(SASS_MEMORY_NEW(Argument,\n pstate,\n expr,\n arg ? arg->name() : \"\",\n arg ? arg->is_rest_argument() : false,\n arg ? arg->is_keyword_argument() : false));\n } else {\n args->append(SASS_MEMORY_NEW(Argument, pstate, expr));\n }\n }\n Function_Call_Obj func = SASS_MEMORY_NEW(Function_Call, pstate, name, args);\n Expand expand(ctx, &d_env, &selector_stack);\n func->via_call(true); // calc invoke is allowed\n if (ff) func->func(ff);\n return func->perform(&expand.eval);\n }\n\n ////////////////////\n // BOOLEAN FUNCTIONS\n ////////////////////\n\n Signature not_sig = \"not($value)\";\n BUILT_IN(sass_not)\n {\n return SASS_MEMORY_NEW(Boolean, pstate, ARG(\"$value\", Expression)->is_false());\n }\n\n Signature if_sig = \"if($condition, $if-true, $if-false)\";\n // BUILT_IN(sass_if)\n // { return ARG(\"$condition\", Expression)->is_false() ? ARG(\"$if-false\", Expression) : ARG(\"$if-true\", Expression); }\n BUILT_IN(sass_if)\n {\n Expand expand(ctx, &d_env, &selector_stack);\n Expression_Obj cond = ARG(\"$condition\", Expression)->perform(&expand.eval);\n bool is_true = !cond->is_false();\n Expression_Obj res = ARG(is_true ? \"$if-true\" : \"$if-false\", Expression);\n res = res->perform(&expand.eval);\n res->set_delayed(false); // clone?\n return res.detach();\n }\n\n //////////////////////////\n // MISCELLANEOUS FUNCTIONS\n //////////////////////////\n\n // value.check_deprecated_interp if value.is_a?(Sass::Script::Value::String)\n // unquoted_string(value.to_sass)\n\n Signature inspect_sig = \"inspect($value)\";\n BUILT_IN(inspect)\n {\n Expression_Ptr v = ARG(\"$value\", Expression);\n if (v->concrete_type() == Expression::NULL_VAL) {\n return SASS_MEMORY_NEW(String_Quoted, pstate, \"null\");\n } else if (v->concrete_type() == Expression::BOOLEAN && v->is_false()) {\n return SASS_MEMORY_NEW(String_Quoted, pstate, \"false\");\n } else if (v->concrete_type() == Expression::STRING) {\n return v;\n } else {\n // ToDo: fix to_sass for nested parentheses\n Sass_Output_Style old_style;\n old_style = ctx.c_options.output_style;\n ctx.c_options.output_style = TO_SASS;\n Emitter emitter(ctx.c_options);\n Inspect i(emitter);\n i.in_declaration = false;\n v->perform(&i);\n ctx.c_options.output_style = old_style;\n return SASS_MEMORY_NEW(String_Quoted, pstate, i.get_buffer());\n }\n // return v;\n }\n Signature selector_nest_sig = \"selector-nest($selectors...)\";\n BUILT_IN(selector_nest)\n {\n List_Ptr arglist = ARG(\"$selectors\", List);\n\n // Not enough parameters\n if( arglist->length() == 0 )\n error(\"$selectors: At least one selector must be passed for `selector-nest'\", pstate, traces);\n\n // Parse args into vector of selectors\n std::vector parsedSelectors;\n for (size_t i = 0, L = arglist->length(); i < L; ++i) {\n Expression_Obj exp = Cast(arglist->value_at_index(i));\n if (exp->concrete_type() == Expression::NULL_VAL) {\n std::stringstream msg;\n msg << \"$selectors: null is not a valid selector: it must be a string,\\n\";\n msg << \"a list of strings, or a list of lists of strings for 'selector-nest'\";\n error(msg.str(), pstate, traces);\n }\n if (String_Constant_Obj str = Cast(exp)) {\n str->quote_mark(0);\n }\n std::string exp_src = exp->to_string(ctx.c_options);\n Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces);\n parsedSelectors.push_back(sel);\n }\n\n // Nothing to do\n if( parsedSelectors.empty() ) {\n return SASS_MEMORY_NEW(Null, pstate);\n }\n\n // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.\n std::vector::iterator itr = parsedSelectors.begin();\n Selector_List_Obj result = *itr;\n ++itr;\n\n for(;itr != parsedSelectors.end(); ++itr) {\n Selector_List_Obj child = *itr;\n std::vector exploded;\n selector_stack.push_back(result);\n Selector_List_Obj rv = child->resolve_parent_refs(selector_stack, traces);\n selector_stack.pop_back();\n for (size_t m = 0, mLen = rv->length(); m < mLen; ++m) {\n exploded.push_back((*rv)[m]);\n }\n result->elements(exploded);\n }\n\n Listize listize;\n return result->perform(&listize);\n }\n\n Signature selector_append_sig = \"selector-append($selectors...)\";\n BUILT_IN(selector_append)\n {\n List_Ptr arglist = ARG(\"$selectors\", List);\n\n // Not enough parameters\n if( arglist->length() == 0 )\n error(\"$selectors: At least one selector must be passed for `selector-append'\", pstate, traces);\n\n // Parse args into vector of selectors\n std::vector parsedSelectors;\n for (size_t i = 0, L = arglist->length(); i < L; ++i) {\n Expression_Obj exp = Cast(arglist->value_at_index(i));\n if (exp->concrete_type() == Expression::NULL_VAL) {\n std::stringstream msg;\n msg << \"$selectors: null is not a valid selector: it must be a string,\\n\";\n msg << \"a list of strings, or a list of lists of strings for 'selector-append'\";\n error(msg.str(), pstate, traces);\n }\n if (String_Constant_Ptr str = Cast(exp)) {\n str->quote_mark(0);\n }\n std::string exp_src = exp->to_string();\n Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces);\n parsedSelectors.push_back(sel);\n }\n\n // Nothing to do\n if( parsedSelectors.empty() ) {\n return SASS_MEMORY_NEW(Null, pstate);\n }\n\n // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.\n std::vector::iterator itr = parsedSelectors.begin();\n Selector_List_Obj result = *itr;\n ++itr;\n\n for(;itr != parsedSelectors.end(); ++itr) {\n Selector_List_Obj child = *itr;\n std::vector newElements;\n\n // For every COMPLEX_SELECTOR in `result`\n // For every COMPLEX_SELECTOR in `child`\n // let parentSeqClone equal a copy of result->elements[i]\n // let childSeq equal child->elements[j]\n // Append all of childSeq head elements into parentSeqClone\n // Set the innermost tail of parentSeqClone, to childSeq's tail\n // Replace result->elements with newElements\n for (size_t i = 0, resultLen = result->length(); i < resultLen; ++i) {\n for (size_t j = 0, childLen = child->length(); j < childLen; ++j) {\n Complex_Selector_Obj parentSeqClone = SASS_MEMORY_CLONE((*result)[i]);\n Complex_Selector_Obj childSeq = (*child)[j];\n Complex_Selector_Obj base = childSeq->tail();\n\n // Must be a simple sequence\n if( childSeq->combinator() != Complex_Selector::Combinator::ANCESTOR_OF ) {\n std::string msg(\"Can't append \\\"\");\n msg += childSeq->to_string();\n msg += \"\\\" to \\\"\";\n msg += parentSeqClone->to_string();\n msg += \"\\\" for `selector-append'\";\n error(msg, pstate, traces);\n }\n\n // Cannot be a Universal selector\n Element_Selector_Obj pType = Cast(childSeq->head()->first());\n if(pType && pType->name() == \"*\") {\n std::string msg(\"Can't append \\\"\");\n msg += childSeq->to_string();\n msg += \"\\\" to \\\"\";\n msg += parentSeqClone->to_string();\n msg += \"\\\" for `selector-append'\";\n error(msg, pstate, traces);\n }\n\n // TODO: Add check for namespace stuff\n\n // append any selectors in childSeq's head\n parentSeqClone->innermost()->head()->concat(base->head());\n\n // Set parentSeqClone new tail\n parentSeqClone->innermost()->tail( base->tail() );\n\n newElements.push_back(parentSeqClone);\n }\n }\n\n result->elements(newElements);\n }\n\n Listize listize;\n return result->perform(&listize);\n }\n\n Signature selector_unify_sig = \"selector-unify($selector1, $selector2)\";\n BUILT_IN(selector_unify)\n {\n Selector_List_Obj selector1 = ARGSEL(\"$selector1\", Selector_List_Obj, p_contextualize);\n Selector_List_Obj selector2 = ARGSEL(\"$selector2\", Selector_List_Obj, p_contextualize);\n\n Selector_List_Obj result = selector1->unify_with(selector2);\n Listize listize;\n return result->perform(&listize);\n }\n\n Signature simple_selectors_sig = \"simple-selectors($selector)\";\n BUILT_IN(simple_selectors)\n {\n Compound_Selector_Obj sel = ARGSEL(\"$selector\", Compound_Selector_Obj, p_contextualize);\n\n List_Ptr l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);\n\n for (size_t i = 0, L = sel->length(); i < L; ++i) {\n Simple_Selector_Obj ss = (*sel)[i];\n std::string ss_string = ss->to_string() ;\n\n l->append(SASS_MEMORY_NEW(String_Quoted, ss->pstate(), ss_string));\n }\n\n return l;\n }\n\n Signature selector_extend_sig = \"selector-extend($selector, $extendee, $extender)\";\n BUILT_IN(selector_extend)\n {\n Selector_List_Obj selector = ARGSEL(\"$selector\", Selector_List_Obj, p_contextualize);\n Selector_List_Obj extendee = ARGSEL(\"$extendee\", Selector_List_Obj, p_contextualize);\n Selector_List_Obj extender = ARGSEL(\"$extender\", Selector_List_Obj, p_contextualize);\n\n Subset_Map subset_map;\n extender->populate_extends(extendee, subset_map);\n Extend extend(subset_map);\n\n Selector_List_Obj result = extend.extendSelectorList(selector, false);\n\n Listize listize;\n return result->perform(&listize);\n }\n\n Signature selector_replace_sig = \"selector-replace($selector, $original, $replacement)\";\n BUILT_IN(selector_replace)\n {\n Selector_List_Obj selector = ARGSEL(\"$selector\", Selector_List_Obj, p_contextualize);\n Selector_List_Obj original = ARGSEL(\"$original\", Selector_List_Obj, p_contextualize);\n Selector_List_Obj replacement = ARGSEL(\"$replacement\", Selector_List_Obj, p_contextualize);\n Subset_Map subset_map;\n replacement->populate_extends(original, subset_map);\n Extend extend(subset_map);\n\n Selector_List_Obj result = extend.extendSelectorList(selector, true);\n\n Listize listize;\n return result->perform(&listize);\n }\n\n Signature selector_parse_sig = \"selector-parse($selector)\";\n BUILT_IN(selector_parse)\n {\n Selector_List_Obj sel = ARGSEL(\"$selector\", Selector_List_Obj, p_contextualize);\n\n Listize listize;\n return sel->perform(&listize);\n }\n\n Signature is_superselector_sig = \"is-superselector($super, $sub)\";\n BUILT_IN(is_superselector)\n {\n Selector_List_Obj sel_sup = ARGSEL(\"$super\", Selector_List_Obj, p_contextualize);\n Selector_List_Obj sel_sub = ARGSEL(\"$sub\", Selector_List_Obj, p_contextualize);\n bool result = sel_sup->is_superselector_of(sel_sub);\n return SASS_MEMORY_NEW(Boolean, pstate, result);\n }\n\n Signature unique_id_sig = \"unique-id()\";\n BUILT_IN(unique_id)\n {\n std::stringstream ss;\n std::uniform_real_distribution<> distributor(0, 4294967296); // 16^8\n uint_fast32_t distributed = static_cast(distributor(rand));\n ss << \"u\" << std::setfill('0') << std::setw(8) << std::hex << distributed;\n return SASS_MEMORY_NEW(String_Quoted, pstate, ss.str());\n }\n\n Signature is_bracketed_sig = \"is-bracketed($list)\";\n BUILT_IN(is_bracketed)\n {\n Value_Obj value = ARG(\"$list\", Value);\n List_Obj list = Cast(value);\n return SASS_MEMORY_NEW(Boolean, pstate, list && list->is_bracketed());\n }\n\n Signature content_exists_sig = \"content-exists()\";\n BUILT_IN(content_exists)\n {\n if (!d_env.has_global(\"is_in_mixin\")) {\n error(\"Cannot call content-exists() except within a mixin.\", pstate, traces);\n }\n return SASS_MEMORY_NEW(Boolean, pstate, d_env.has_lexical(\"@content[m]\"));\n }\n\n Signature get_function_sig = \"get-function($name, $css: false)\";\n BUILT_IN(get_function)\n {\n String_Constant_Ptr ss = Cast(env[\"$name\"]);\n if (!ss) {\n error(\"$name: \" + (env[\"$name\"]->to_string()) + \" is not a string for `get-function'\", pstate, traces);\n }\n\n std::string name = Util::normalize_underscores(unquote(ss->value()));\n std::string full_name = name + \"[f]\";\n\n Boolean_Obj css = ARG(\"$css\", Boolean);\n if (!css->is_false()) {\n Definition_Ptr def = SASS_MEMORY_NEW(Definition,\n pstate,\n name,\n SASS_MEMORY_NEW(Parameters, pstate),\n SASS_MEMORY_NEW(Block, pstate, 0, false),\n Definition::FUNCTION);\n return SASS_MEMORY_NEW(Function, pstate, def, true);\n }\n\n\n if (!d_env.has_global(full_name)) {\n error(\"Function not found: \" + name, pstate, traces);\n }\n\n Definition_Ptr def = Cast(d_env[full_name]);\n return SASS_MEMORY_NEW(Function, pstate, def, false);\n }\n }\n}\n" }, { "path": "libsass-build/functions.hpp", "content": "#ifndef SASS_FUNCTIONS_H\n#define SASS_FUNCTIONS_H\n\n#include \"listize.hpp\"\n#include \"position.hpp\"\n#include \"environment.hpp\"\n#include \"ast_fwd_decl.hpp\"\n#include \"sass/functions.h\"\n\n#define BUILT_IN(name) Expression_Ptr \\\nname(Env& env, Env& d_env, Context& ctx, Signature sig, ParserState pstate, Backtraces traces, std::vector selector_stack)\n\nnamespace Sass {\n struct Backtrace;\n typedef const char* Signature;\n typedef Expression_Ptr (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtraces, std::vector);\n\n Definition_Ptr make_native_function(Signature, Native_Function, Context& ctx);\n Definition_Ptr make_c_function(Sass_Function_Entry c_func, Context& ctx);\n\n std::string function_name(Signature);\n\n namespace Functions {\n\n extern Signature rgb_sig;\n extern Signature rgba_4_sig;\n extern Signature rgba_2_sig;\n extern Signature red_sig;\n extern Signature green_sig;\n extern Signature blue_sig;\n extern Signature mix_sig;\n extern Signature hsl_sig;\n extern Signature hsla_sig;\n extern Signature hue_sig;\n extern Signature saturation_sig;\n extern Signature lightness_sig;\n extern Signature adjust_hue_sig;\n extern Signature lighten_sig;\n extern Signature darken_sig;\n extern Signature saturate_sig;\n extern Signature desaturate_sig;\n extern Signature grayscale_sig;\n extern Signature complement_sig;\n extern Signature invert_sig;\n extern Signature alpha_sig;\n extern Signature opacity_sig;\n extern Signature opacify_sig;\n extern Signature fade_in_sig;\n extern Signature transparentize_sig;\n extern Signature fade_out_sig;\n extern Signature adjust_color_sig;\n extern Signature scale_color_sig;\n extern Signature change_color_sig;\n extern Signature ie_hex_str_sig;\n extern Signature unquote_sig;\n extern Signature quote_sig;\n extern Signature str_length_sig;\n extern Signature str_insert_sig;\n extern Signature str_index_sig;\n extern Signature str_slice_sig;\n extern Signature to_upper_case_sig;\n extern Signature to_lower_case_sig;\n extern Signature percentage_sig;\n extern Signature round_sig;\n extern Signature ceil_sig;\n extern Signature floor_sig;\n extern Signature abs_sig;\n extern Signature min_sig;\n extern Signature max_sig;\n extern Signature inspect_sig;\n extern Signature random_sig;\n extern Signature length_sig;\n extern Signature nth_sig;\n extern Signature index_sig;\n extern Signature join_sig;\n extern Signature append_sig;\n extern Signature zip_sig;\n extern Signature list_separator_sig;\n extern Signature type_of_sig;\n extern Signature unit_sig;\n extern Signature unitless_sig;\n extern Signature comparable_sig;\n extern Signature variable_exists_sig;\n extern Signature global_variable_exists_sig;\n extern Signature function_exists_sig;\n extern Signature mixin_exists_sig;\n extern Signature feature_exists_sig;\n extern Signature call_sig;\n extern Signature not_sig;\n extern Signature if_sig;\n extern Signature map_get_sig;\n extern Signature map_merge_sig;\n extern Signature map_remove_sig;\n extern Signature map_keys_sig;\n extern Signature map_values_sig;\n extern Signature map_has_key_sig;\n extern Signature keywords_sig;\n extern Signature set_nth_sig;\n extern Signature unique_id_sig;\n extern Signature selector_nest_sig;\n extern Signature selector_append_sig;\n extern Signature selector_extend_sig;\n extern Signature selector_replace_sig;\n extern Signature selector_unify_sig;\n extern Signature is_superselector_sig;\n extern Signature simple_selectors_sig;\n extern Signature selector_parse_sig;\n extern Signature is_bracketed_sig;\n extern Signature content_exists_sig;\n extern Signature get_function_sig;\n\n BUILT_IN(rgb);\n BUILT_IN(rgba_4);\n BUILT_IN(rgba_2);\n BUILT_IN(red);\n BUILT_IN(green);\n BUILT_IN(blue);\n BUILT_IN(mix);\n BUILT_IN(hsl);\n BUILT_IN(hsla);\n BUILT_IN(hue);\n BUILT_IN(saturation);\n BUILT_IN(lightness);\n BUILT_IN(adjust_hue);\n BUILT_IN(lighten);\n BUILT_IN(darken);\n BUILT_IN(saturate);\n BUILT_IN(desaturate);\n BUILT_IN(grayscale);\n BUILT_IN(complement);\n BUILT_IN(invert);\n BUILT_IN(alpha);\n BUILT_IN(opacify);\n BUILT_IN(transparentize);\n BUILT_IN(adjust_color);\n BUILT_IN(scale_color);\n BUILT_IN(change_color);\n BUILT_IN(ie_hex_str);\n BUILT_IN(sass_unquote);\n BUILT_IN(sass_quote);\n BUILT_IN(str_length);\n BUILT_IN(str_insert);\n BUILT_IN(str_index);\n BUILT_IN(str_slice);\n BUILT_IN(to_upper_case);\n BUILT_IN(to_lower_case);\n BUILT_IN(percentage);\n BUILT_IN(round);\n BUILT_IN(ceil);\n BUILT_IN(floor);\n BUILT_IN(abs);\n BUILT_IN(min);\n BUILT_IN(max);\n BUILT_IN(inspect);\n BUILT_IN(random);\n BUILT_IN(length);\n BUILT_IN(nth);\n BUILT_IN(index);\n BUILT_IN(join);\n BUILT_IN(append);\n BUILT_IN(zip);\n BUILT_IN(list_separator);\n BUILT_IN(type_of);\n BUILT_IN(unit);\n BUILT_IN(unitless);\n BUILT_IN(comparable);\n BUILT_IN(variable_exists);\n BUILT_IN(global_variable_exists);\n BUILT_IN(function_exists);\n BUILT_IN(mixin_exists);\n BUILT_IN(feature_exists);\n BUILT_IN(call);\n BUILT_IN(sass_not);\n BUILT_IN(sass_if);\n BUILT_IN(map_get);\n BUILT_IN(map_merge);\n BUILT_IN(map_remove);\n BUILT_IN(map_keys);\n BUILT_IN(map_values);\n BUILT_IN(map_has_key);\n BUILT_IN(keywords);\n BUILT_IN(set_nth);\n BUILT_IN(unique_id);\n BUILT_IN(selector_nest);\n BUILT_IN(selector_append);\n BUILT_IN(selector_extend);\n BUILT_IN(selector_replace);\n BUILT_IN(selector_unify);\n BUILT_IN(is_superselector);\n BUILT_IN(simple_selectors);\n BUILT_IN(selector_parse);\n BUILT_IN(is_bracketed);\n BUILT_IN(content_exists);\n BUILT_IN(get_function);\n }\n}\n\n#endif\n" }, { "path": "libsass-build/include/sass/base.h", "content": "#ifndef SASS_BASE_H\n#define SASS_BASE_H\n\n// #define DEBUG_SHARED_PTR\n\n#ifdef _MSC_VER\n #pragma warning(disable : 4503)\n #ifndef _SCL_SECURE_NO_WARNINGS\n #define _SCL_SECURE_NO_WARNINGS\n #endif\n #ifndef _CRT_SECURE_NO_WARNINGS\n #define _CRT_SECURE_NO_WARNINGS\n #endif\n #ifndef _CRT_NONSTDC_NO_DEPRECATE\n #define _CRT_NONSTDC_NO_DEPRECATE\n #endif\n#endif\n\n#include \n#include \n\n#ifdef __GNUC__\n #define DEPRECATED(func) func __attribute__ ((deprecated))\n#elif defined(_MSC_VER)\n #define DEPRECATED(func) __declspec(deprecated) func\n#else\n #pragma message(\"WARNING: You need to implement DEPRECATED for this compiler\")\n #define DEPRECATED(func) func\n#endif\n\n#ifdef _WIN32\n\n /* You should define ADD_EXPORTS *only* when building the DLL. */\n #ifdef ADD_EXPORTS\n #define ADDAPI __declspec(dllexport)\n #define ADDCALL __cdecl\n #else\n #define ADDAPI\n #define ADDCALL\n #endif\n\n#else /* _WIN32 not defined. */\n\n /* Define with no value on non-Windows OSes. */\n #define ADDAPI\n #define ADDCALL\n\n#endif\n\n/* Make sure functions are exported with C linkage under C++ compilers. */\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n\n// Different render styles\nenum Sass_Output_Style {\n SASS_STYLE_NESTED,\n SASS_STYLE_EXPANDED,\n SASS_STYLE_COMPACT,\n SASS_STYLE_COMPRESSED,\n // only used internaly\n SASS_STYLE_INSPECT,\n SASS_STYLE_TO_SASS\n};\n\n// to allocate buffer to be filled\nADDAPI void* ADDCALL sass_alloc_memory(size_t size);\n// to allocate a buffer from existing string\nADDAPI char* ADDCALL sass_copy_c_string(const char* str);\n// to free overtaken memory when done\nADDAPI void ADDCALL sass_free_memory(void* ptr);\n\n// Some convenient string helper function\nADDAPI char* ADDCALL sass_string_quote (const char* str, const char quote_mark);\nADDAPI char* ADDCALL sass_string_unquote (const char* str);\n\n// Implemented sass language version\n// Hardcoded version 3.4 for time being\nADDAPI const char* ADDCALL libsass_version(void);\n\n// Get compiled libsass language\nADDAPI const char* ADDCALL libsass_language_version(void);\n\n#ifdef __cplusplus\n} // __cplusplus defined.\n#endif\n\n#endif\n" }, { "path": "libsass-build/include/sass/context.h", "content": "#ifndef SASS_C_CONTEXT_H\n#define SASS_C_CONTEXT_H\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n\n// Forward declaration\nstruct Sass_Compiler;\n\n// Forward declaration\nstruct Sass_Options; // base struct\nstruct Sass_Context; // : Sass_Options\nstruct Sass_File_Context; // : Sass_Context\nstruct Sass_Data_Context; // : Sass_Context\n\n// Compiler states\nenum Sass_Compiler_State {\n SASS_COMPILER_CREATED,\n SASS_COMPILER_PARSED,\n SASS_COMPILER_EXECUTED\n};\n\n// Create and initialize an option struct\nADDAPI struct Sass_Options* ADDCALL sass_make_options (void);\n// Create and initialize a specific context\nADDAPI struct Sass_File_Context* ADDCALL sass_make_file_context (const char* input_path);\nADDAPI struct Sass_Data_Context* ADDCALL sass_make_data_context (char* source_string);\n\n// Call the compilation step for the specific context\nADDAPI int ADDCALL sass_compile_file_context (struct Sass_File_Context* ctx);\nADDAPI int ADDCALL sass_compile_data_context (struct Sass_Data_Context* ctx);\n\n// Create a sass compiler instance for more control\nADDAPI struct Sass_Compiler* ADDCALL sass_make_file_compiler (struct Sass_File_Context* file_ctx);\nADDAPI struct Sass_Compiler* ADDCALL sass_make_data_compiler (struct Sass_Data_Context* data_ctx);\n\n// Execute the different compilation steps individually\n// Usefull if you only want to query the included files\nADDAPI int ADDCALL sass_compiler_parse(struct Sass_Compiler* compiler);\nADDAPI int ADDCALL sass_compiler_execute(struct Sass_Compiler* compiler);\n\n// Release all memory allocated with the compiler\n// This does _not_ include any contexts or options\nADDAPI void ADDCALL sass_delete_compiler(struct Sass_Compiler* compiler);\nADDAPI void ADDCALL sass_delete_options(struct Sass_Options* options);\n\n// Release all memory allocated and also ourself\nADDAPI void ADDCALL sass_delete_file_context (struct Sass_File_Context* ctx);\nADDAPI void ADDCALL sass_delete_data_context (struct Sass_Data_Context* ctx);\n\n// Getters for context from specific implementation\nADDAPI struct Sass_Context* ADDCALL sass_file_context_get_context (struct Sass_File_Context* file_ctx);\nADDAPI struct Sass_Context* ADDCALL sass_data_context_get_context (struct Sass_Data_Context* data_ctx);\n\n// Getters for Context_Options from Sass_Context\nADDAPI struct Sass_Options* ADDCALL sass_context_get_options (struct Sass_Context* ctx);\nADDAPI struct Sass_Options* ADDCALL sass_file_context_get_options (struct Sass_File_Context* file_ctx);\nADDAPI struct Sass_Options* ADDCALL sass_data_context_get_options (struct Sass_Data_Context* data_ctx);\nADDAPI void ADDCALL sass_file_context_set_options (struct Sass_File_Context* file_ctx, struct Sass_Options* opt);\nADDAPI void ADDCALL sass_data_context_set_options (struct Sass_Data_Context* data_ctx, struct Sass_Options* opt);\n\n\n// Getters for Context_Option values\nADDAPI int ADDCALL sass_option_get_precision (struct Sass_Options* options);\nADDAPI enum Sass_Output_Style ADDCALL sass_option_get_output_style (struct Sass_Options* options);\nADDAPI bool ADDCALL sass_option_get_source_comments (struct Sass_Options* options);\nADDAPI bool ADDCALL sass_option_get_source_map_embed (struct Sass_Options* options);\nADDAPI bool ADDCALL sass_option_get_source_map_contents (struct Sass_Options* options);\nADDAPI bool ADDCALL sass_option_get_source_map_file_urls (struct Sass_Options* options);\nADDAPI bool ADDCALL sass_option_get_omit_source_map_url (struct Sass_Options* options);\nADDAPI bool ADDCALL sass_option_get_is_indented_syntax_src (struct Sass_Options* options);\nADDAPI const char* ADDCALL sass_option_get_indent (struct Sass_Options* options);\nADDAPI const char* ADDCALL sass_option_get_linefeed (struct Sass_Options* options);\nADDAPI const char* ADDCALL sass_option_get_input_path (struct Sass_Options* options);\nADDAPI const char* ADDCALL sass_option_get_output_path (struct Sass_Options* options);\nADDAPI const char* ADDCALL sass_option_get_source_map_file (struct Sass_Options* options);\nADDAPI const char* ADDCALL sass_option_get_source_map_root (struct Sass_Options* options);\nADDAPI Sass_Importer_List ADDCALL sass_option_get_c_headers (struct Sass_Options* options);\nADDAPI Sass_Importer_List ADDCALL sass_option_get_c_importers (struct Sass_Options* options);\nADDAPI Sass_Function_List ADDCALL sass_option_get_c_functions (struct Sass_Options* options);\n\n// Setters for Context_Option values\nADDAPI void ADDCALL sass_option_set_precision (struct Sass_Options* options, int precision);\nADDAPI void ADDCALL sass_option_set_output_style (struct Sass_Options* options, enum Sass_Output_Style output_style);\nADDAPI void ADDCALL sass_option_set_source_comments (struct Sass_Options* options, bool source_comments);\nADDAPI void ADDCALL sass_option_set_source_map_embed (struct Sass_Options* options, bool source_map_embed);\nADDAPI void ADDCALL sass_option_set_source_map_contents (struct Sass_Options* options, bool source_map_contents);\nADDAPI void ADDCALL sass_option_set_source_map_file_urls (struct Sass_Options* options, bool source_map_file_urls);\nADDAPI void ADDCALL sass_option_set_omit_source_map_url (struct Sass_Options* options, bool omit_source_map_url);\nADDAPI void ADDCALL sass_option_set_is_indented_syntax_src (struct Sass_Options* options, bool is_indented_syntax_src);\nADDAPI void ADDCALL sass_option_set_indent (struct Sass_Options* options, const char* indent);\nADDAPI void ADDCALL sass_option_set_linefeed (struct Sass_Options* options, const char* linefeed);\nADDAPI void ADDCALL sass_option_set_input_path (struct Sass_Options* options, const char* input_path);\nADDAPI void ADDCALL sass_option_set_output_path (struct Sass_Options* options, const char* output_path);\nADDAPI void ADDCALL sass_option_set_plugin_path (struct Sass_Options* options, const char* plugin_path);\nADDAPI void ADDCALL sass_option_set_include_path (struct Sass_Options* options, const char* include_path);\nADDAPI void ADDCALL sass_option_set_source_map_file (struct Sass_Options* options, const char* source_map_file);\nADDAPI void ADDCALL sass_option_set_source_map_root (struct Sass_Options* options, const char* source_map_root);\nADDAPI void ADDCALL sass_option_set_c_headers (struct Sass_Options* options, Sass_Importer_List c_headers);\nADDAPI void ADDCALL sass_option_set_c_importers (struct Sass_Options* options, Sass_Importer_List c_importers);\nADDAPI void ADDCALL sass_option_set_c_functions (struct Sass_Options* options, Sass_Function_List c_functions);\n\n\n// Getters for Sass_Context values\nADDAPI const char* ADDCALL sass_context_get_output_string (struct Sass_Context* ctx);\nADDAPI int ADDCALL sass_context_get_error_status (struct Sass_Context* ctx);\nADDAPI const char* ADDCALL sass_context_get_error_json (struct Sass_Context* ctx);\nADDAPI const char* ADDCALL sass_context_get_error_text (struct Sass_Context* ctx);\nADDAPI const char* ADDCALL sass_context_get_error_message (struct Sass_Context* ctx);\nADDAPI const char* ADDCALL sass_context_get_error_file (struct Sass_Context* ctx);\nADDAPI const char* ADDCALL sass_context_get_error_src (struct Sass_Context* ctx);\nADDAPI size_t ADDCALL sass_context_get_error_line (struct Sass_Context* ctx);\nADDAPI size_t ADDCALL sass_context_get_error_column (struct Sass_Context* ctx);\nADDAPI const char* ADDCALL sass_context_get_source_map_string (struct Sass_Context* ctx);\nADDAPI char** ADDCALL sass_context_get_included_files (struct Sass_Context* ctx);\n\n// Getters for options include path array\nADDAPI size_t ADDCALL sass_option_get_include_path_size(struct Sass_Options* options);\nADDAPI const char* ADDCALL sass_option_get_include_path(struct Sass_Options* options, size_t i);\n\n// Calculate the size of the stored null terminated array\nADDAPI size_t ADDCALL sass_context_get_included_files_size (struct Sass_Context* ctx);\n\n// Take ownership of memory (value on context is set to 0)\nADDAPI char* ADDCALL sass_context_take_error_json (struct Sass_Context* ctx);\nADDAPI char* ADDCALL sass_context_take_error_text (struct Sass_Context* ctx);\nADDAPI char* ADDCALL sass_context_take_error_message (struct Sass_Context* ctx);\nADDAPI char* ADDCALL sass_context_take_error_file (struct Sass_Context* ctx);\nADDAPI char* ADDCALL sass_context_take_output_string (struct Sass_Context* ctx);\nADDAPI char* ADDCALL sass_context_take_source_map_string (struct Sass_Context* ctx);\nADDAPI char** ADDCALL sass_context_take_included_files (struct Sass_Context* ctx);\n\n// Getters for Sass_Compiler options\nADDAPI enum Sass_Compiler_State ADDCALL sass_compiler_get_state(struct Sass_Compiler* compiler);\nADDAPI struct Sass_Context* ADDCALL sass_compiler_get_context(struct Sass_Compiler* compiler);\nADDAPI struct Sass_Options* ADDCALL sass_compiler_get_options(struct Sass_Compiler* compiler);\nADDAPI size_t ADDCALL sass_compiler_get_import_stack_size(struct Sass_Compiler* compiler);\nADDAPI Sass_Import_Entry ADDCALL sass_compiler_get_last_import(struct Sass_Compiler* compiler);\nADDAPI Sass_Import_Entry ADDCALL sass_compiler_get_import_entry(struct Sass_Compiler* compiler, size_t idx);\nADDAPI size_t ADDCALL sass_compiler_get_callee_stack_size(struct Sass_Compiler* compiler);\nADDAPI Sass_Callee_Entry ADDCALL sass_compiler_get_last_callee(struct Sass_Compiler* compiler);\nADDAPI Sass_Callee_Entry ADDCALL sass_compiler_get_callee_entry(struct Sass_Compiler* compiler, size_t idx);\n\n// Push function for paths (no manipulation support for now)\nADDAPI void ADDCALL sass_option_push_plugin_path (struct Sass_Options* options, const char* path);\nADDAPI void ADDCALL sass_option_push_include_path (struct Sass_Options* options, const char* path);\n\n// Resolve a file via the given include paths in the sass option struct\n// find_file looks for the exact file name while find_include does a regular sass include\nADDAPI char* ADDCALL sass_find_file (const char* path, struct Sass_Options* opt);\nADDAPI char* ADDCALL sass_find_include (const char* path, struct Sass_Options* opt);\n\n// Resolve a file relative to last import or include paths in the sass option struct\n// find_file looks for the exact file name while find_include does a regular sass include\nADDAPI char* ADDCALL sass_compiler_find_file (const char* path, struct Sass_Compiler* compiler);\nADDAPI char* ADDCALL sass_compiler_find_include (const char* path, struct Sass_Compiler* compiler);\n\n#ifdef __cplusplus\n} // __cplusplus defined.\n#endif\n\n#endif\n" }, { "path": "libsass-build/include/sass/functions.h", "content": "#ifndef SASS_C_FUNCTIONS_H\n#define SASS_C_FUNCTIONS_H\n\n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n\n// Forward declaration\nstruct Sass_Env;\nstruct Sass_Callee;\nstruct Sass_Import;\nstruct Sass_Options;\nstruct Sass_Compiler;\nstruct Sass_Importer;\nstruct Sass_Function;\n\n// Typedef helpers for callee lists\ntypedef struct Sass_Env (*Sass_Env_Frame);\n// Typedef helpers for callee lists\ntypedef struct Sass_Callee (*Sass_Callee_Entry);\n// Typedef helpers for import lists\ntypedef struct Sass_Import (*Sass_Import_Entry);\ntypedef struct Sass_Import* (*Sass_Import_List);\n// Typedef helpers for custom importer lists\ntypedef struct Sass_Importer (*Sass_Importer_Entry);\ntypedef struct Sass_Importer* (*Sass_Importer_List);\n// Typedef defining importer signature and return type\ntypedef Sass_Import_List (*Sass_Importer_Fn)\n (const char* url, Sass_Importer_Entry cb, struct Sass_Compiler* compiler);\n\n// Typedef helpers for custom functions lists\ntypedef struct Sass_Function (*Sass_Function_Entry);\ntypedef struct Sass_Function* (*Sass_Function_List);\n// Typedef defining function signature and return type\ntypedef union Sass_Value* (*Sass_Function_Fn)\n (const union Sass_Value*, Sass_Function_Entry cb, struct Sass_Compiler* compiler);\n\n// Type of function calls\nenum Sass_Callee_Type {\n SASS_CALLEE_MIXIN,\n SASS_CALLEE_FUNCTION,\n SASS_CALLEE_C_FUNCTION,\n};\n\n// Creator for sass custom importer return argument list\nADDAPI Sass_Importer_List ADDCALL sass_make_importer_list (size_t length);\nADDAPI Sass_Importer_Entry ADDCALL sass_importer_get_list_entry (Sass_Importer_List list, size_t idx);\nADDAPI void ADDCALL sass_importer_set_list_entry (Sass_Importer_List list, size_t idx, Sass_Importer_Entry entry);\nADDAPI void ADDCALL sass_delete_importer_list (Sass_Importer_List list);\n\n\n// Creators for custom importer callback (with some additional pointer)\n// The pointer is mostly used to store the callback into the actual binding\nADDAPI Sass_Importer_Entry ADDCALL sass_make_importer (Sass_Importer_Fn importer, double priority, void* cookie);\n\n// Getters for import function descriptors\nADDAPI Sass_Importer_Fn ADDCALL sass_importer_get_function (Sass_Importer_Entry cb);\nADDAPI double ADDCALL sass_importer_get_priority (Sass_Importer_Entry cb);\nADDAPI void* ADDCALL sass_importer_get_cookie (Sass_Importer_Entry cb);\n\n// Deallocator for associated memory\nADDAPI void ADDCALL sass_delete_importer (Sass_Importer_Entry cb);\n\n// Creator for sass custom importer return argument list\nADDAPI Sass_Import_List ADDCALL sass_make_import_list (size_t length);\n// Creator for a single import entry returned by the custom importer inside the list\nADDAPI Sass_Import_Entry ADDCALL sass_make_import_entry (const char* path, char* source, char* srcmap);\nADDAPI Sass_Import_Entry ADDCALL sass_make_import (const char* imp_path, const char* abs_base, char* source, char* srcmap);\n// set error message to abort import and to print out a message (path from existing object is used in output)\nADDAPI Sass_Import_Entry ADDCALL sass_import_set_error(Sass_Import_Entry import, const char* message, size_t line, size_t col);\n\n// Setters to insert an entry into the import list (you may also use [] access directly)\n// Since we are dealing with pointers they should have a guaranteed and fixed size\nADDAPI void ADDCALL sass_import_set_list_entry (Sass_Import_List list, size_t idx, Sass_Import_Entry entry);\nADDAPI Sass_Import_Entry ADDCALL sass_import_get_list_entry (Sass_Import_List list, size_t idx);\n\n// Getters for callee entry\nADDAPI const char* ADDCALL sass_callee_get_name (Sass_Callee_Entry);\nADDAPI const char* ADDCALL sass_callee_get_path (Sass_Callee_Entry);\nADDAPI size_t ADDCALL sass_callee_get_line (Sass_Callee_Entry);\nADDAPI size_t ADDCALL sass_callee_get_column (Sass_Callee_Entry);\nADDAPI enum Sass_Callee_Type ADDCALL sass_callee_get_type (Sass_Callee_Entry);\nADDAPI Sass_Env_Frame ADDCALL sass_callee_get_env (Sass_Callee_Entry);\n\n// Getters and Setters for environments (lexical, local and global)\nADDAPI union Sass_Value* ADDCALL sass_env_get_lexical (Sass_Env_Frame, const char*);\nADDAPI void ADDCALL sass_env_set_lexical (Sass_Env_Frame, const char*, union Sass_Value*);\nADDAPI union Sass_Value* ADDCALL sass_env_get_local (Sass_Env_Frame, const char*);\nADDAPI void ADDCALL sass_env_set_local (Sass_Env_Frame, const char*, union Sass_Value*);\nADDAPI union Sass_Value* ADDCALL sass_env_get_global (Sass_Env_Frame, const char*);\nADDAPI void ADDCALL sass_env_set_global (Sass_Env_Frame, const char*, union Sass_Value*);\n\n// Getters for import entry\nADDAPI const char* ADDCALL sass_import_get_imp_path (Sass_Import_Entry);\nADDAPI const char* ADDCALL sass_import_get_abs_path (Sass_Import_Entry);\nADDAPI const char* ADDCALL sass_import_get_source (Sass_Import_Entry);\nADDAPI const char* ADDCALL sass_import_get_srcmap (Sass_Import_Entry);\n// Explicit functions to take ownership of these items\n// The property on our struct will be reset to NULL\nADDAPI char* ADDCALL sass_import_take_source (Sass_Import_Entry);\nADDAPI char* ADDCALL sass_import_take_srcmap (Sass_Import_Entry);\n// Getters from import error entry\nADDAPI size_t ADDCALL sass_import_get_error_line (Sass_Import_Entry);\nADDAPI size_t ADDCALL sass_import_get_error_column (Sass_Import_Entry);\nADDAPI const char* ADDCALL sass_import_get_error_message (Sass_Import_Entry);\n\n// Deallocator for associated memory (incl. entries)\nADDAPI void ADDCALL sass_delete_import_list (Sass_Import_List);\n// Just in case we have some stray import structs\nADDAPI void ADDCALL sass_delete_import (Sass_Import_Entry);\n\n\n\n// Creators for sass function list and function descriptors\nADDAPI Sass_Function_List ADDCALL sass_make_function_list (size_t length);\nADDAPI Sass_Function_Entry ADDCALL sass_make_function (const char* signature, Sass_Function_Fn cb, void* cookie);\nADDAPI void ADDCALL sass_delete_function (Sass_Function_Entry entry);\nADDAPI void ADDCALL sass_delete_function_list (Sass_Function_List list);\n\n// Setters and getters for callbacks on function lists\nADDAPI Sass_Function_Entry ADDCALL sass_function_get_list_entry(Sass_Function_List list, size_t pos);\nADDAPI void ADDCALL sass_function_set_list_entry(Sass_Function_List list, size_t pos, Sass_Function_Entry cb);\n\n// Getters for custom function descriptors\nADDAPI const char* ADDCALL sass_function_get_signature (Sass_Function_Entry cb);\nADDAPI Sass_Function_Fn ADDCALL sass_function_get_function (Sass_Function_Entry cb);\nADDAPI void* ADDCALL sass_function_get_cookie (Sass_Function_Entry cb);\n\n\n#ifdef __cplusplus\n} // __cplusplus defined.\n#endif\n\n#endif\n" }, { "path": "libsass-build/include/sass/values.h", "content": "#ifndef SASS_C_VALUES_H\n#define SASS_C_VALUES_H\n\n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n\n// Forward declaration\nunion Sass_Value;\n\n// Type for Sass values\nenum Sass_Tag {\n SASS_BOOLEAN,\n SASS_NUMBER,\n SASS_COLOR,\n SASS_STRING,\n SASS_LIST,\n SASS_MAP,\n SASS_NULL,\n SASS_ERROR,\n SASS_WARNING\n};\n\n// Tags for denoting Sass list separators\nenum Sass_Separator {\n SASS_COMMA,\n SASS_SPACE,\n // only used internally to represent a hash map before evaluation\n // otherwise we would be too early to check for duplicate keys\n SASS_HASH\n};\n\n// Value Operators\nenum Sass_OP {\n AND, OR, // logical connectives\n EQ, NEQ, GT, GTE, LT, LTE, // arithmetic relations\n ADD, SUB, MUL, DIV, MOD, // arithmetic functions\n NUM_OPS // so we know how big to make the op table\n};\n\n// Creator functions for all value types\nADDAPI union Sass_Value* ADDCALL sass_make_null (void);\nADDAPI union Sass_Value* ADDCALL sass_make_boolean (bool val);\nADDAPI union Sass_Value* ADDCALL sass_make_string (const char* val);\nADDAPI union Sass_Value* ADDCALL sass_make_qstring (const char* val);\nADDAPI union Sass_Value* ADDCALL sass_make_number (double val, const char* unit);\nADDAPI union Sass_Value* ADDCALL sass_make_color (double r, double g, double b, double a);\nADDAPI union Sass_Value* ADDCALL sass_make_list (size_t len, enum Sass_Separator sep, bool is_bracketed);\nADDAPI union Sass_Value* ADDCALL sass_make_map (size_t len);\nADDAPI union Sass_Value* ADDCALL sass_make_error (const char* msg);\nADDAPI union Sass_Value* ADDCALL sass_make_warning (const char* msg);\n\n// Generic destructor function for all types\n// Will release memory of all associated Sass_Values\n// Means we will delete recursively for lists and maps\nADDAPI void ADDCALL sass_delete_value (union Sass_Value* val);\n\n// Make a deep cloned copy of the given sass value\nADDAPI union Sass_Value* ADDCALL sass_clone_value (const union Sass_Value* val);\n\n// Execute an operation for two Sass_Values and return the result as a Sass_Value too\nADDAPI union Sass_Value* ADDCALL sass_value_op (enum Sass_OP op, const union Sass_Value* a, const union Sass_Value* b);\n\n// Stringify a Sass_Values and also return the result as a Sass_Value (of type STRING)\nADDAPI union Sass_Value* ADDCALL sass_value_stringify (const union Sass_Value* a, bool compressed, int precision);\n\n// Return the sass tag for a generic sass value\n// Check is needed before accessing specific values!\nADDAPI enum Sass_Tag ADDCALL sass_value_get_tag (const union Sass_Value* v);\n\n// Check value to be of a specific type\n// Can also be used before accessing properties!\nADDAPI bool ADDCALL sass_value_is_null (const union Sass_Value* v);\nADDAPI bool ADDCALL sass_value_is_number (const union Sass_Value* v);\nADDAPI bool ADDCALL sass_value_is_string (const union Sass_Value* v);\nADDAPI bool ADDCALL sass_value_is_boolean (const union Sass_Value* v);\nADDAPI bool ADDCALL sass_value_is_color (const union Sass_Value* v);\nADDAPI bool ADDCALL sass_value_is_list (const union Sass_Value* v);\nADDAPI bool ADDCALL sass_value_is_map (const union Sass_Value* v);\nADDAPI bool ADDCALL sass_value_is_error (const union Sass_Value* v);\nADDAPI bool ADDCALL sass_value_is_warning (const union Sass_Value* v);\n\n// Getters and setters for Sass_Number\nADDAPI double ADDCALL sass_number_get_value (const union Sass_Value* v);\nADDAPI void ADDCALL sass_number_set_value (union Sass_Value* v, double value);\nADDAPI const char* ADDCALL sass_number_get_unit (const union Sass_Value* v);\nADDAPI void ADDCALL sass_number_set_unit (union Sass_Value* v, char* unit);\n\n// Getters and setters for Sass_String\nADDAPI const char* ADDCALL sass_string_get_value (const union Sass_Value* v);\nADDAPI void ADDCALL sass_string_set_value (union Sass_Value* v, char* value);\nADDAPI bool ADDCALL sass_string_is_quoted(const union Sass_Value* v);\nADDAPI void ADDCALL sass_string_set_quoted(union Sass_Value* v, bool quoted);\n\n// Getters and setters for Sass_Boolean\nADDAPI bool ADDCALL sass_boolean_get_value (const union Sass_Value* v);\nADDAPI void ADDCALL sass_boolean_set_value (union Sass_Value* v, bool value);\n\n// Getters and setters for Sass_Color\nADDAPI double ADDCALL sass_color_get_r (const union Sass_Value* v);\nADDAPI void ADDCALL sass_color_set_r (union Sass_Value* v, double r);\nADDAPI double ADDCALL sass_color_get_g (const union Sass_Value* v);\nADDAPI void ADDCALL sass_color_set_g (union Sass_Value* v, double g);\nADDAPI double ADDCALL sass_color_get_b (const union Sass_Value* v);\nADDAPI void ADDCALL sass_color_set_b (union Sass_Value* v, double b);\nADDAPI double ADDCALL sass_color_get_a (const union Sass_Value* v);\nADDAPI void ADDCALL sass_color_set_a (union Sass_Value* v, double a);\n\n// Getter for the number of items in list\nADDAPI size_t ADDCALL sass_list_get_length (const union Sass_Value* v);\n// Getters and setters for Sass_List\nADDAPI enum Sass_Separator ADDCALL sass_list_get_separator (const union Sass_Value* v);\nADDAPI void ADDCALL sass_list_set_separator (union Sass_Value* v, enum Sass_Separator value);\nADDAPI bool ADDCALL sass_list_get_is_bracketed (const union Sass_Value* v);\nADDAPI void ADDCALL sass_list_set_is_bracketed (union Sass_Value* v, bool value);\n// Getters and setters for Sass_List values\nADDAPI union Sass_Value* ADDCALL sass_list_get_value (const union Sass_Value* v, size_t i);\nADDAPI void ADDCALL sass_list_set_value (union Sass_Value* v, size_t i, union Sass_Value* value);\n\n// Getter for the number of items in map\nADDAPI size_t ADDCALL sass_map_get_length (const union Sass_Value* v);\n// Getters and setters for Sass_Map keys and values\nADDAPI union Sass_Value* ADDCALL sass_map_get_key (const union Sass_Value* v, size_t i);\nADDAPI void ADDCALL sass_map_set_key (union Sass_Value* v, size_t i, union Sass_Value*);\nADDAPI union Sass_Value* ADDCALL sass_map_get_value (const union Sass_Value* v, size_t i);\nADDAPI void ADDCALL sass_map_set_value (union Sass_Value* v, size_t i, union Sass_Value*);\n\n// Getters and setters for Sass_Error\nADDAPI char* ADDCALL sass_error_get_message (const union Sass_Value* v);\nADDAPI void ADDCALL sass_error_set_message (union Sass_Value* v, char* msg);\n\n// Getters and setters for Sass_Warning\nADDAPI char* ADDCALL sass_warning_get_message (const union Sass_Value* v);\nADDAPI void ADDCALL sass_warning_set_message (union Sass_Value* v, char* msg);\n\n#ifdef __cplusplus\n} // __cplusplus defined.\n#endif\n\n#endif\n" }, { "path": "libsass-build/include/sass/version.h", "content": "#ifndef SASS_VERSION_H\n#define SASS_VERSION_H\n\n#ifndef LIBSASS_VERSION\n#define LIBSASS_VERSION \"3.5.5\"\n#endif\n\n#ifndef LIBSASS_LANGUAGE_VERSION\n#define LIBSASS_LANGUAGE_VERSION \"3.5\"\n#endif\n\n#endif\n" }, { "path": "libsass-build/include/sass/version.h.in", "content": "#ifndef SASS_VERSION_H\n#define SASS_VERSION_H\n\n#ifndef LIBSASS_VERSION\n#define LIBSASS_VERSION \"@PACKAGE_VERSION@\"\n#endif\n\n#ifndef LIBSASS_LANGUAGE_VERSION\n#define LIBSASS_LANGUAGE_VERSION \"3.5\"\n#endif\n\n#endif\n" }, { "path": "libsass-build/include/sass.h", "content": "#ifndef SASS_H\n#define SASS_H\n\n// #define DEBUG 1\n\n// include API headers\n#include \n#include \n#include \n#include \n#include \n#include \n\n#endif\n\n" }, { "path": "libsass-build/include/sass2scss.h", "content": "/**\n * sass2scss\n * Licensed under the MIT License\n * Copyright (c) Marcel Greter\n */\n\n#ifndef SASS2SCSS_H\n#define SASS2SCSS_H\n\n#ifdef _WIN32\n\n /* You should define ADD_EXPORTS *only* when building the DLL. */\n #ifdef ADD_EXPORTS\n #define ADDAPI __declspec(dllexport)\n\t#define ADDCALL __cdecl\n #else\n #define ADDAPI\n\t#define ADDCALL\n #endif\n\n#else /* _WIN32 not defined. */\n\n /* Define with no value on non-Windows OSes. */\n #define ADDAPI\n #define ADDCALL\n\n#endif\n\n#ifdef __cplusplus\n\n#include \n#include \n#include \n#include \n#include \n\n#ifndef SASS2SCSS_VERSION\n// Hardcode once the file is copied from\n// https://github.com/mgreter/sass2scss\n#define SASS2SCSS_VERSION \"1.1.1\"\n#endif\n\n// add namespace for c++\nnamespace Sass\n{\n\n\t// pretty print options\n\tconst int SASS2SCSS_PRETTIFY_0 = 0;\n\tconst int SASS2SCSS_PRETTIFY_1 = 1;\n\tconst int SASS2SCSS_PRETTIFY_2 = 2;\n\tconst int SASS2SCSS_PRETTIFY_3 = 3;\n\n\t// remove one-line comment\n\tconst int SASS2SCSS_KEEP_COMMENT = 32;\n\t// remove multi-line comments\n\tconst int SASS2SCSS_STRIP_COMMENT = 64;\n\t// convert one-line to multi-line\n\tconst int SASS2SCSS_CONVERT_COMMENT = 128;\n\n\t// String for finding something interesting\n\tconst std::string SASS2SCSS_FIND_WHITESPACE = \" \\t\\n\\v\\f\\r\";\n\n\t// converter struct\n\t// holding all states\n\tstruct converter\n\t{\n\t\t// bit options\n\t\tint options;\n\t\t// is selector\n\t\tbool selector;\n\t\t// concat lists\n\t\tbool comma;\n\t\t// has property\n\t\tbool property;\n\t\t// has semicolon\n\t\tbool semicolon;\n\t\t// comment context\n\t\tstd::string comment;\n\t\t// flag end of file\n\t\tbool end_of_file;\n\t\t// whitespace buffer\n\t\tstd::string whitespace;\n\t\t// context/block stack\n\t\tstd::stack indents;\n\t};\n\n\t// function only available in c++ code\n\tchar* sass2scss (const std::string& sass, const int options);\n\n}\n// EO namespace\n\n// declare for c\nextern \"C\" {\n#endif\n\n\t// prettyfy print options\n\t#define SASS2SCSS_PRETTIFY_0 0\n\t#define SASS2SCSS_PRETTIFY_1 1\n\t#define SASS2SCSS_PRETTIFY_2 2\n\t#define SASS2SCSS_PRETTIFY_3 3\n\n\t// keep one-line comments\n\t#define SASS2SCSS_KEEP_COMMENT 32\n\t// remove multi-line comments\n\t#define SASS2SCSS_STRIP_COMMENT 64\n\t// convert one-line to multi-line\n\t#define SASS2SCSS_CONVERT_COMMENT 128\n\n\t// available to c and c++ code\n\tADDAPI char* ADDCALL sass2scss (const char* sass, const int options);\n\n\t// Get compiled sass2scss version\n\tADDAPI const char* ADDCALL sass2scss_version(void);\n\n#ifdef __cplusplus\n} // __cplusplus defined.\n#endif\n\n#endif" }, { "path": "libsass-build/inspect.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"ast.hpp\"\n#include \"inspect.hpp\"\n#include \"context.hpp\"\n#include \"listize.hpp\"\n#include \"color_maps.hpp\"\n#include \"utf8/checked.h\"\n\nnamespace Sass {\n\n Inspect::Inspect(const Emitter& emi)\n : Emitter(emi)\n { }\n Inspect::~Inspect() { }\n\n // statements\n void Inspect::operator()(Block_Ptr block)\n {\n if (!block->is_root()) {\n add_open_mapping(block);\n append_scope_opener();\n }\n if (output_style() == NESTED) indentation += block->tabs();\n for (size_t i = 0, L = block->length(); i < L; ++i) {\n (*block)[i]->perform(this);\n }\n if (output_style() == NESTED) indentation -= block->tabs();\n if (!block->is_root()) {\n append_scope_closer();\n add_close_mapping(block);\n }\n\n }\n\n void Inspect::operator()(Ruleset_Ptr ruleset)\n {\n if (ruleset->selector()) {\n opt.in_selector = true;\n ruleset->selector()->perform(this);\n opt.in_selector = false;\n }\n if (ruleset->block()) {\n ruleset->block()->perform(this);\n }\n }\n\n void Inspect::operator()(Keyframe_Rule_Ptr rule)\n {\n if (rule->name()) rule->name()->perform(this);\n if (rule->block()) rule->block()->perform(this);\n }\n\n void Inspect::operator()(Bubble_Ptr bubble)\n {\n append_indentation();\n append_token(\"::BUBBLE\", bubble);\n append_scope_opener();\n bubble->node()->perform(this);\n append_scope_closer();\n }\n\n void Inspect::operator()(Media_Block_Ptr media_block)\n {\n append_indentation();\n append_token(\"@media\", media_block);\n append_mandatory_space();\n in_media_block = true;\n media_block->media_queries()->perform(this);\n in_media_block = false;\n media_block->block()->perform(this);\n }\n\n void Inspect::operator()(Supports_Block_Ptr feature_block)\n {\n append_indentation();\n append_token(\"@supports\", feature_block);\n append_mandatory_space();\n feature_block->condition()->perform(this);\n feature_block->block()->perform(this);\n }\n\n void Inspect::operator()(At_Root_Block_Ptr at_root_block)\n {\n append_indentation();\n append_token(\"@at-root \", at_root_block);\n append_mandatory_space();\n if(at_root_block->expression()) at_root_block->expression()->perform(this);\n if(at_root_block->block()) at_root_block->block()->perform(this);\n }\n\n void Inspect::operator()(Directive_Ptr at_rule)\n {\n append_indentation();\n append_token(at_rule->keyword(), at_rule);\n if (at_rule->selector()) {\n append_mandatory_space();\n bool was_wrapped = in_wrapped;\n in_wrapped = true;\n at_rule->selector()->perform(this);\n in_wrapped = was_wrapped;\n }\n if (at_rule->value()) {\n append_mandatory_space();\n at_rule->value()->perform(this);\n }\n if (at_rule->block()) {\n at_rule->block()->perform(this);\n }\n else {\n append_delimiter();\n }\n }\n\n void Inspect::operator()(Declaration_Ptr dec)\n {\n if (dec->value()->concrete_type() == Expression::NULL_VAL) return;\n bool was_decl = in_declaration;\n in_declaration = true;\n LOCAL_FLAG(in_custom_property, dec->is_custom_property());\n\n if (output_style() == NESTED)\n indentation += dec->tabs();\n append_indentation();\n if (dec->property())\n dec->property()->perform(this);\n append_colon_separator();\n\n if (dec->value()->concrete_type() == Expression::SELECTOR) {\n Listize listize;\n Expression_Obj ls = dec->value()->perform(&listize);\n ls->perform(this);\n } else {\n dec->value()->perform(this);\n }\n\n if (dec->is_important()) {\n append_optional_space();\n append_string(\"!important\");\n }\n append_delimiter();\n if (output_style() == NESTED)\n indentation -= dec->tabs();\n in_declaration = was_decl;\n }\n\n void Inspect::operator()(Assignment_Ptr assn)\n {\n append_token(assn->variable(), assn);\n append_colon_separator();\n assn->value()->perform(this);\n if (assn->is_default()) {\n append_optional_space();\n append_string(\"!default\");\n }\n append_delimiter();\n }\n\n void Inspect::operator()(Import_Ptr import)\n {\n if (!import->urls().empty()) {\n append_token(\"@import\", import);\n append_mandatory_space();\n\n import->urls().front()->perform(this);\n if (import->urls().size() == 1) {\n if (import->import_queries()) {\n append_mandatory_space();\n import->import_queries()->perform(this);\n }\n }\n append_delimiter();\n for (size_t i = 1, S = import->urls().size(); i < S; ++i) {\n append_mandatory_linefeed();\n append_token(\"@import\", import);\n append_mandatory_space();\n\n import->urls()[i]->perform(this);\n if (import->urls().size() - 1 == i) {\n if (import->import_queries()) {\n append_mandatory_space();\n import->import_queries()->perform(this);\n }\n }\n append_delimiter();\n }\n }\n }\n\n void Inspect::operator()(Import_Stub_Ptr import)\n {\n append_indentation();\n append_token(\"@import\", import);\n append_mandatory_space();\n append_string(import->imp_path());\n append_delimiter();\n }\n\n void Inspect::operator()(Warning_Ptr warning)\n {\n append_indentation();\n append_token(\"@warn\", warning);\n append_mandatory_space();\n warning->message()->perform(this);\n append_delimiter();\n }\n\n void Inspect::operator()(Error_Ptr error)\n {\n append_indentation();\n append_token(\"@error\", error);\n append_mandatory_space();\n error->message()->perform(this);\n append_delimiter();\n }\n\n void Inspect::operator()(Debug_Ptr debug)\n {\n append_indentation();\n append_token(\"@debug\", debug);\n append_mandatory_space();\n debug->value()->perform(this);\n append_delimiter();\n }\n\n void Inspect::operator()(Comment_Ptr comment)\n {\n in_comment = true;\n comment->text()->perform(this);\n in_comment = false;\n }\n\n void Inspect::operator()(If_Ptr cond)\n {\n append_indentation();\n append_token(\"@if\", cond);\n append_mandatory_space();\n cond->predicate()->perform(this);\n cond->block()->perform(this);\n if (cond->alternative()) {\n append_optional_linefeed();\n append_indentation();\n append_string(\"else\");\n cond->alternative()->perform(this);\n }\n }\n\n void Inspect::operator()(For_Ptr loop)\n {\n append_indentation();\n append_token(\"@for\", loop);\n append_mandatory_space();\n append_string(loop->variable());\n append_string(\" from \");\n loop->lower_bound()->perform(this);\n append_string(loop->is_inclusive() ? \" through \" : \" to \");\n loop->upper_bound()->perform(this);\n loop->block()->perform(this);\n }\n\n void Inspect::operator()(Each_Ptr loop)\n {\n append_indentation();\n append_token(\"@each\", loop);\n append_mandatory_space();\n append_string(loop->variables()[0]);\n for (size_t i = 1, L = loop->variables().size(); i < L; ++i) {\n append_comma_separator();\n append_string(loop->variables()[i]);\n }\n append_string(\" in \");\n loop->list()->perform(this);\n loop->block()->perform(this);\n }\n\n void Inspect::operator()(While_Ptr loop)\n {\n append_indentation();\n append_token(\"@while\", loop);\n append_mandatory_space();\n loop->predicate()->perform(this);\n loop->block()->perform(this);\n }\n\n void Inspect::operator()(Return_Ptr ret)\n {\n append_indentation();\n append_token(\"@return\", ret);\n append_mandatory_space();\n ret->value()->perform(this);\n append_delimiter();\n }\n\n void Inspect::operator()(Extension_Ptr extend)\n {\n append_indentation();\n append_token(\"@extend\", extend);\n append_mandatory_space();\n extend->selector()->perform(this);\n append_delimiter();\n }\n\n void Inspect::operator()(Definition_Ptr def)\n {\n append_indentation();\n if (def->type() == Definition::MIXIN) {\n append_token(\"@mixin\", def);\n append_mandatory_space();\n } else {\n append_token(\"@function\", def);\n append_mandatory_space();\n }\n append_string(def->name());\n def->parameters()->perform(this);\n def->block()->perform(this);\n }\n\n void Inspect::operator()(Mixin_Call_Ptr call)\n {\n append_indentation();\n append_token(\"@include\", call);\n append_mandatory_space();\n append_string(call->name());\n if (call->arguments()) {\n call->arguments()->perform(this);\n }\n if (call->block()) {\n append_optional_space();\n call->block()->perform(this);\n }\n if (!call->block()) append_delimiter();\n }\n\n void Inspect::operator()(Content_Ptr content)\n {\n append_indentation();\n append_token(\"@content\", content);\n append_delimiter();\n }\n\n void Inspect::operator()(Map_Ptr map)\n {\n if (output_style() == TO_SASS && map->empty()) {\n append_string(\"()\");\n return;\n }\n if (map->empty()) return;\n if (map->is_invisible()) return;\n bool items_output = false;\n append_string(\"(\");\n for (auto key : map->keys()) {\n if (items_output) append_comma_separator();\n key->perform(this);\n append_colon_separator();\n LOCAL_FLAG(in_space_array, true);\n LOCAL_FLAG(in_comma_array, true);\n map->at(key)->perform(this);\n items_output = true;\n }\n append_string(\")\");\n }\n\n std::string Inspect::lbracket(List_Ptr list) {\n return list->is_bracketed() ? \"[\" : \"(\";\n }\n\n std::string Inspect::rbracket(List_Ptr list) {\n return list->is_bracketed() ? \"]\" : \")\";\n }\n\n void Inspect::operator()(List_Ptr list)\n {\n if (list->empty() && (output_style() == TO_SASS || list->is_bracketed())) {\n append_string(lbracket(list));\n append_string(rbracket(list));\n return;\n }\n std::string sep(list->separator() == SASS_SPACE ? \" \" : \",\");\n if ((output_style() != COMPRESSED) && sep == \",\") sep += \" \";\n else if (in_media_block && sep != \" \") sep += \" \"; // verified\n if (list->empty()) return;\n bool items_output = false;\n\n bool was_space_array = in_space_array;\n bool was_comma_array = in_comma_array;\n // if the list is bracketed, always include the left bracket\n if (list->is_bracketed()) {\n append_string(lbracket(list));\n }\n // probably ruby sass eqivalent of element_needs_parens\n else if (output_style() == TO_SASS &&\n list->length() == 1 &&\n !list->from_selector() &&\n !Cast(list->at(0)) &&\n !Cast(list->at(0))\n ) {\n append_string(lbracket(list));\n }\n else if (!in_declaration && (list->separator() == SASS_HASH ||\n (list->separator() == SASS_SPACE && in_space_array) ||\n (list->separator() == SASS_COMMA && in_comma_array)\n )) {\n append_string(lbracket(list));\n }\n\n if (list->separator() == SASS_SPACE) in_space_array = true;\n else if (list->separator() == SASS_COMMA) in_comma_array = true;\n\n for (size_t i = 0, L = list->size(); i < L; ++i) {\n if (list->separator() == SASS_HASH)\n { sep[0] = i % 2 ? ':' : ','; }\n Expression_Obj list_item = list->at(i);\n if (output_style() != TO_SASS) {\n if (list_item->is_invisible()) {\n // this fixes an issue with \"\" in a list\n if (!Cast(list_item)) {\n continue;\n }\n }\n }\n if (items_output) {\n append_string(sep);\n }\n if (items_output && sep != \" \")\n append_optional_space();\n list_item->perform(this);\n items_output = true;\n }\n\n in_comma_array = was_comma_array;\n in_space_array = was_space_array;\n\n // if the list is bracketed, always include the right bracket\n if (list->is_bracketed()) {\n if (list->separator() == SASS_COMMA && list->size() == 1) {\n append_string(\",\");\n }\n append_string(rbracket(list));\n }\n // probably ruby sass eqivalent of element_needs_parens\n else if (output_style() == TO_SASS &&\n list->length() == 1 &&\n !list->from_selector() &&\n !Cast(list->at(0)) &&\n !Cast(list->at(0))\n ) {\n append_string(\",\");\n append_string(rbracket(list));\n }\n else if (!in_declaration && (list->separator() == SASS_HASH ||\n (list->separator() == SASS_SPACE && in_space_array) ||\n (list->separator() == SASS_COMMA && in_comma_array)\n )) {\n append_string(rbracket(list));\n }\n\n }\n\n void Inspect::operator()(Binary_Expression_Ptr expr)\n {\n expr->left()->perform(this);\n if ( in_media_block ||\n (output_style() == INSPECT) || (\n expr->op().ws_before\n && (!expr->is_interpolant())\n && (expr->is_left_interpolant() ||\n expr->is_right_interpolant())\n\n )) append_string(\" \");\n switch (expr->optype()) {\n case Sass_OP::AND: append_string(\"&&\"); break;\n case Sass_OP::OR: append_string(\"||\"); break;\n case Sass_OP::EQ: append_string(\"==\"); break;\n case Sass_OP::NEQ: append_string(\"!=\"); break;\n case Sass_OP::GT: append_string(\">\"); break;\n case Sass_OP::GTE: append_string(\">=\"); break;\n case Sass_OP::LT: append_string(\"<\"); break;\n case Sass_OP::LTE: append_string(\"<=\"); break;\n case Sass_OP::ADD: append_string(\"+\"); break;\n case Sass_OP::SUB: append_string(\"-\"); break;\n case Sass_OP::MUL: append_string(\"*\"); break;\n case Sass_OP::DIV: append_string(\"/\"); break;\n case Sass_OP::MOD: append_string(\"%\"); break;\n default: break; // shouldn't get here\n }\n if ( in_media_block ||\n (output_style() == INSPECT) || (\n expr->op().ws_after\n && (!expr->is_interpolant())\n && (expr->is_left_interpolant() ||\n expr->is_right_interpolant())\n )) append_string(\" \");\n expr->right()->perform(this);\n }\n\n void Inspect::operator()(Unary_Expression_Ptr expr)\n {\n if (expr->optype() == Unary_Expression::PLUS) append_string(\"+\");\n else if (expr->optype() == Unary_Expression::SLASH) append_string(\"/\");\n else append_string(\"-\");\n expr->operand()->perform(this);\n }\n\n void Inspect::operator()(Function_Call_Ptr call)\n {\n append_token(call->name(), call);\n call->arguments()->perform(this);\n }\n\n void Inspect::operator()(Function_Call_Schema_Ptr call)\n {\n call->name()->perform(this);\n call->arguments()->perform(this);\n }\n\n void Inspect::operator()(Variable_Ptr var)\n {\n append_token(var->name(), var);\n }\n\n void Inspect::operator()(Number_Ptr n)\n {\n\n std::string res;\n\n // reduce units\n n->reduce();\n\n // check if the fractional part of the value equals to zero\n // neat trick from http://stackoverflow.com/a/1521682/1550314\n // double int_part; bool is_int = modf(value, &int_part) == 0.0;\n\n // this all cannot be done with one run only, since fixed\n // output differs from normal output and regular output\n // can contain scientific notation which we do not want!\n\n // first sample\n std::stringstream ss;\n ss.precision(12);\n ss << n->value();\n\n // check if we got scientific notation in result\n if (ss.str().find_first_of(\"e\") != std::string::npos) {\n ss.clear(); ss.str(std::string());\n ss.precision(std::max(12, opt.precision));\n ss << std::fixed << n->value();\n }\n\n std::string tmp = ss.str();\n size_t pos_point = tmp.find_first_of(\".,\");\n size_t pos_fract = tmp.find_last_not_of(\"0\");\n bool is_int = pos_point == pos_fract ||\n pos_point == std::string::npos;\n\n // reset stream for another run\n ss.clear(); ss.str(std::string());\n\n // take a shortcut for integers\n if (is_int)\n {\n ss.precision(0);\n ss << std::fixed << n->value();\n res = std::string(ss.str());\n }\n // process floats\n else\n {\n // do we have have too much precision?\n if (pos_fract < opt.precision + pos_point)\n { ss.precision((int)(pos_fract - pos_point)); }\n else { ss.precision(opt.precision); }\n // round value again\n ss << std::fixed << n->value();\n res = std::string(ss.str());\n // maybe we truncated up to decimal point\n size_t pos = res.find_last_not_of(\"0\");\n // handle case where we have a \"0\"\n if (pos == std::string::npos) {\n res = \"0.0\";\n } else {\n bool at_dec_point = res[pos] == '.' ||\n res[pos] == ',';\n // don't leave a blank point\n if (at_dec_point) ++ pos;\n res.resize (pos + 1);\n }\n }\n\n // some final cosmetics\n if (res == \"0.0\") res = \"0\";\n else if (res == \"\") res = \"0\";\n else if (res == \"-0\") res = \"0\";\n else if (res == \"-0.0\") res = \"0\";\n else if (opt.output_style == COMPRESSED)\n {\n // check if handling negative nr\n size_t off = res[0] == '-' ? 1 : 0;\n // remove leading zero from floating point in compressed mode\n if (n->zero() && res[off] == '0' && res[off+1] == '.') res.erase(off, 1);\n }\n\n // add unit now\n res += n->unit();\n\n // output the final token\n append_token(res, n);\n }\n\n // helper function for serializing colors\n template \n static double cap_channel(double c) {\n if (c > range) return range;\n else if (c < 0) return 0;\n else return c;\n }\n\n void Inspect::operator()(Color_Ptr c)\n {\n // output the final token\n std::stringstream ss;\n\n // original color name\n // maybe an unknown token\n std::string name = c->disp();\n\n if (opt.in_selector && name != \"\") {\n append_token(name, c);\n return;\n }\n\n // resolved color\n std::string res_name = name;\n\n double r = Sass::round(cap_channel<0xff>(c->r()), opt.precision);\n double g = Sass::round(cap_channel<0xff>(c->g()), opt.precision);\n double b = Sass::round(cap_channel<0xff>(c->b()), opt.precision);\n double a = cap_channel<1> (c->a());\n\n // get color from given name (if one was given at all)\n if (name != \"\" && name_to_color(name)) {\n Color_Ptr_Const n = name_to_color(name);\n r = Sass::round(cap_channel<0xff>(n->r()), opt.precision);\n g = Sass::round(cap_channel<0xff>(n->g()), opt.precision);\n b = Sass::round(cap_channel<0xff>(n->b()), opt.precision);\n a = cap_channel<1> (n->a());\n }\n // otherwise get the possible resolved color name\n else {\n double numval = r * 0x10000 + g * 0x100 + b;\n if (color_to_name(numval))\n res_name = color_to_name(numval);\n }\n\n std::stringstream hexlet;\n // dart sass compressed all colors in regular css always\n // ruby sass and libsass does it only when not delayed\n // since color math is going to be removed, this can go too\n bool compressed = opt.output_style == COMPRESSED;\n hexlet << '#' << std::setw(1) << std::setfill('0');\n // create a short color hexlet if there is any need for it\n if (compressed && is_color_doublet(r, g, b) && a == 1) {\n hexlet << std::hex << std::setw(1) << (static_cast(r) >> 4);\n hexlet << std::hex << std::setw(1) << (static_cast(g) >> 4);\n hexlet << std::hex << std::setw(1) << (static_cast(b) >> 4);\n } else {\n hexlet << std::hex << std::setw(2) << static_cast(r);\n hexlet << std::hex << std::setw(2) << static_cast(g);\n hexlet << std::hex << std::setw(2) << static_cast(b);\n }\n\n if (compressed && !c->is_delayed()) name = \"\";\n if (opt.output_style == INSPECT && a >= 1) {\n append_token(hexlet.str(), c);\n return;\n }\n\n // retain the originally specified color definition if unchanged\n if (name != \"\") {\n ss << name;\n }\n else if (a >= 1) {\n if (res_name != \"\") {\n if (compressed && hexlet.str().size() < res_name.size()) {\n ss << hexlet.str();\n } else {\n ss << res_name;\n }\n }\n else {\n ss << hexlet.str();\n }\n }\n else {\n ss << \"rgba(\";\n ss << static_cast(r) << \",\";\n if (!compressed) ss << \" \";\n ss << static_cast(g) << \",\";\n if (!compressed) ss << \" \";\n ss << static_cast(b) << \",\";\n if (!compressed) ss << \" \";\n ss << a << ')';\n }\n\n append_token(ss.str(), c);\n\n }\n\n void Inspect::operator()(Boolean_Ptr b)\n {\n // output the final token\n append_token(b->value() ? \"true\" : \"false\", b);\n }\n\n void Inspect::operator()(String_Schema_Ptr ss)\n {\n // Evaluation should turn these into String_Constants,\n // so this method is only for inspection purposes.\n for (size_t i = 0, L = ss->length(); i < L; ++i) {\n if ((*ss)[i]->is_interpolant()) append_string(\"#{\");\n (*ss)[i]->perform(this);\n if ((*ss)[i]->is_interpolant()) append_string(\"}\");\n }\n }\n\n void Inspect::operator()(String_Constant_Ptr s)\n {\n append_token(s->value(), s);\n }\n\n void Inspect::operator()(String_Quoted_Ptr s)\n {\n if (const char q = s->quote_mark()) {\n append_token(quote(s->value(), q), s);\n } else {\n append_token(s->value(), s);\n }\n }\n\n void Inspect::operator()(Custom_Error_Ptr e)\n {\n append_token(e->message(), e);\n }\n\n void Inspect::operator()(Custom_Warning_Ptr w)\n {\n append_token(w->message(), w);\n }\n\n void Inspect::operator()(Supports_Operator_Ptr so)\n {\n\n if (so->needs_parens(so->left())) append_string(\"(\");\n so->left()->perform(this);\n if (so->needs_parens(so->left())) append_string(\")\");\n\n if (so->operand() == Supports_Operator::AND) {\n append_mandatory_space();\n append_token(\"and\", so);\n append_mandatory_space();\n } else if (so->operand() == Supports_Operator::OR) {\n append_mandatory_space();\n append_token(\"or\", so);\n append_mandatory_space();\n }\n\n if (so->needs_parens(so->right())) append_string(\"(\");\n so->right()->perform(this);\n if (so->needs_parens(so->right())) append_string(\")\");\n }\n\n void Inspect::operator()(Supports_Negation_Ptr sn)\n {\n append_token(\"not\", sn);\n append_mandatory_space();\n if (sn->needs_parens(sn->condition())) append_string(\"(\");\n sn->condition()->perform(this);\n if (sn->needs_parens(sn->condition())) append_string(\")\");\n }\n\n void Inspect::operator()(Supports_Declaration_Ptr sd)\n {\n append_string(\"(\");\n sd->feature()->perform(this);\n append_string(\": \");\n sd->value()->perform(this);\n append_string(\")\");\n }\n\n void Inspect::operator()(Supports_Interpolation_Ptr sd)\n {\n sd->value()->perform(this);\n }\n\n void Inspect::operator()(Media_Query_Ptr mq)\n {\n size_t i = 0;\n if (mq->media_type()) {\n if (mq->is_negated()) append_string(\"not \");\n else if (mq->is_restricted()) append_string(\"only \");\n mq->media_type()->perform(this);\n }\n else {\n (*mq)[i++]->perform(this);\n }\n for (size_t L = mq->length(); i < L; ++i) {\n append_string(\" and \");\n (*mq)[i]->perform(this);\n }\n }\n\n void Inspect::operator()(Media_Query_Expression_Ptr mqe)\n {\n if (mqe->is_interpolated()) {\n mqe->feature()->perform(this);\n }\n else {\n append_string(\"(\");\n mqe->feature()->perform(this);\n if (mqe->value()) {\n append_string(\": \"); // verified\n mqe->value()->perform(this);\n }\n append_string(\")\");\n }\n }\n\n void Inspect::operator()(At_Root_Query_Ptr ae)\n {\n if (ae->feature()) {\n append_string(\"(\");\n ae->feature()->perform(this);\n if (ae->value()) {\n append_colon_separator();\n ae->value()->perform(this);\n }\n append_string(\")\");\n }\n }\n\n void Inspect::operator()(Function_Ptr f)\n {\n append_token(\"get-function\", f);\n append_string(\"(\");\n append_string(quote(f->name()));\n append_string(\")\");\n }\n\n void Inspect::operator()(Null_Ptr n)\n {\n // output the final token\n append_token(\"null\", n);\n }\n\n // parameters and arguments\n void Inspect::operator()(Parameter_Ptr p)\n {\n append_token(p->name(), p);\n if (p->default_value()) {\n append_colon_separator();\n p->default_value()->perform(this);\n }\n else if (p->is_rest_parameter()) {\n append_string(\"...\");\n }\n }\n\n void Inspect::operator()(Parameters_Ptr p)\n {\n append_string(\"(\");\n if (!p->empty()) {\n (*p)[0]->perform(this);\n for (size_t i = 1, L = p->length(); i < L; ++i) {\n append_comma_separator();\n (*p)[i]->perform(this);\n }\n }\n append_string(\")\");\n }\n\n void Inspect::operator()(Argument_Ptr a)\n {\n if (!a->name().empty()) {\n append_token(a->name(), a);\n append_colon_separator();\n }\n if (!a->value()) return;\n // Special case: argument nulls can be ignored\n if (a->value()->concrete_type() == Expression::NULL_VAL) {\n return;\n }\n if (a->value()->concrete_type() == Expression::STRING) {\n String_Constant_Ptr s = Cast(a->value());\n if (s) s->perform(this);\n } else {\n a->value()->perform(this);\n }\n if (a->is_rest_argument()) {\n append_string(\"...\");\n }\n }\n\n void Inspect::operator()(Arguments_Ptr a)\n {\n append_string(\"(\");\n if (!a->empty()) {\n (*a)[0]->perform(this);\n for (size_t i = 1, L = a->length(); i < L; ++i) {\n append_string(\", \"); // verified\n // Sass Bug? append_comma_separator();\n (*a)[i]->perform(this);\n }\n }\n append_string(\")\");\n }\n\n void Inspect::operator()(Selector_Schema_Ptr s)\n {\n opt.in_selector = true;\n s->contents()->perform(this);\n opt.in_selector = false;\n }\n\n void Inspect::operator()(Parent_Selector_Ptr p)\n {\n if (p->is_real_parent_ref()) append_string(\"&\");\n }\n\n void Inspect::operator()(Placeholder_Selector_Ptr s)\n {\n append_token(s->name(), s);\n if (s->has_line_break()) append_optional_linefeed();\n if (s->has_line_break()) append_indentation();\n\n }\n\n void Inspect::operator()(Element_Selector_Ptr s)\n {\n append_token(s->ns_name(), s);\n }\n\n void Inspect::operator()(Class_Selector_Ptr s)\n {\n append_token(s->ns_name(), s);\n if (s->has_line_break()) append_optional_linefeed();\n if (s->has_line_break()) append_indentation();\n }\n\n void Inspect::operator()(Id_Selector_Ptr s)\n {\n append_token(s->ns_name(), s);\n if (s->has_line_break()) append_optional_linefeed();\n if (s->has_line_break()) append_indentation();\n }\n\n void Inspect::operator()(Attribute_Selector_Ptr s)\n {\n append_string(\"[\");\n add_open_mapping(s);\n append_token(s->ns_name(), s);\n if (!s->matcher().empty()) {\n append_string(s->matcher());\n if (s->value() && *s->value()) {\n s->value()->perform(this);\n }\n }\n add_close_mapping(s);\n if (s->modifier() != 0) {\n append_mandatory_space();\n append_char(s->modifier());\n }\n append_string(\"]\");\n }\n\n void Inspect::operator()(Pseudo_Selector_Ptr s)\n {\n append_token(s->ns_name(), s);\n if (s->expression()) {\n append_string(\"(\");\n s->expression()->perform(this);\n append_string(\")\");\n }\n }\n\n void Inspect::operator()(Wrapped_Selector_Ptr s)\n {\n if (s->name() == \" \") {\n append_string(\"\");\n } else {\n bool was = in_wrapped;\n in_wrapped = true;\n append_token(s->name(), s);\n append_string(\"(\");\n bool was_comma_array = in_comma_array;\n in_comma_array = false;\n s->selector()->perform(this);\n in_comma_array = was_comma_array;\n append_string(\")\");\n in_wrapped = was;\n }\n }\n\n void Inspect::operator()(Compound_Selector_Ptr s)\n {\n for (size_t i = 0, L = s->length(); i < L; ++i) {\n (*s)[i]->perform(this);\n }\n if (s->has_line_break()) {\n if (output_style() != COMPACT) {\n append_optional_linefeed();\n }\n }\n }\n\n void Inspect::operator()(Complex_Selector_Ptr c)\n {\n Compound_Selector_Obj head = c->head();\n Complex_Selector_Obj tail = c->tail();\n Complex_Selector::Combinator comb = c->combinator();\n\n if (comb == Complex_Selector::ANCESTOR_OF && (!head || head->empty())) {\n if (tail) tail->perform(this);\n return;\n }\n\n if (c->has_line_feed()) {\n if (!(c->has_parent_ref())) {\n append_optional_linefeed();\n append_indentation();\n }\n }\n\n if (head && head->length() != 0) head->perform(this);\n bool is_empty = !head || head->length() == 0 || head->is_empty_reference();\n bool is_tail = head && !head->is_empty_reference() && tail;\n if (output_style() == COMPRESSED && comb != Complex_Selector::ANCESTOR_OF) scheduled_space = 0;\n\n switch (comb) {\n case Complex_Selector::ANCESTOR_OF:\n if (is_tail) append_mandatory_space();\n break;\n case Complex_Selector::PARENT_OF:\n append_optional_space();\n append_string(\">\");\n append_optional_space();\n break;\n case Complex_Selector::ADJACENT_TO:\n append_optional_space();\n append_string(\"+\");\n append_optional_space();\n break;\n case Complex_Selector::REFERENCE:\n append_mandatory_space();\n append_string(\"/\");\n if (c->reference()) c->reference()->perform(this);\n append_string(\"/\");\n append_mandatory_space();\n break;\n case Complex_Selector::PRECEDES:\n if (is_empty) append_optional_space();\n else append_mandatory_space();\n append_string(\"~\");\n if (tail) append_mandatory_space();\n else append_optional_space();\n break;\n default: break;\n }\n if (tail && comb != Complex_Selector::ANCESTOR_OF) {\n if (c->has_line_break()) append_optional_linefeed();\n }\n if (tail) tail->perform(this);\n if (!tail && c->has_line_break()) {\n if (output_style() == COMPACT) {\n append_mandatory_space();\n }\n }\n }\n\n void Inspect::operator()(Selector_List_Ptr g)\n {\n\n if (g->empty()) {\n if (output_style() == TO_SASS) {\n append_token(\"()\", g);\n }\n return;\n }\n\n\n bool was_comma_array = in_comma_array;\n // probably ruby sass eqivalent of element_needs_parens\n if (output_style() == TO_SASS && g->length() == 1 &&\n (!Cast((*g)[0]) &&\n !Cast((*g)[0]))) {\n append_string(\"(\");\n }\n else if (!in_declaration && in_comma_array) {\n append_string(\"(\");\n }\n\n if (in_declaration) in_comma_array = true;\n\n for (size_t i = 0, L = g->length(); i < L; ++i) {\n if (!in_wrapped && i == 0) append_indentation();\n if ((*g)[i] == 0) continue;\n schedule_mapping(g->at(i)->last());\n // add_open_mapping((*g)[i]->last());\n (*g)[i]->perform(this);\n // add_close_mapping((*g)[i]->last());\n if (i < L - 1) {\n scheduled_space = 0;\n append_comma_separator();\n }\n }\n\n in_comma_array = was_comma_array;\n // probably ruby sass eqivalent of element_needs_parens\n if (output_style() == TO_SASS && g->length() == 1 &&\n (!Cast((*g)[0]) &&\n !Cast((*g)[0]))) {\n append_string(\",)\");\n }\n else if (!in_declaration && in_comma_array) {\n append_string(\")\");\n }\n\n }\n\n void Inspect::fallback_impl(AST_Node_Ptr n)\n {\n }\n\n}\n" }, { "path": "libsass-build/inspect.hpp", "content": "#ifndef SASS_INSPECT_H\n#define SASS_INSPECT_H\n\n#include \"position.hpp\"\n#include \"operation.hpp\"\n#include \"emitter.hpp\"\n\nnamespace Sass {\n class Context;\n\n class Inspect : public Operation_CRTP, public Emitter {\n protected:\n // import all the class-specific methods and override as desired\n using Operation_CRTP::operator();\n\n void fallback_impl(AST_Node_Ptr n);\n\n public:\n\n Inspect(const Emitter& emi);\n virtual ~Inspect();\n\n // statements\n virtual void operator()(Block_Ptr);\n virtual void operator()(Ruleset_Ptr);\n virtual void operator()(Bubble_Ptr);\n virtual void operator()(Supports_Block_Ptr);\n virtual void operator()(Media_Block_Ptr);\n virtual void operator()(At_Root_Block_Ptr);\n virtual void operator()(Directive_Ptr);\n virtual void operator()(Keyframe_Rule_Ptr);\n virtual void operator()(Declaration_Ptr);\n virtual void operator()(Assignment_Ptr);\n virtual void operator()(Import_Ptr);\n virtual void operator()(Import_Stub_Ptr);\n virtual void operator()(Warning_Ptr);\n virtual void operator()(Error_Ptr);\n virtual void operator()(Debug_Ptr);\n virtual void operator()(Comment_Ptr);\n virtual void operator()(If_Ptr);\n virtual void operator()(For_Ptr);\n virtual void operator()(Each_Ptr);\n virtual void operator()(While_Ptr);\n virtual void operator()(Return_Ptr);\n virtual void operator()(Extension_Ptr);\n virtual void operator()(Definition_Ptr);\n virtual void operator()(Mixin_Call_Ptr);\n virtual void operator()(Content_Ptr);\n // expressions\n virtual void operator()(Map_Ptr);\n virtual void operator()(Function_Ptr);\n virtual void operator()(List_Ptr);\n virtual void operator()(Binary_Expression_Ptr);\n virtual void operator()(Unary_Expression_Ptr);\n virtual void operator()(Function_Call_Ptr);\n virtual void operator()(Function_Call_Schema_Ptr);\n // virtual void operator()(Custom_Warning_Ptr);\n // virtual void operator()(Custom_Error_Ptr);\n virtual void operator()(Variable_Ptr);\n virtual void operator()(Number_Ptr);\n virtual void operator()(Color_Ptr);\n virtual void operator()(Boolean_Ptr);\n virtual void operator()(String_Schema_Ptr);\n virtual void operator()(String_Constant_Ptr);\n virtual void operator()(String_Quoted_Ptr);\n virtual void operator()(Custom_Error_Ptr);\n virtual void operator()(Custom_Warning_Ptr);\n virtual void operator()(Supports_Operator_Ptr);\n virtual void operator()(Supports_Negation_Ptr);\n virtual void operator()(Supports_Declaration_Ptr);\n virtual void operator()(Supports_Interpolation_Ptr);\n virtual void operator()(Media_Query_Ptr);\n virtual void operator()(Media_Query_Expression_Ptr);\n virtual void operator()(At_Root_Query_Ptr);\n virtual void operator()(Null_Ptr);\n virtual void operator()(Parent_Selector_Ptr p);\n // parameters and arguments\n virtual void operator()(Parameter_Ptr);\n virtual void operator()(Parameters_Ptr);\n virtual void operator()(Argument_Ptr);\n virtual void operator()(Arguments_Ptr);\n // selectors\n virtual void operator()(Selector_Schema_Ptr);\n virtual void operator()(Placeholder_Selector_Ptr);\n virtual void operator()(Element_Selector_Ptr);\n virtual void operator()(Class_Selector_Ptr);\n virtual void operator()(Id_Selector_Ptr);\n virtual void operator()(Attribute_Selector_Ptr);\n virtual void operator()(Pseudo_Selector_Ptr);\n virtual void operator()(Wrapped_Selector_Ptr);\n virtual void operator()(Compound_Selector_Ptr);\n virtual void operator()(Complex_Selector_Ptr);\n virtual void operator()(Selector_List_Ptr);\n\n virtual std::string lbracket(List_Ptr);\n virtual std::string rbracket(List_Ptr);\n\n // template \n // void fallback(U x) { fallback_impl(reinterpret_cast(x)); }\n };\n\n}\n#endif\n" }, { "path": "libsass-build/json.cpp", "content": "/*\n Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com)\n All rights reserved.\n\n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n THE SOFTWARE.\n*/\n\n#ifdef _MSC_VER\n#define _CRT_SECURE_NO_WARNINGS\n#define _CRT_NONSTDC_NO_DEPRECATE\n#endif\n\n#include \"json.hpp\"\n\n// include utf8 library used by libsass\n// ToDo: replace internal json utf8 code\n#include \"utf8.h\"\n\n#include \n#include \n#include \n#include \n#include \n\n#if defined(_MSC_VER) && _MSC_VER < 1900\n#include \n#ifdef snprintf\n#undef snprintf\n#endif\nextern \"C\" int snprintf(char *, size_t, const char *, ...);\n#endif\n\n#define out_of_memory() do { \\\n fprintf(stderr, \"Out of memory.\\n\"); \\\n exit(EXIT_FAILURE); \\\n } while (0)\n\n/* Sadly, strdup is not portable. */\nstatic char *json_strdup(const char *str)\n{\n char *ret = (char*) malloc(strlen(str) + 1);\n if (ret == NULL)\n out_of_memory();\n strcpy(ret, str);\n return ret;\n}\n\n/* String buffer */\n\ntypedef struct\n{\n char *cur;\n char *end;\n char *start;\n} SB;\n\nstatic void sb_init(SB *sb)\n{\n sb->start = (char*) malloc(17);\n if (sb->start == NULL)\n out_of_memory();\n sb->cur = sb->start;\n sb->end = sb->start + 16;\n}\n\n/* sb and need may be evaluated multiple times. */\n#define sb_need(sb, need) do { \\\n if ((sb)->end - (sb)->cur < (need)) \\\n sb_grow(sb, need); \\\n } while (0)\n\nstatic void sb_grow(SB *sb, int need)\n{\n size_t length = sb->cur - sb->start;\n size_t alloc = sb->end - sb->start;\n\n do {\n alloc *= 2;\n } while (alloc < length + need);\n\n sb->start = (char*) realloc(sb->start, alloc + 1);\n if (sb->start == NULL)\n out_of_memory();\n sb->cur = sb->start + length;\n sb->end = sb->start + alloc;\n}\n\nstatic void sb_put(SB *sb, const char *bytes, int count)\n{\n sb_need(sb, count);\n memcpy(sb->cur, bytes, count);\n sb->cur += count;\n}\n\n#define sb_putc(sb, c) do { \\\n if ((sb)->cur >= (sb)->end) \\\n sb_grow(sb, 1); \\\n *(sb)->cur++ = (c); \\\n } while (0)\n\nstatic void sb_puts(SB *sb, const char *str)\n{\n sb_put(sb, str, (int)strlen(str));\n}\n\nstatic char *sb_finish(SB *sb)\n{\n *sb->cur = 0;\n assert(sb->start <= sb->cur && strlen(sb->start) == (size_t)(sb->cur - sb->start));\n return sb->start;\n}\n\nstatic void sb_free(SB *sb)\n{\n free(sb->start);\n}\n\n/*\n * Unicode helper functions\n *\n * These are taken from the ccan/charset module and customized a bit.\n * Putting them here means the compiler can (choose to) inline them,\n * and it keeps ccan/json from having a dependency.\n *\n * We use uint32_t Type for Unicode codepoints.\n * We need our own because wchar_t might be 16 bits.\n */\n\n/*\n * Validate a single UTF-8 character starting at @s.\n * The string must be null-terminated.\n *\n * If it's valid, return its length (1 thru 4).\n * If it's invalid or clipped, return 0.\n *\n * This function implements the syntax given in RFC3629, which is\n * the same as that given in The Unicode Standard, Version 6.0.\n *\n * It has the following properties:\n *\n * * All codepoints U+0000..U+10FFFF may be encoded,\n * except for U+D800..U+DFFF, which are reserved\n * for UTF-16 surrogate pair encoding.\n * * UTF-8 byte sequences longer than 4 bytes are not permitted,\n * as they exceed the range of Unicode.\n * * The sixty-six Unicode \"non-characters\" are permitted\n * (namely, U+FDD0..U+FDEF, U+xxFFFE, and U+xxFFFF).\n */\nstatic int utf8_validate_cz(const char *s)\n{\n unsigned char c = *s++;\n\n if (c <= 0x7F) { /* 00..7F */\n return 1;\n } else if (c <= 0xC1) { /* 80..C1 */\n /* Disallow overlong 2-byte sequence. */\n return 0;\n } else if (c <= 0xDF) { /* C2..DF */\n /* Make sure subsequent byte is in the range 0x80..0xBF. */\n if (((unsigned char)*s++ & 0xC0) != 0x80)\n return 0;\n\n return 2;\n } else if (c <= 0xEF) { /* E0..EF */\n /* Disallow overlong 3-byte sequence. */\n if (c == 0xE0 && (unsigned char)*s < 0xA0)\n return 0;\n\n /* Disallow U+D800..U+DFFF. */\n if (c == 0xED && (unsigned char)*s > 0x9F)\n return 0;\n\n /* Make sure subsequent bytes are in the range 0x80..0xBF. */\n if (((unsigned char)*s++ & 0xC0) != 0x80)\n return 0;\n if (((unsigned char)*s++ & 0xC0) != 0x80)\n return 0;\n\n return 3;\n } else if (c <= 0xF4) { /* F0..F4 */\n /* Disallow overlong 4-byte sequence. */\n if (c == 0xF0 && (unsigned char)*s < 0x90)\n return 0;\n\n /* Disallow codepoints beyond U+10FFFF. */\n if (c == 0xF4 && (unsigned char)*s > 0x8F)\n return 0;\n\n /* Make sure subsequent bytes are in the range 0x80..0xBF. */\n if (((unsigned char)*s++ & 0xC0) != 0x80)\n return 0;\n if (((unsigned char)*s++ & 0xC0) != 0x80)\n return 0;\n if (((unsigned char)*s++ & 0xC0) != 0x80)\n return 0;\n\n return 4;\n } else { /* F5..FF */\n return 0;\n }\n}\n\n/* Validate a null-terminated UTF-8 string. */\nstatic bool utf8_validate(const char *s)\n{\n int len;\n\n for (; *s != 0; s += len) {\n len = utf8_validate_cz(s);\n if (len == 0)\n return false;\n }\n\n return true;\n}\n\n/*\n * Read a single UTF-8 character starting at @s,\n * returning the length, in bytes, of the character read.\n *\n * This function assumes input is valid UTF-8,\n * and that there are enough characters in front of @s.\n */\nstatic int utf8_read_char(const char *s, uint32_t *out)\n{\n const unsigned char *c = (const unsigned char*) s;\n\n assert(utf8_validate_cz(s));\n\n if (c[0] <= 0x7F) {\n /* 00..7F */\n *out = c[0];\n return 1;\n } else if (c[0] <= 0xDF) {\n /* C2..DF (unless input is invalid) */\n *out = ((uint32_t)c[0] & 0x1F) << 6 |\n ((uint32_t)c[1] & 0x3F);\n return 2;\n } else if (c[0] <= 0xEF) {\n /* E0..EF */\n *out = ((uint32_t)c[0] & 0xF) << 12 |\n ((uint32_t)c[1] & 0x3F) << 6 |\n ((uint32_t)c[2] & 0x3F);\n return 3;\n } else {\n /* F0..F4 (unless input is invalid) */\n *out = ((uint32_t)c[0] & 0x7) << 18 |\n ((uint32_t)c[1] & 0x3F) << 12 |\n ((uint32_t)c[2] & 0x3F) << 6 |\n ((uint32_t)c[3] & 0x3F);\n return 4;\n }\n}\n\n/*\n * Write a single UTF-8 character to @s,\n * returning the length, in bytes, of the character written.\n *\n * @unicode must be U+0000..U+10FFFF, but not U+D800..U+DFFF.\n *\n * This function will write up to 4 bytes to @out.\n */\nstatic int utf8_write_char(uint32_t unicode, char *out)\n{\n unsigned char *o = (unsigned char*) out;\n\n assert(unicode <= 0x10FFFF && !(unicode >= 0xD800 && unicode <= 0xDFFF));\n\n if (unicode <= 0x7F) {\n /* U+0000..U+007F */\n *o++ = unicode;\n return 1;\n } else if (unicode <= 0x7FF) {\n /* U+0080..U+07FF */\n *o++ = 0xC0 | unicode >> 6;\n *o++ = 0x80 | (unicode & 0x3F);\n return 2;\n } else if (unicode <= 0xFFFF) {\n /* U+0800..U+FFFF */\n *o++ = 0xE0 | unicode >> 12;\n *o++ = 0x80 | (unicode >> 6 & 0x3F);\n *o++ = 0x80 | (unicode & 0x3F);\n return 3;\n } else {\n /* U+10000..U+10FFFF */\n *o++ = 0xF0 | unicode >> 18;\n *o++ = 0x80 | (unicode >> 12 & 0x3F);\n *o++ = 0x80 | (unicode >> 6 & 0x3F);\n *o++ = 0x80 | (unicode & 0x3F);\n return 4;\n }\n}\n\n/*\n * Compute the Unicode codepoint of a UTF-16 surrogate pair.\n *\n * @uc should be 0xD800..0xDBFF, and @lc should be 0xDC00..0xDFFF.\n * If they aren't, this function returns false.\n */\nstatic bool from_surrogate_pair(uint16_t uc, uint16_t lc, uint32_t *unicode)\n{\n if (uc >= 0xD800 && uc <= 0xDBFF && lc >= 0xDC00 && lc <= 0xDFFF) {\n *unicode = 0x10000 + ((((uint32_t)uc & 0x3FF) << 10) | (lc & 0x3FF));\n return true;\n } else {\n return false;\n }\n}\n\n/*\n * Construct a UTF-16 surrogate pair given a Unicode codepoint.\n *\n * @unicode must be U+10000..U+10FFFF.\n */\nstatic void to_surrogate_pair(uint32_t unicode, uint16_t *uc, uint16_t *lc)\n{\n uint32_t n;\n\n assert(unicode >= 0x10000 && unicode <= 0x10FFFF);\n\n n = unicode - 0x10000;\n *uc = ((n >> 10) & 0x3FF) | 0xD800;\n *lc = (n & 0x3FF) | 0xDC00;\n}\n\nstatic bool is_space (const char *c);\nstatic bool is_digit (const char *c);\nstatic bool parse_value (const char **sp, JsonNode **out);\nstatic bool parse_string (const char **sp, char **out);\nstatic bool parse_number (const char **sp, double *out);\nstatic bool parse_array (const char **sp, JsonNode **out);\nstatic bool parse_object (const char **sp, JsonNode **out);\nstatic bool parse_hex16 (const char **sp, uint16_t *out);\n\nstatic bool expect_literal (const char **sp, const char *str);\nstatic void skip_space (const char **sp);\n\nstatic void emit_value (SB *out, const JsonNode *node);\nstatic void emit_value_indented (SB *out, const JsonNode *node, const char *space, int indent_level);\nstatic void emit_string (SB *out, const char *str);\nstatic void emit_number (SB *out, double num);\nstatic void emit_array (SB *out, const JsonNode *array);\nstatic void emit_array_indented (SB *out, const JsonNode *array, const char *space, int indent_level);\nstatic void emit_object (SB *out, const JsonNode *object);\nstatic void emit_object_indented (SB *out, const JsonNode *object, const char *space, int indent_level);\n\nstatic int write_hex16(char *out, uint16_t val);\n\nstatic JsonNode *mknode(JsonTag tag);\nstatic void append_node(JsonNode *parent, JsonNode *child);\nstatic void prepend_node(JsonNode *parent, JsonNode *child);\nstatic void append_member(JsonNode *object, char *key, JsonNode *value);\n\n/* Assertion-friendly validity checks */\nstatic bool tag_is_valid(unsigned int tag);\nstatic bool number_is_valid(const char *num);\n\nJsonNode *json_decode(const char *json)\n{\n const char *s = json;\n JsonNode *ret;\n\n skip_space(&s);\n if (!parse_value(&s, &ret))\n return NULL;\n\n skip_space(&s);\n if (*s != 0) {\n json_delete(ret);\n return NULL;\n }\n\n return ret;\n}\n\nchar *json_encode(const JsonNode *node)\n{\n return json_stringify(node, NULL);\n}\n\nchar *json_encode_string(const char *str)\n{\n SB sb;\n sb_init(&sb);\n\n try {\n emit_string(&sb, str);\n }\n catch (std::exception) {\n sb_free(&sb);\n throw;\n }\n\n return sb_finish(&sb);\n}\n\nchar *json_stringify(const JsonNode *node, const char *space)\n{\n SB sb;\n sb_init(&sb);\n\n try {\n if (space != NULL)\n emit_value_indented(&sb, node, space, 0);\n else\n emit_value(&sb, node);\n }\n catch (std::exception) {\n sb_free(&sb);\n throw;\n }\n\n return sb_finish(&sb);\n}\n\nvoid json_delete(JsonNode *node)\n{\n if (node != NULL) {\n json_remove_from_parent(node);\n\n switch (node->tag) {\n case JSON_STRING:\n free(node->string_);\n break;\n case JSON_ARRAY:\n case JSON_OBJECT:\n {\n JsonNode *child, *next;\n for (child = node->children.head; child != NULL; child = next) {\n next = child->next;\n json_delete(child);\n }\n break;\n }\n default:;\n }\n\n free(node);\n }\n}\n\nbool json_validate(const char *json)\n{\n const char *s = json;\n\n skip_space(&s);\n if (!parse_value(&s, NULL))\n return false;\n\n skip_space(&s);\n if (*s != 0)\n return false;\n\n return true;\n}\n\nJsonNode *json_find_element(JsonNode *array, int index)\n{\n JsonNode *element;\n int i = 0;\n\n if (array == NULL || array->tag != JSON_ARRAY)\n return NULL;\n\n json_foreach(element, array) {\n if (i == index)\n return element;\n i++;\n }\n\n return NULL;\n}\n\nJsonNode *json_find_member(JsonNode *object, const char *name)\n{\n JsonNode *member;\n\n if (object == NULL || object->tag != JSON_OBJECT)\n return NULL;\n\n json_foreach(member, object)\n if (strcmp(member->key, name) == 0)\n return member;\n\n return NULL;\n}\n\nJsonNode *json_first_child(const JsonNode *node)\n{\n if (node != NULL && (node->tag == JSON_ARRAY || node->tag == JSON_OBJECT))\n return node->children.head;\n return NULL;\n}\n\nstatic JsonNode *mknode(JsonTag tag)\n{\n JsonNode *ret = (JsonNode*) calloc(1, sizeof(JsonNode));\n if (ret == NULL)\n out_of_memory();\n ret->tag = tag;\n return ret;\n}\n\nJsonNode *json_mknull(void)\n{\n return mknode(JSON_NULL);\n}\n\nJsonNode *json_mkbool(bool b)\n{\n JsonNode *ret = mknode(JSON_BOOL);\n ret->bool_ = b;\n return ret;\n}\n\nstatic JsonNode *mkstring(char *s)\n{\n JsonNode *ret = mknode(JSON_STRING);\n ret->string_ = s;\n return ret;\n}\n\nJsonNode *json_mkstring(const char *s)\n{\n return mkstring(json_strdup(s));\n}\n\nJsonNode *json_mknumber(double n)\n{\n JsonNode *node = mknode(JSON_NUMBER);\n node->number_ = n;\n return node;\n}\n\nJsonNode *json_mkarray(void)\n{\n return mknode(JSON_ARRAY);\n}\n\nJsonNode *json_mkobject(void)\n{\n return mknode(JSON_OBJECT);\n}\n\nstatic void append_node(JsonNode *parent, JsonNode *child)\n{\n if (child != NULL && parent != NULL) {\n child->parent = parent;\n child->prev = parent->children.tail;\n child->next = NULL;\n\n if (parent->children.tail != NULL)\n parent->children.tail->next = child;\n else\n parent->children.head = child;\n parent->children.tail = child;\n }\n}\n\nstatic void prepend_node(JsonNode *parent, JsonNode *child)\n{\n if (child != NULL && parent != NULL) {\n child->parent = parent;\n child->prev = NULL;\n child->next = parent->children.head;\n\n if (parent->children.head != NULL)\n parent->children.head->prev = child;\n else\n parent->children.tail = child;\n parent->children.head = child;\n }\n}\n\nstatic void append_member(JsonNode *object, char *key, JsonNode *value)\n{\n if (value != NULL && object != NULL) {\n value->key = key;\n append_node(object, value);\n }\n}\n\nvoid json_append_element(JsonNode *array, JsonNode *element)\n{\n if (array != NULL && element !=NULL) {\n assert(array->tag == JSON_ARRAY);\n assert(element->parent == NULL);\n\n append_node(array, element);\n }\n}\n\nvoid json_prepend_element(JsonNode *array, JsonNode *element)\n{\n assert(array->tag == JSON_ARRAY);\n assert(element->parent == NULL);\n\n prepend_node(array, element);\n}\n\nvoid json_append_member(JsonNode *object, const char *key, JsonNode *value)\n{\n if (object != NULL && key != NULL && value != NULL) {\n assert(object->tag == JSON_OBJECT);\n assert(value->parent == NULL);\n\n append_member(object, json_strdup(key), value);\n }\n}\n\nvoid json_prepend_member(JsonNode *object, const char *key, JsonNode *value)\n{\n if (object != NULL && key != NULL && value != NULL) {\n assert(object->tag == JSON_OBJECT);\n assert(value->parent == NULL);\n\n value->key = json_strdup(key);\n prepend_node(object, value);\n }\n}\n\nvoid json_remove_from_parent(JsonNode *node)\n{\n if (node != NULL) {\n JsonNode *parent = node->parent;\n\n if (parent != NULL) {\n if (node->prev != NULL)\n node->prev->next = node->next;\n else\n parent->children.head = node->next;\n\n if (node->next != NULL)\n node->next->prev = node->prev;\n else\n parent->children.tail = node->prev;\n\n free(node->key);\n\n node->parent = NULL;\n node->prev = node->next = NULL;\n node->key = NULL;\n }\n }\n}\n\nstatic bool parse_value(const char **sp, JsonNode **out)\n{\n const char *s = *sp;\n\n switch (*s) {\n case 'n':\n if (expect_literal(&s, \"null\")) {\n if (out)\n *out = json_mknull();\n *sp = s;\n return true;\n }\n return false;\n\n case 'f':\n if (expect_literal(&s, \"false\")) {\n if (out)\n *out = json_mkbool(false);\n *sp = s;\n return true;\n }\n return false;\n\n case 't':\n if (expect_literal(&s, \"true\")) {\n if (out)\n *out = json_mkbool(true);\n *sp = s;\n return true;\n }\n return false;\n\n case '\"': {\n char *str = NULL;\n if (parse_string(&s, out ? &str : NULL)) {\n if (out)\n *out = mkstring(str);\n *sp = s;\n return true;\n }\n return false;\n }\n\n case '[':\n if (parse_array(&s, out)) {\n *sp = s;\n return true;\n }\n return false;\n\n case '{':\n if (parse_object(&s, out)) {\n *sp = s;\n return true;\n }\n return false;\n\n default: {\n double num;\n if (parse_number(&s, out ? &num : NULL)) {\n if (out)\n *out = json_mknumber(num);\n *sp = s;\n return true;\n }\n return false;\n }\n }\n}\n\nstatic bool parse_array(const char **sp, JsonNode **out)\n{\n const char *s = *sp;\n JsonNode *ret = out ? json_mkarray() : NULL;\n JsonNode *element = NULL;\n\n if (*s++ != '[')\n goto failure;\n skip_space(&s);\n\n if (*s == ']') {\n s++;\n goto success;\n }\n\n for (;;) {\n if (!parse_value(&s, out ? &element : NULL))\n goto failure;\n skip_space(&s);\n\n if (out)\n json_append_element(ret, element);\n\n if (*s == ']') {\n s++;\n goto success;\n }\n\n if (*s++ != ',')\n goto failure;\n skip_space(&s);\n }\n\nsuccess:\n *sp = s;\n if (out)\n *out = ret;\n return true;\n\nfailure:\n json_delete(ret);\n return false;\n}\n\nstatic bool parse_object(const char **sp, JsonNode **out)\n{\n const char *s = *sp;\n JsonNode *ret = out ? json_mkobject() : NULL;\n char *key = NULL;\n JsonNode *value = NULL;\n\n if (*s++ != '{')\n goto failure;\n skip_space(&s);\n\n if (*s == '}') {\n s++;\n goto success;\n }\n\n for (;;) {\n if (!parse_string(&s, out ? &key : NULL))\n goto failure;\n skip_space(&s);\n\n if (*s++ != ':')\n goto failure_free_key;\n skip_space(&s);\n\n if (!parse_value(&s, out ? &value : NULL))\n goto failure_free_key;\n skip_space(&s);\n\n if (out)\n append_member(ret, key, value);\n\n if (*s == '}') {\n s++;\n goto success;\n }\n\n if (*s++ != ',')\n goto failure;\n skip_space(&s);\n }\n\nsuccess:\n *sp = s;\n if (out)\n *out = ret;\n return true;\n\nfailure_free_key:\n if (out)\n free(key);\nfailure:\n json_delete(ret);\n return false;\n}\n\nbool parse_string(const char **sp, char **out)\n{\n const char *s = *sp;\n SB sb = { 0, 0, 0 };\n char throwaway_buffer[4];\n /* enough space for a UTF-8 character */\n char *b;\n\n if (*s++ != '\"')\n return false;\n\n if (out) {\n sb_init(&sb);\n sb_need(&sb, 4);\n b = sb.cur;\n } else {\n b = throwaway_buffer;\n }\n\n while (*s != '\"') {\n unsigned char c = *s++;\n\n /* Parse next character, and write it to b. */\n if (c == '\\\\') {\n c = *s++;\n switch (c) {\n case '\"':\n case '\\\\':\n case '/':\n *b++ = c;\n break;\n case 'b':\n *b++ = '\\b';\n break;\n case 'f':\n *b++ = '\\f';\n break;\n case 'n':\n *b++ = '\\n';\n break;\n case 'r':\n *b++ = '\\r';\n break;\n case 't':\n *b++ = '\\t';\n break;\n case 'u':\n {\n uint16_t uc, lc;\n uint32_t unicode;\n\n if (!parse_hex16(&s, &uc))\n goto failed;\n\n if (uc >= 0xD800 && uc <= 0xDFFF) {\n /* Handle UTF-16 surrogate pair. */\n if (*s++ != '\\\\' || *s++ != 'u' || !parse_hex16(&s, &lc))\n goto failed; /* Incomplete surrogate pair. */\n if (!from_surrogate_pair(uc, lc, &unicode))\n goto failed; /* Invalid surrogate pair. */\n } else if (uc == 0) {\n /* Disallow \"\\u0000\". */\n goto failed;\n } else {\n unicode = uc;\n }\n\n b += utf8_write_char(unicode, b);\n break;\n }\n default:\n /* Invalid escape */\n goto failed;\n }\n } else if (c <= 0x1F) {\n /* Control characters are not allowed in string literals. */\n goto failed;\n } else {\n /* Validate and echo a UTF-8 character. */\n int len;\n\n s--;\n len = utf8_validate_cz(s);\n if (len == 0)\n goto failed; /* Invalid UTF-8 character. */\n\n while (len--)\n *b++ = *s++;\n }\n\n /*\n * Update sb to know about the new bytes,\n * and set up b to write another character.\n */\n if (out) {\n sb.cur = b;\n sb_need(&sb, 4);\n b = sb.cur;\n } else {\n b = throwaway_buffer;\n }\n }\n s++;\n\n if (out)\n *out = sb_finish(&sb);\n *sp = s;\n return true;\n\nfailed:\n if (out)\n sb_free(&sb);\n return false;\n}\n\nbool is_space(const char *c) {\n return ((*c) == '\\t' || (*c) == '\\n' || (*c) == '\\r' || (*c) == ' ');\n}\n\nbool is_digit(const char *c){\n return ((*c) >= '0' && (*c) <= '9');\n}\n\n/*\n * The JSON spec says that a number shall follow this precise pattern\n * (spaces and quotes added for readability):\n * '-'? (0 | [1-9][0-9]*) ('.' [0-9]+)? ([Ee] [+-]? [0-9]+)?\n *\n * However, some JSON parsers are more liberal. For instance, PHP accepts\n * '.5' and '1.'. JSON.parse accepts '+3'.\n *\n * This function takes the strict approach.\n */\nbool parse_number(const char **sp, double *out)\n{\n const char *s = *sp;\n\n /* '-'? */\n if (*s == '-')\n s++;\n\n /* (0 | [1-9][0-9]*) */\n if (*s == '0') {\n s++;\n } else {\n if (!is_digit(s))\n return false;\n do {\n s++;\n } while (is_digit(s));\n }\n\n /* ('.' [0-9]+)? */\n if (*s == '.') {\n s++;\n if (!is_digit(s))\n return false;\n do {\n s++;\n } while (is_digit(s));\n }\n\n /* ([Ee] [+-]? [0-9]+)? */\n if (*s == 'E' || *s == 'e') {\n s++;\n if (*s == '+' || *s == '-')\n s++;\n if (!is_digit(s))\n return false;\n do {\n s++;\n } while (is_digit(s));\n }\n\n if (out)\n *out = strtod(*sp, NULL);\n\n *sp = s;\n return true;\n}\n\nstatic void skip_space(const char **sp)\n{\n const char *s = *sp;\n while (is_space(s))\n s++;\n *sp = s;\n}\n\nstatic void emit_value(SB *out, const JsonNode *node)\n{\n assert(tag_is_valid(node->tag));\n switch (node->tag) {\n case JSON_NULL:\n sb_puts(out, \"null\");\n break;\n case JSON_BOOL:\n sb_puts(out, node->bool_ ? \"true\" : \"false\");\n break;\n case JSON_STRING:\n emit_string(out, node->string_);\n break;\n case JSON_NUMBER:\n emit_number(out, node->number_);\n break;\n case JSON_ARRAY:\n emit_array(out, node);\n break;\n case JSON_OBJECT:\n emit_object(out, node);\n break;\n default:\n assert(false);\n }\n}\n\nvoid emit_value_indented(SB *out, const JsonNode *node, const char *space, int indent_level)\n{\n assert(tag_is_valid(node->tag));\n switch (node->tag) {\n case JSON_NULL:\n sb_puts(out, \"null\");\n break;\n case JSON_BOOL:\n sb_puts(out, node->bool_ ? \"true\" : \"false\");\n break;\n case JSON_STRING:\n emit_string(out, node->string_);\n break;\n case JSON_NUMBER:\n emit_number(out, node->number_);\n break;\n case JSON_ARRAY:\n emit_array_indented(out, node, space, indent_level);\n break;\n case JSON_OBJECT:\n emit_object_indented(out, node, space, indent_level);\n break;\n default:\n assert(false);\n }\n}\n\nstatic void emit_array(SB *out, const JsonNode *array)\n{\n const JsonNode *element;\n\n sb_putc(out, '[');\n json_foreach(element, array) {\n emit_value(out, element);\n if (element->next != NULL)\n sb_putc(out, ',');\n }\n sb_putc(out, ']');\n}\n\nstatic void emit_array_indented(SB *out, const JsonNode *array, const char *space, int indent_level)\n{\n const JsonNode *element = array->children.head;\n int i;\n\n if (element == NULL) {\n sb_puts(out, \"[]\");\n return;\n }\n\n sb_puts(out, \"[\\n\");\n while (element != NULL) {\n for (i = 0; i < indent_level + 1; i++)\n sb_puts(out, space);\n emit_value_indented(out, element, space, indent_level + 1);\n\n element = element->next;\n sb_puts(out, element != NULL ? \",\\n\" : \"\\n\");\n }\n for (i = 0; i < indent_level; i++)\n sb_puts(out, space);\n sb_putc(out, ']');\n}\n\nstatic void emit_object(SB *out, const JsonNode *object)\n{\n const JsonNode *member;\n\n sb_putc(out, '{');\n json_foreach(member, object) {\n emit_string(out, member->key);\n sb_putc(out, ':');\n emit_value(out, member);\n if (member->next != NULL)\n sb_putc(out, ',');\n }\n sb_putc(out, '}');\n}\n\nstatic void emit_object_indented(SB *out, const JsonNode *object, const char *space, int indent_level)\n{\n const JsonNode *member = object->children.head;\n int i;\n\n if (member == NULL) {\n sb_puts(out, \"{}\");\n return;\n }\n\n sb_puts(out, \"{\\n\");\n while (member != NULL) {\n for (i = 0; i < indent_level + 1; i++)\n sb_puts(out, space);\n emit_string(out, member->key);\n sb_puts(out, \": \");\n emit_value_indented(out, member, space, indent_level + 1);\n\n member = member->next;\n sb_puts(out, member != NULL ? \",\\n\" : \"\\n\");\n }\n for (i = 0; i < indent_level; i++)\n sb_puts(out, space);\n sb_putc(out, '}');\n}\n\nvoid emit_string(SB *out, const char *str)\n{\n bool escape_unicode = false;\n const char *s = str;\n char *b;\n\n// make assertion catchable\n#ifndef NDEBUG\n if (!utf8_validate(str)) {\n throw utf8::invalid_utf8(0);\n }\n#endif\n\n assert(utf8_validate(str));\n\n /*\n * 14 bytes is enough space to write up to two\n * \\uXXXX escapes and two quotation marks.\n */\n sb_need(out, 14);\n b = out->cur;\n\n *b++ = '\"';\n while (*s != 0) {\n unsigned char c = *s++;\n\n /* Encode the next character, and write it to b. */\n switch (c) {\n case '\"':\n *b++ = '\\\\';\n *b++ = '\"';\n break;\n case '\\\\':\n *b++ = '\\\\';\n *b++ = '\\\\';\n break;\n case '\\b':\n *b++ = '\\\\';\n *b++ = 'b';\n break;\n case '\\f':\n *b++ = '\\\\';\n *b++ = 'f';\n break;\n case '\\n':\n *b++ = '\\\\';\n *b++ = 'n';\n break;\n case '\\r':\n *b++ = '\\\\';\n *b++ = 'r';\n break;\n case '\\t':\n *b++ = '\\\\';\n *b++ = 't';\n break;\n default: {\n int len;\n\n s--;\n len = utf8_validate_cz(s);\n\n if (len == 0) {\n /*\n * Handle invalid UTF-8 character gracefully in production\n * by writing a replacement character (U+FFFD)\n * and skipping a single byte.\n *\n * This should never happen when assertions are enabled\n * due to the assertion at the beginning of this function.\n */\n assert(false);\n if (escape_unicode) {\n strcpy(b, \"\\\\uFFFD\");\n b += 6;\n } else {\n *b++ = 0xEFu;\n *b++ = 0xBFu;\n *b++ = 0xBDu;\n }\n s++;\n } else if (c < 0x1F || (c >= 0x80 && escape_unicode)) {\n /* Encode using \\u.... */\n uint32_t unicode;\n\n s += utf8_read_char(s, &unicode);\n\n if (unicode <= 0xFFFF) {\n *b++ = '\\\\';\n *b++ = 'u';\n b += write_hex16(b, unicode);\n } else {\n /* Produce a surrogate pair. */\n uint16_t uc, lc;\n assert(unicode <= 0x10FFFF);\n to_surrogate_pair(unicode, &uc, &lc);\n *b++ = '\\\\';\n *b++ = 'u';\n b += write_hex16(b, uc);\n *b++ = '\\\\';\n *b++ = 'u';\n b += write_hex16(b, lc);\n }\n } else {\n /* Write the character directly. */\n while (len--)\n *b++ = *s++;\n }\n\n break;\n }\n }\n\n /*\n * Update *out to know about the new bytes,\n * and set up b to write another encoded character.\n */\n out->cur = b;\n sb_need(out, 14);\n b = out->cur;\n }\n *b++ = '\"';\n\n out->cur = b;\n}\n\nstatic void emit_number(SB *out, double num)\n{\n /*\n * This isn't exactly how JavaScript renders numbers,\n * but it should produce valid JSON for reasonable numbers\n * preserve precision well enough, and avoid some oddities\n * like 0.3 -> 0.299999999999999988898 .\n */\n char buf[64];\n sprintf(buf, \"%.16g\", num);\n\n if (number_is_valid(buf))\n sb_puts(out, buf);\n else\n sb_puts(out, \"null\");\n}\n\nstatic bool tag_is_valid(unsigned int tag)\n{\n return (/* tag >= JSON_NULL && */ tag <= JSON_OBJECT);\n}\n\nstatic bool number_is_valid(const char *num)\n{\n return (parse_number(&num, NULL) && *num == '\\0');\n}\n\nstatic bool expect_literal(const char **sp, const char *str)\n{\n const char *s = *sp;\n\n while (*str != '\\0')\n if (*s++ != *str++)\n return false;\n\n *sp = s;\n return true;\n}\n\n/*\n * Parses exactly 4 hex characters (capital or lowercase).\n * Fails if any input chars are not [0-9A-Fa-f].\n */\nstatic bool parse_hex16(const char **sp, uint16_t *out)\n{\n const char *s = *sp;\n uint16_t ret = 0;\n uint16_t i;\n uint16_t tmp;\n char c;\n\n for (i = 0; i < 4; i++) {\n c = *s++;\n if (c >= '0' && c <= '9')\n tmp = c - '0';\n else if (c >= 'A' && c <= 'F')\n tmp = c - 'A' + 10;\n else if (c >= 'a' && c <= 'f')\n tmp = c - 'a' + 10;\n else\n return false;\n\n ret <<= 4;\n ret += tmp;\n }\n\n if (out)\n *out = ret;\n *sp = s;\n return true;\n}\n\n/*\n * Encodes a 16-bit number into hexadecimal,\n * writing exactly 4 hex chars.\n */\nstatic int write_hex16(char *out, uint16_t val)\n{\n const char *hex = \"0123456789ABCDEF\";\n\n *out++ = hex[(val >> 12) & 0xF];\n *out++ = hex[(val >> 8) & 0xF];\n *out++ = hex[(val >> 4) & 0xF];\n *out++ = hex[ val & 0xF];\n\n return 4;\n}\n\nbool json_check(const JsonNode *node, char errmsg[256])\n{\n #define problem(...) do { \\\n if (errmsg != NULL) \\\n snprintf(errmsg, 256, __VA_ARGS__); \\\n return false; \\\n } while (0)\n\n if (node->key != NULL && !utf8_validate(node->key))\n problem(\"key contains invalid UTF-8\");\n\n if (!tag_is_valid(node->tag))\n problem(\"tag is invalid (%u)\", node->tag);\n\n if (node->tag == JSON_BOOL) {\n if (node->bool_ != false && node->bool_ != true)\n problem(\"bool_ is neither false (%d) nor true (%d)\", (int)false, (int)true);\n } else if (node->tag == JSON_STRING) {\n if (node->string_ == NULL)\n problem(\"string_ is NULL\");\n if (!utf8_validate(node->string_))\n problem(\"string_ contains invalid UTF-8\");\n } else if (node->tag == JSON_ARRAY || node->tag == JSON_OBJECT) {\n JsonNode *head = node->children.head;\n JsonNode *tail = node->children.tail;\n\n if (head == NULL || tail == NULL) {\n if (head != NULL)\n problem(\"tail is NULL, but head is not\");\n if (tail != NULL)\n problem(\"head is NULL, but tail is not\");\n } else {\n JsonNode *child;\n JsonNode *last = NULL;\n\n if (head->prev != NULL)\n problem(\"First child's prev pointer is not NULL\");\n\n for (child = head; child != NULL; last = child, child = child->next) {\n if (child == node)\n problem(\"node is its own child\");\n if (child->next == child)\n problem(\"child->next == child (cycle)\");\n if (child->next == head)\n problem(\"child->next == head (cycle)\");\n\n if (child->parent != node)\n problem(\"child does not point back to parent\");\n if (child->next != NULL && child->next->prev != child)\n problem(\"child->next does not point back to child\");\n\n if (node->tag == JSON_ARRAY && child->key != NULL)\n problem(\"Array element's key is not NULL\");\n if (node->tag == JSON_OBJECT && child->key == NULL)\n problem(\"Object member's key is NULL\");\n\n if (!json_check(child, errmsg))\n return false;\n }\n\n if (last != tail)\n problem(\"tail does not match pointer found by starting at head and following next links\");\n }\n }\n\n return true;\n\n #undef problem\n}\n" }, { "path": "libsass-build/json.hpp", "content": "/*\n Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com)\n All rights reserved.\n\n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n THE SOFTWARE.\n*/\n\n#ifndef CCAN_JSON_H\n#define CCAN_JSON_H\n\n#include \n#include \n\ntypedef enum {\n JSON_NULL,\n JSON_BOOL,\n JSON_STRING,\n JSON_NUMBER,\n JSON_ARRAY,\n JSON_OBJECT,\n} JsonTag;\n\ntypedef struct JsonNode JsonNode;\n\nstruct JsonNode\n{\n /* only if parent is an object or array (NULL otherwise) */\n JsonNode *parent;\n JsonNode *prev, *next;\n\n /* only if parent is an object (NULL otherwise) */\n char *key; /* Must be valid UTF-8. */\n\n JsonTag tag;\n union {\n /* JSON_BOOL */\n bool bool_;\n\n /* JSON_STRING */\n char *string_; /* Must be valid UTF-8. */\n\n /* JSON_NUMBER */\n double number_;\n\n /* JSON_ARRAY */\n /* JSON_OBJECT */\n struct {\n JsonNode *head, *tail;\n } children;\n };\n};\n\n/*** Encoding, decoding, and validation ***/\n\nJsonNode *json_decode (const char *json);\nchar *json_encode (const JsonNode *node);\nchar *json_encode_string (const char *str);\nchar *json_stringify (const JsonNode *node, const char *space);\nvoid json_delete (JsonNode *node);\n\nbool json_validate (const char *json);\n\n/*** Lookup and traversal ***/\n\nJsonNode *json_find_element (JsonNode *array, int index);\nJsonNode *json_find_member (JsonNode *object, const char *key);\n\nJsonNode *json_first_child (const JsonNode *node);\n\n#define json_foreach(i, object_or_array) \\\n for ((i) = json_first_child(object_or_array); \\\n (i) != NULL; \\\n (i) = (i)->next)\n\n/*** Construction and manipulation ***/\n\nJsonNode *json_mknull(void);\nJsonNode *json_mkbool(bool b);\nJsonNode *json_mkstring(const char *s);\nJsonNode *json_mknumber(double n);\nJsonNode *json_mkarray(void);\nJsonNode *json_mkobject(void);\n\nvoid json_append_element(JsonNode *array, JsonNode *element);\nvoid json_prepend_element(JsonNode *array, JsonNode *element);\nvoid json_append_member(JsonNode *object, const char *key, JsonNode *value);\nvoid json_prepend_member(JsonNode *object, const char *key, JsonNode *value);\n\nvoid json_remove_from_parent(JsonNode *node);\n\n/*** Debugging ***/\n\n/*\n * Look for structure and encoding problems in a JsonNode or its descendents.\n *\n * If a problem is detected, return false, writing a description of the problem\n * to errmsg (unless errmsg is NULL).\n */\nbool json_check(const JsonNode *node, char errmsg[256]);\n\n#endif\n" }, { "path": "libsass-build/kwd_arg_macros.hpp", "content": "#ifndef SASS_KWD_ARG_MACROS_H\n#define SASS_KWD_ARG_MACROS_H\n\n// Example usage:\n// KWD_ARG_SET(Args) {\n// KWD_ARG(Args, string, foo);\n// KWD_ARG(Args, int, bar);\n// ...\n// };\n//\n// ... and later ...\n//\n// something(Args().foo(\"hey\").bar(3));\n\n#define KWD_ARG_SET(set_name) class set_name\n\n#define KWD_ARG(set_name, type, name) \\\nprivate: \\\n type name##_; \\\npublic: \\\n set_name& name(type name##__) { \\\n name##_ = name##__; \\\n return *this; \\\n } \\\n type name() { return name##_; } \\\nprivate:\n\n#endif\n" }, { "path": "libsass-build/lexer.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n#include \n#include \"lexer.hpp\"\n#include \"constants.hpp\"\n\n\nnamespace Sass {\n using namespace Constants;\n\n namespace Prelexer {\n\n //####################################\n // BASIC CHARACTER MATCHERS\n //####################################\n\n // Match standard control chars\n const char* kwd_at(const char* src) { return exactly<'@'>(src); }\n const char* kwd_dot(const char* src) { return exactly<'.'>(src); }\n const char* kwd_comma(const char* src) { return exactly<','>(src); };\n const char* kwd_colon(const char* src) { return exactly<':'>(src); };\n const char* kwd_star(const char* src) { return exactly<'*'>(src); };\n const char* kwd_plus(const char* src) { return exactly<'+'>(src); };\n const char* kwd_minus(const char* src) { return exactly<'-'>(src); };\n const char* kwd_slash(const char* src) { return exactly<'/'>(src); };\n\n //####################################\n // implement some function that do exist in the standard\n // but those are locale aware which brought some trouble\n // this even seems to improve performance by quite a bit\n //####################################\n\n bool is_alpha(const char& chr)\n {\n return unsigned(chr - 'A') <= 'Z' - 'A' ||\n unsigned(chr - 'a') <= 'z' - 'a';\n }\n\n bool is_space(const char& chr)\n {\n // adapted the technique from is_alpha\n return chr == ' ' || unsigned(chr - '\\t') <= '\\r' - '\\t';\n }\n\n bool is_digit(const char& chr)\n {\n // adapted the technique from is_alpha\n return unsigned(chr - '0') <= '9' - '0';\n }\n\n bool is_number(const char& chr)\n {\n // adapted the technique from is_alpha\n return is_digit(chr) || chr == '-' || chr == '+';\n }\n\n bool is_xdigit(const char& chr)\n {\n // adapted the technique from is_alpha\n return unsigned(chr - '0') <= '9' - '0' ||\n unsigned(chr - 'a') <= 'f' - 'a' ||\n unsigned(chr - 'A') <= 'F' - 'A';\n }\n\n bool is_punct(const char& chr)\n {\n // locale independent\n return chr == '.';\n }\n\n bool is_alnum(const char& chr)\n {\n return is_alpha(chr) || is_digit(chr);\n }\n\n // check if char is outside ascii range\n bool is_unicode(const char& chr)\n {\n // check for unicode range\n return unsigned(chr) > 127;\n }\n\n // check if char is outside ascii range\n // but with specific ranges (copied from Ruby Sass)\n bool is_nonascii(const char& chr)\n {\n unsigned int cmp = unsigned(chr);\n return (\n (cmp >= 128 && cmp <= 15572911) ||\n (cmp >= 15630464 && cmp <= 15712189) ||\n (cmp >= 4036001920)\n );\n }\n\n // check if char is within a reduced ascii range\n // valid in a uri (copied from Ruby Sass)\n bool is_uri_character(const char& chr)\n {\n unsigned int cmp = unsigned(chr);\n return (cmp > 41 && cmp < 127) ||\n cmp == ':' || cmp == '/';\n }\n\n // check if char is within a reduced ascii range\n // valid for escaping (copied from Ruby Sass)\n bool is_escapable_character(const char& chr)\n {\n unsigned int cmp = unsigned(chr);\n return cmp > 31 && cmp < 127;\n }\n\n // Match word character (look ahead)\n bool is_character(const char& chr)\n {\n // valid alpha, numeric or unicode char (plus hyphen)\n return is_alnum(chr) || is_unicode(chr) || chr == '-';\n }\n\n //####################################\n // BASIC CLASS MATCHERS\n //####################################\n\n // create matchers that advance the position\n const char* space(const char* src) { return is_space(*src) ? src + 1 : 0; }\n const char* alpha(const char* src) { return is_alpha(*src) ? src + 1 : 0; }\n const char* unicode(const char* src) { return is_unicode(*src) ? src + 1 : 0; }\n const char* nonascii(const char* src) { return is_nonascii(*src) ? src + 1 : 0; }\n const char* digit(const char* src) { return is_digit(*src) ? src + 1 : 0; }\n const char* xdigit(const char* src) { return is_xdigit(*src) ? src + 1 : 0; }\n const char* alnum(const char* src) { return is_alnum(*src) ? src + 1 : 0; }\n const char* punct(const char* src) { return is_punct(*src) ? src + 1 : 0; }\n const char* hyphen(const char* src) { return *src && *src == '-' ? src + 1 : 0; }\n const char* character(const char* src) { return is_character(*src) ? src + 1 : 0; }\n const char* uri_character(const char* src) { return is_uri_character(*src) ? src + 1 : 0; }\n const char* escapable_character(const char* src) { return is_escapable_character(*src) ? src + 1 : 0; }\n\n // Match multiple ctype characters.\n const char* spaces(const char* src) { return one_plus(src); }\n const char* digits(const char* src) { return one_plus(src); }\n const char* hyphens(const char* src) { return one_plus(src); }\n\n // Whitespace handling.\n const char* no_spaces(const char* src) { return negate< space >(src); }\n const char* optional_spaces(const char* src) { return zero_plus< space >(src); }\n\n // Match any single character.\n const char* any_char(const char* src) { return *src ? src + 1 : src; }\n\n // Match word boundary (zero-width lookahead).\n const char* word_boundary(const char* src) { return is_character(*src) || *src == '#' ? 0 : src; }\n\n // Match linefeed /(?:\\n|\\r\\n?)/\n const char* re_linebreak(const char* src)\n {\n // end of file or unix linefeed return here\n if (*src == 0 || *src == '\\n') return src + 1;\n // a carriage return may optionally be followed by a linefeed\n if (*src == '\\r') return *(src + 1) == '\\n' ? src + 2 : src + 1;\n // no linefeed\n return 0;\n }\n\n // Assert string boundaries (/\\Z|\\z|\\A/)\n // This is a zero-width positive lookahead\n const char* end_of_line(const char* src)\n {\n // end of file or unix linefeed return here\n return *src == 0 || *src == '\\n' || *src == '\\r' ? src : 0;\n }\n\n // Assert end_of_file boundary (/\\z/)\n // This is a zero-width positive lookahead\n const char* end_of_file(const char* src)\n {\n // end of file or unix linefeed return here\n return *src == 0 ? src : 0;\n }\n\n }\n}\n" }, { "path": "libsass-build/lexer.hpp", "content": "#ifndef SASS_LEXER_H\n#define SASS_LEXER_H\n\n#include \n\nnamespace Sass {\n namespace Prelexer {\n\n //####################################\n // BASIC CHARACTER MATCHERS\n //####################################\n\n // Match standard control chars\n const char* kwd_at(const char* src);\n const char* kwd_dot(const char* src);\n const char* kwd_comma(const char* src);\n const char* kwd_colon(const char* src);\n const char* kwd_star(const char* src);\n const char* kwd_plus(const char* src);\n const char* kwd_minus(const char* src);\n const char* kwd_slash(const char* src);\n\n //####################################\n // BASIC CLASS MATCHERS\n //####################################\n\n // These are locale independant\n bool is_space(const char& src);\n bool is_alpha(const char& src);\n bool is_punct(const char& src);\n bool is_digit(const char& src);\n bool is_number(const char& src);\n bool is_alnum(const char& src);\n bool is_xdigit(const char& src);\n bool is_unicode(const char& src);\n bool is_nonascii(const char& src);\n bool is_character(const char& src);\n bool is_uri_character(const char& src);\n bool escapable_character(const char& src);\n\n // Match a single ctype predicate.\n const char* space(const char* src);\n const char* alpha(const char* src);\n const char* digit(const char* src);\n const char* xdigit(const char* src);\n const char* alnum(const char* src);\n const char* punct(const char* src);\n const char* hyphen(const char* src);\n const char* unicode(const char* src);\n const char* nonascii(const char* src);\n const char* character(const char* src);\n const char* uri_character(const char* src);\n const char* escapable_character(const char* src);\n\n // Match multiple ctype characters.\n const char* spaces(const char* src);\n const char* digits(const char* src);\n const char* hyphens(const char* src);\n\n // Whitespace handling.\n const char* no_spaces(const char* src);\n const char* optional_spaces(const char* src);\n\n // Match any single character (/./).\n const char* any_char(const char* src);\n\n // Assert word boundary (/\\b/)\n // Is a zero-width positive lookaheads\n const char* word_boundary(const char* src);\n\n // Match a single linebreak (/(?:\\n|\\r\\n?)/).\n const char* re_linebreak(const char* src);\n\n // Assert string boundaries (/\\Z|\\z|\\A/)\n // There are zero-width positive lookaheads\n const char* end_of_line(const char* src);\n\n // Assert end_of_file boundary (/\\z/)\n const char* end_of_file(const char* src);\n // const char* start_of_string(const char* src);\n\n // Type definition for prelexer functions\n typedef const char* (*prelexer)(const char*);\n\n //####################################\n // BASIC \"REGEX\" CONSTRUCTORS\n //####################################\n\n // Match a single character literal.\n // Regex equivalent: /(?:x)/\n template \n const char* exactly(const char* src) {\n return *src == chr ? src + 1 : 0;\n }\n\n // Match the full string literal.\n // Regex equivalent: /(?:literal)/\n template \n const char* exactly(const char* src) {\n if (str == NULL) return 0;\n const char* pre = str;\n if (src == NULL) return 0;\n // there is a small chance that the search string\n // is longer than the rest of the string to look at\n while (*pre && *src == *pre) {\n ++src, ++pre;\n }\n // did the matcher finish?\n return *pre == 0 ? src : 0;\n }\n\n\n // Match a single character literal.\n // Regex equivalent: /(?:x)/i\n // only define lower case alpha chars\n template \n const char* insensitive(const char* src) {\n return *src == chr || *src+32 == chr ? src + 1 : 0;\n }\n\n // Match the full string literal.\n // Regex equivalent: /(?:literal)/i\n // only define lower case alpha chars\n template \n const char* insensitive(const char* src) {\n if (str == NULL) return 0;\n const char* pre = str;\n if (src == NULL) return 0;\n // there is a small chance that the search string\n // is longer than the rest of the string to look at\n while (*pre && (*src == *pre || *src+32 == *pre)) {\n ++src, ++pre;\n }\n // did the matcher finish?\n return *pre == 0 ? src : 0;\n }\n\n // Match for members of char class.\n // Regex equivalent: /[axy]/\n template \n const char* class_char(const char* src) {\n const char* cc = char_class;\n while (*cc && *src != *cc) ++cc;\n return *cc ? src + 1 : 0;\n }\n\n // Match for members of char class.\n // Regex equivalent: /[axy]+/\n template \n const char* class_chars(const char* src) {\n const char* p = src;\n while (class_char(p)) ++p;\n return p == src ? 0 : p;\n }\n\n // Match for members of char class.\n // Regex equivalent: /[^axy]/\n template \n const char* neg_class_char(const char* src) {\n if (*src == 0) return 0;\n const char* cc = neg_char_class;\n while (*cc && *src != *cc) ++cc;\n return *cc ? 0 : src + 1;\n }\n\n // Match for members of char class.\n // Regex equivalent: /[^axy]+/\n template \n const char* neg_class_chars(const char* src) {\n const char* p = src;\n while (neg_class_char(p)) ++p;\n return p == src ? 0 : p;\n }\n\n // Match all except the supplied one.\n // Regex equivalent: /[^x]/\n template \n const char* any_char_but(const char* src) {\n return (*src && *src != chr) ? src + 1 : 0;\n }\n\n // Succeeds if the matcher fails.\n // Aka. zero-width negative lookahead.\n // Regex equivalent: /(?!literal)/\n template \n const char* negate(const char* src) {\n return mx(src) ? 0 : src;\n }\n\n // Succeeds if the matcher succeeds.\n // Aka. zero-width positive lookahead.\n // Regex equivalent: /(?=literal)/\n // just hangs around until we need it\n template \n const char* lookahead(const char* src) {\n return mx(src) ? src : 0;\n }\n\n // Tries supplied matchers in order.\n // Succeeds if one of them succeeds.\n // Regex equivalent: /(?:FOO|BAR)/\n template \n const char* alternatives(const char* src) {\n const char* rslt;\n if ((rslt = mx(src))) return rslt;\n return 0;\n }\n template \n const char* alternatives(const char* src) {\n const char* rslt;\n if ((rslt = mx1(src))) return rslt;\n return alternatives(src);\n }\n\n // Tries supplied matchers in order.\n // Succeeds if all of them succeeds.\n // Regex equivalent: /(?:FOO)(?:BAR)/\n template \n const char* sequence(const char* src) {\n const char* rslt = src;\n if (!(rslt = mx1(rslt))) return 0;\n return rslt;\n }\n template \n const char* sequence(const char* src) {\n const char* rslt = src;\n if (!(rslt = mx1(rslt))) return 0;\n return sequence(rslt);\n }\n\n\n // Match a pattern or not. Always succeeds.\n // Regex equivalent: /(?:literal)?/\n template \n const char* optional(const char* src) {\n const char* p = mx(src);\n return p ? p : src;\n }\n\n // Match zero or more of the patterns.\n // Regex equivalent: /(?:literal)*/\n template \n const char* zero_plus(const char* src) {\n const char* p = mx(src);\n while (p) src = p, p = mx(src);\n return src;\n }\n\n // Match one or more of the patterns.\n // Regex equivalent: /(?:literal)+/\n template \n const char* one_plus(const char* src) {\n const char* p = mx(src);\n if (!p) return 0;\n while (p) src = p, p = mx(src);\n return src;\n }\n\n // Match mx non-greedy until delimiter.\n // Other prelexers are greedy by default.\n // Regex equivalent: /(?:$mx)*?(?=$delim)\\b/\n template \n const char* non_greedy(const char* src) {\n while (!delim(src)) {\n const char* p = mx(src);\n if (p == src) return 0;\n if (p == 0) return 0;\n src = p;\n }\n return src;\n }\n\n //####################################\n // ADVANCED \"REGEX\" CONSTRUCTORS\n //####################################\n\n // Match with word boundary rule.\n // Regex equivalent: /(?:$mx)\\b/i\n template \n const char* keyword(const char* src) {\n return sequence <\n insensitive < str >,\n word_boundary\n >(src);\n }\n\n // Match with word boundary rule.\n // Regex equivalent: /(?:$mx)\\b/\n template \n const char* word(const char* src) {\n return sequence <\n exactly < str >,\n word_boundary\n >(src);\n }\n\n template \n const char* loosely(const char* src) {\n return sequence <\n optional_spaces,\n exactly < chr >\n >(src);\n }\n template \n const char* loosely(const char* src) {\n return sequence <\n optional_spaces,\n exactly < str >\n >(src);\n }\n\n }\n}\n\n#endif\n" }, { "path": "libsass-build/listize.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n#include \n\n#include \"listize.hpp\"\n#include \"context.hpp\"\n#include \"backtrace.hpp\"\n#include \"error_handling.hpp\"\n\nnamespace Sass {\n\n Listize::Listize()\n { }\n\n Expression_Ptr Listize::operator()(Selector_List_Ptr sel)\n {\n List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);\n l->from_selector(true);\n for (size_t i = 0, L = sel->length(); i < L; ++i) {\n if (!sel->at(i)) continue;\n l->append(sel->at(i)->perform(this));\n }\n if (l->length()) return l.detach();\n return SASS_MEMORY_NEW(Null, l->pstate());\n }\n\n Expression_Ptr Listize::operator()(Compound_Selector_Ptr sel)\n {\n std::string str;\n for (size_t i = 0, L = sel->length(); i < L; ++i) {\n Expression_Ptr e = (*sel)[i]->perform(this);\n if (e) str += e->to_string();\n }\n return SASS_MEMORY_NEW(String_Quoted, sel->pstate(), str);\n }\n\n Expression_Ptr Listize::operator()(Complex_Selector_Ptr sel)\n {\n List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), 2);\n l->from_selector(true);\n Compound_Selector_Obj head = sel->head();\n if (head && !head->is_empty_reference())\n {\n Expression_Ptr hh = head->perform(this);\n if (hh) l->append(hh);\n }\n\n std::string reference = ! sel->reference() ? \"\"\n : sel->reference()->to_string();\n switch(sel->combinator())\n {\n case Complex_Selector::PARENT_OF:\n l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), \">\"));\n break;\n case Complex_Selector::ADJACENT_TO:\n l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), \"+\"));\n break;\n case Complex_Selector::REFERENCE:\n l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), \"/\" + reference + \"/\"));\n break;\n case Complex_Selector::PRECEDES:\n l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), \"~\"));\n break;\n case Complex_Selector::ANCESTOR_OF:\n break;\n default: break;\n }\n\n Complex_Selector_Obj tail = sel->tail();\n if (tail)\n {\n Expression_Obj tt = tail->perform(this);\n if (List_Ptr ls = Cast(tt))\n { l->concat(ls); }\n }\n if (l->length() == 0) return 0;\n return l.detach();\n }\n\n Expression_Ptr Listize::fallback_impl(AST_Node_Ptr n)\n {\n return Cast(n);\n }\n\n}\n" }, { "path": "libsass-build/listize.hpp", "content": "#ifndef SASS_LISTIZE_H\n#define SASS_LISTIZE_H\n\n#include \n#include \n\n#include \"ast.hpp\"\n#include \"context.hpp\"\n#include \"operation.hpp\"\n#include \"environment.hpp\"\n\nnamespace Sass {\n\n struct Backtrace;\n\n class Listize : public Operation_CRTP {\n\n Expression_Ptr fallback_impl(AST_Node_Ptr n);\n\n public:\n Listize();\n ~Listize() { }\n\n Expression_Ptr operator()(Selector_List_Ptr);\n Expression_Ptr operator()(Complex_Selector_Ptr);\n Expression_Ptr operator()(Compound_Selector_Ptr);\n\n template \n Expression_Ptr fallback(U x) { return fallback_impl(x); }\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/mapping.hpp", "content": "#ifndef SASS_MAPPING_H\n#define SASS_MAPPING_H\n\n#include \"position.hpp\"\n\nnamespace Sass {\n\n struct Mapping {\n Position original_position;\n Position generated_position;\n\n Mapping(const Position& original_position, const Position& generated_position)\n : original_position(original_position), generated_position(generated_position) { }\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/memory/SharedPtr.cpp", "content": "#include \"../sass.hpp\"\n#include \n#include \n\n#include \"SharedPtr.hpp\"\n#include \"../ast_fwd_decl.hpp\"\n\n#ifdef DEBUG_SHARED_PTR\n#include \"../debugger.hpp\"\n#endif\n\nnamespace Sass {\n\n #ifdef DEBUG_SHARED_PTR\n void SharedObj::dumpMemLeaks() {\n if (!all.empty()) {\n std::cerr << \"###################################\\n\";\n std::cerr << \"# REPORTING MISSING DEALLOCATIONS #\\n\";\n std::cerr << \"###################################\\n\";\n for (SharedObj* var : all) {\n if (AST_Node_Ptr ast = dynamic_cast(var)) {\n debug_ast(ast);\n } else {\n std::cerr << \"LEAKED \" << var << \"\\n\";\n }\n }\n }\n }\n std::vector SharedObj::all;\n #endif\n\n bool SharedObj::taint = false;\n\n SharedObj::SharedObj()\n : detached(false)\n #ifdef DEBUG_SHARED_PTR\n , dbg(false)\n #endif\n {\n refcounter = 0;\n #ifdef DEBUG_SHARED_PTR\n if (taint) all.push_back(this);\n #endif\n };\n\n SharedObj::~SharedObj() {\n #ifdef DEBUG_SHARED_PTR\n if (dbg) std::cerr << \"Destruct \" << this << \"\\n\";\n if(!all.empty()) { // check needed for MSVC (no clue why?)\n all.erase(std::remove(all.begin(), all.end(), this), all.end());\n }\n #endif\n };\n\n void SharedPtr::decRefCount() {\n if (node) {\n -- node->refcounter;\n #ifdef DEBUG_SHARED_PTR\n if (node->dbg) std::cerr << \"- \" << node << \" X \" << node->refcounter << \" (\" << this << \") \" << \"\\n\";\n #endif\n if (node->refcounter == 0) {\n #ifdef DEBUG_SHARED_PTR\n // AST_Node_Ptr ast = dynamic_cast(node);\n if (node->dbg) std::cerr << \"DELETE NODE \" << node << \"\\n\";\n #endif\n if (!node->detached) {\n delete(node);\n }\n }\n }\n }\n\n void SharedPtr::incRefCount() {\n if (node) {\n ++ node->refcounter;\n node->detached = false;\n #ifdef DEBUG_SHARED_PTR\n if (node->dbg) {\n std::cerr << \"+ \" << node << \" X \" << node->refcounter << \" (\" << this << \") \" << \"\\n\";\n }\n #endif\n }\n }\n\n SharedPtr::~SharedPtr() {\n decRefCount();\n }\n\n\n // the create constructor\n SharedPtr::SharedPtr(SharedObj* ptr)\n : node(ptr) {\n incRefCount();\n }\n // copy assignment operator\n SharedPtr& SharedPtr::operator=(const SharedPtr& rhs) {\n void* cur_ptr = (void*) node;\n void* rhs_ptr = (void*) rhs.node;\n if (cur_ptr == rhs_ptr) {\n return *this;\n }\n decRefCount();\n node = rhs.node;\n incRefCount();\n return *this;\n }\n\n // the copy constructor\n SharedPtr::SharedPtr(const SharedPtr& obj)\n : node(obj.node) {\n incRefCount();\n }\n\n}" }, { "path": "libsass-build/memory/SharedPtr.hpp", "content": "#ifndef SASS_MEMORY_SHARED_PTR_H\n#define SASS_MEMORY_SHARED_PTR_H\n\n#include \"sass/base.h\"\n\n#include \n\nnamespace Sass {\n\n class SharedPtr;\n\n ///////////////////////////////////////////////////////////////////////////////\n // Use macros for the allocation task, since overloading operator `new`\n // has been proven to be flaky under certain compilers (see comment below).\n ///////////////////////////////////////////////////////////////////////////////\n\n #ifdef DEBUG_SHARED_PTR\n\n #define SASS_MEMORY_NEW(Class, ...) \\\n ((Class*)(new Class(__VA_ARGS__))->trace(__FILE__, __LINE__)) \\\n\n #define SASS_MEMORY_COPY(obj) \\\n ((obj)->copy(__FILE__, __LINE__)) \\\n\n #define SASS_MEMORY_CLONE(obj) \\\n ((obj)->clone(__FILE__, __LINE__)) \\\n\n #else\n\n #define SASS_MEMORY_NEW(Class, ...) \\\n new Class(__VA_ARGS__) \\\n\n #define SASS_MEMORY_COPY(obj) \\\n ((obj)->copy()) \\\n\n #define SASS_MEMORY_CLONE(obj) \\\n ((obj)->clone()) \\\n\n #endif\n\n class SharedObj {\n protected:\n friend class SharedPtr;\n friend class Memory_Manager;\n #ifdef DEBUG_SHARED_PTR\n static std::vector all;\n std::string file;\n size_t line;\n #endif\n static bool taint;\n long refcounter;\n // long refcount;\n bool detached;\n #ifdef DEBUG_SHARED_PTR\n bool dbg;\n #endif\n public:\n #ifdef DEBUG_SHARED_PTR\n static void dumpMemLeaks();\n SharedObj* trace(std::string file, size_t line) {\n this->file = file;\n this->line = line;\n return this;\n }\n #endif\n SharedObj();\n #ifdef DEBUG_SHARED_PTR\n std::string getDbgFile() {\n return file;\n }\n size_t getDbgLine() {\n return line;\n }\n void setDbg(bool dbg) {\n this->dbg = dbg;\n }\n #endif\n static void setTaint(bool val) {\n taint = val;\n }\n virtual ~SharedObj();\n long getRefCount() {\n return refcounter;\n }\n };\n\n\n class SharedPtr {\n protected:\n SharedObj* node;\n protected:\n void decRefCount();\n void incRefCount();\n public:\n // the empty constructor\n SharedPtr()\n : node(NULL) {};\n // the create constructor\n SharedPtr(SharedObj* ptr);\n // the copy constructor\n SharedPtr(const SharedPtr& obj);\n // the move constructor\n SharedPtr(SharedPtr&& obj);\n // copy assignment operator\n SharedPtr& operator=(const SharedPtr& obj);\n // move assignment operator\n SharedPtr& operator=(SharedPtr&& obj);\n // pure virtual destructor\n virtual ~SharedPtr() = 0;\n public:\n SharedObj* obj () const {\n return node;\n };\n SharedObj* operator-> () const {\n return node;\n };\n bool isNull () {\n return node == NULL;\n };\n bool isNull () const {\n return node == NULL;\n };\n SharedObj* detach() const {\n if (node) {\n node->detached = true;\n }\n return node;\n };\n operator bool() const {\n return node != NULL;\n };\n\n };\n\n template < class T >\n class SharedImpl : private SharedPtr {\n public:\n SharedImpl()\n : SharedPtr(NULL) {};\n SharedImpl(T* node)\n : SharedPtr(node) {};\n template < class U >\n SharedImpl(SharedImpl obj)\n : SharedPtr(static_cast(obj.ptr())) {}\n SharedImpl(T&& node)\n : SharedPtr(node) {};\n SharedImpl(const T& node)\n : SharedPtr(node) {};\n // the copy constructor\n SharedImpl(const SharedImpl& impl)\n : SharedPtr(impl.node) {};\n // the move constructor\n SharedImpl(SharedImpl&& impl)\n : SharedPtr(impl.node) {};\n // copy assignment operator\n SharedImpl& operator=(const SharedImpl& rhs) {\n if (node) decRefCount();\n node = rhs.node;\n incRefCount();\n return *this;\n }\n // move assignment operator\n SharedImpl& operator=(SharedImpl&& rhs) {\n // don't move our self\n if (this != &rhs) {\n if (node) decRefCount();\n node = std::move(rhs.node);\n rhs.node = NULL;\n }\n return *this;\n }\n ~SharedImpl() {};\n public:\n operator T*() const {\n return static_cast(this->obj());\n }\n operator T&() const {\n return *static_cast(this->obj());\n }\n T& operator* () const {\n return *static_cast(this->obj());\n };\n T* operator-> () const {\n return static_cast(this->obj());\n };\n T* ptr () const {\n return static_cast(this->obj());\n };\n T* detach() const {\n if (this->obj() == NULL) return NULL;\n return static_cast(SharedPtr::detach());\n }\n bool isNull() const {\n return this->obj() == NULL;\n }\n bool operator<(const T& rhs) const {\n return *this->ptr() < rhs;\n };\n operator bool() const {\n return this->obj() != NULL;\n };\n };\n\n}\n\n#endif" }, { "path": "libsass-build/node.cpp", "content": "#include \"sass.hpp\"\n#include \n\n#include \"node.hpp\"\n#include \"context.hpp\"\n#include \"parser.hpp\"\n\nnamespace Sass {\n\n\n Node Node::createCombinator(const Complex_Selector::Combinator& combinator) {\n NodeDequePtr null;\n return Node(COMBINATOR, combinator, NULL /*pSelector*/, null /*pCollection*/);\n }\n\n\n Node Node::createSelector(const Complex_Selector& pSelector) {\n NodeDequePtr null;\n\n Complex_Selector_Ptr pStripped = SASS_MEMORY_COPY(&pSelector);\n pStripped->tail(NULL);\n pStripped->combinator(Complex_Selector::ANCESTOR_OF);\n\n Node n(SELECTOR, Complex_Selector::ANCESTOR_OF, pStripped, null /*pCollection*/);\n n.got_line_feed = pSelector.has_line_feed();\n return n;\n }\n\n\n Node Node::createCollection() {\n NodeDequePtr pEmptyCollection = std::make_shared();\n return Node(COLLECTION, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, pEmptyCollection);\n }\n\n\n Node Node::createCollection(const NodeDeque& values) {\n NodeDequePtr pShallowCopiedCollection = std::make_shared(values);\n return Node(COLLECTION, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, pShallowCopiedCollection);\n }\n\n\n Node Node::createNil() {\n NodeDequePtr null;\n return Node(NIL, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, null /*pCollection*/);\n }\n\n\n Node::Node(const TYPE& type, Complex_Selector::Combinator combinator, Complex_Selector_Ptr pSelector, NodeDequePtr& pCollection)\n : got_line_feed(false), mType(type), mCombinator(combinator), mpSelector(pSelector), mpCollection(pCollection)\n { if (pSelector) got_line_feed = pSelector->has_line_feed(); }\n\n\n Node Node::klone() const {\n NodeDequePtr pNewCollection = std::make_shared();\n if (mpCollection) {\n for (NodeDeque::iterator iter = mpCollection->begin(), iterEnd = mpCollection->end(); iter != iterEnd; iter++) {\n Node& toClone = *iter;\n pNewCollection->push_back(toClone.klone());\n }\n }\n\n Node n(mType, mCombinator, mpSelector ? SASS_MEMORY_COPY(mpSelector) : NULL, pNewCollection);\n n.got_line_feed = got_line_feed;\n return n;\n }\n\n\n bool Node::contains(const Node& potentialChild) const {\n bool found = false;\n\n for (NodeDeque::iterator iter = mpCollection->begin(), iterEnd = mpCollection->end(); iter != iterEnd; iter++) {\n Node& toTest = *iter;\n\n if (toTest == potentialChild) {\n found = true;\n break;\n }\n }\n\n return found;\n }\n\n\n bool Node::operator==(const Node& rhs) const {\n if (this->type() != rhs.type()) {\n return false;\n }\n\n if (this->isCombinator()) {\n\n return this->combinator() == rhs.combinator();\n\n } else if (this->isNil()) {\n\n return true; // no state to check\n\n } else if (this->isSelector()){\n\n return *this->selector() == *rhs.selector();\n\n } else if (this->isCollection()) {\n\n if (this->collection()->size() != rhs.collection()->size()) {\n return false;\n }\n\n for (NodeDeque::iterator lhsIter = this->collection()->begin(), lhsIterEnd = this->collection()->end(),\n rhsIter = rhs.collection()->begin(); lhsIter != lhsIterEnd; lhsIter++, rhsIter++) {\n\n if (*lhsIter != *rhsIter) {\n return false;\n }\n\n }\n\n return true;\n\n }\n\n // We shouldn't get here.\n throw \"Comparing unknown node types. A new type was probably added and this method wasn't implemented for it.\";\n }\n\n\n void Node::plus(Node& rhs) {\n if (!this->isCollection() || !rhs.isCollection()) {\n throw \"Both the current node and rhs must be collections.\";\n }\n this->collection()->insert(this->collection()->end(), rhs.collection()->begin(), rhs.collection()->end());\n }\n\n#ifdef DEBUG\n std::ostream& operator<<(std::ostream& os, const Node& node) {\n\n if (node.isCombinator()) {\n\n switch (node.combinator()) {\n case Complex_Selector::ANCESTOR_OF: os << \"\\\" \\\"\"; break;\n case Complex_Selector::PARENT_OF: os << \"\\\">\\\"\"; break;\n case Complex_Selector::PRECEDES: os << \"\\\"~\\\"\"; break;\n case Complex_Selector::ADJACENT_TO: os << \"\\\"+\\\"\"; break;\n case Complex_Selector::REFERENCE: os << \"\\\"/\\\"\"; break;\n }\n\n } else if (node.isNil()) {\n\n os << \"nil\";\n\n } else if (node.isSelector()){\n\n os << node.selector()->head()->to_string();\n\n } else if (node.isCollection()) {\n\n os << \"[\";\n\n for (NodeDeque::iterator iter = node.collection()->begin(), iterBegin = node.collection()->begin(), iterEnd = node.collection()->end(); iter != iterEnd; iter++) {\n if (iter != iterBegin) {\n os << \", \";\n }\n\n os << (*iter);\n }\n\n os << \"]\";\n\n }\n\n return os;\n\n }\n#endif\n\n\n Node complexSelectorToNode(Complex_Selector_Ptr pToConvert) {\n if (pToConvert == NULL) {\n return Node::createNil();\n }\n Node node = Node::createCollection();\n node.got_line_feed = pToConvert->has_line_feed();\n bool has_lf = pToConvert->has_line_feed();\n\n // unwrap the selector from parent ref\n if (pToConvert->head() && pToConvert->head()->has_parent_ref()) {\n Complex_Selector_Obj tail = pToConvert->tail();\n if (tail) tail->has_line_feed(pToConvert->has_line_feed());\n pToConvert = tail;\n }\n\n while (pToConvert) {\n\n bool empty_parent_ref = pToConvert->head() && pToConvert->head()->is_empty_reference();\n\n // the first Complex_Selector may contain a dummy head pointer, skip it.\n if (pToConvert->head() && !empty_parent_ref) {\n node.collection()->push_back(Node::createSelector(*pToConvert));\n if (has_lf) node.collection()->back().got_line_feed = has_lf;\n if (pToConvert->head() || empty_parent_ref) {\n if (pToConvert->tail()) {\n pToConvert->tail()->has_line_feed(pToConvert->has_line_feed());\n }\n }\n has_lf = false;\n }\n\n if (pToConvert->combinator() != Complex_Selector::ANCESTOR_OF) {\n node.collection()->push_back(Node::createCombinator(pToConvert->combinator()));\n if (has_lf) node.collection()->back().got_line_feed = has_lf;\n has_lf = false;\n }\n\n if (pToConvert && empty_parent_ref && pToConvert->tail()) {\n // pToConvert->tail()->has_line_feed(pToConvert->has_line_feed());\n }\n\n pToConvert = pToConvert->tail();\n }\n\n return node;\n }\n\n\n Complex_Selector_Ptr nodeToComplexSelector(const Node& toConvert) {\n if (toConvert.isNil()) {\n return NULL;\n }\n\n\n if (!toConvert.isCollection()) {\n throw \"The node to convert to a Complex_Selector_Ptr must be a collection type or nil.\";\n }\n\n\n NodeDeque& childNodes = *toConvert.collection();\n\n std::string noPath(\"\");\n Complex_Selector_Obj pFirst = SASS_MEMORY_NEW(Complex_Selector, ParserState(\"[NODE]\"), Complex_Selector::ANCESTOR_OF, NULL, NULL);\n\n Complex_Selector_Obj pCurrent = pFirst;\n\n if (toConvert.isSelector()) pFirst->has_line_feed(toConvert.got_line_feed);\n if (toConvert.isCombinator()) pFirst->has_line_feed(toConvert.got_line_feed);\n\n for (NodeDeque::iterator childIter = childNodes.begin(), childIterEnd = childNodes.end(); childIter != childIterEnd; childIter++) {\n\n Node& child = *childIter;\n\n if (child.isSelector()) {\n // JMA - need to clone the selector, because they can end up getting shared across Node\n // collections, and can result in an infinite loop during the call to parentSuperselector()\n pCurrent->tail(SASS_MEMORY_COPY(child.selector()));\n // if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);\n pCurrent = pCurrent->tail();\n } else if (child.isCombinator()) {\n pCurrent->combinator(child.combinator());\n if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);\n\n // if the next node is also a combinator, create another Complex_Selector to hold it so it doesn't replace the current combinator\n if (childIter+1 != childIterEnd) {\n Node& nextNode = *(childIter+1);\n if (nextNode.isCombinator()) {\n pCurrent->tail(SASS_MEMORY_NEW(Complex_Selector, ParserState(\"[NODE]\"), Complex_Selector::ANCESTOR_OF, NULL, NULL));\n if (nextNode.got_line_feed) pCurrent->tail()->has_line_feed(nextNode.got_line_feed);\n pCurrent = pCurrent->tail();\n }\n }\n } else {\n throw \"The node to convert's children must be only combinators or selectors.\";\n }\n }\n\n // Put the dummy Compound_Selector in the first position, for consistency with the rest of libsass\n Compound_Selector_Ptr fakeHead = SASS_MEMORY_NEW(Compound_Selector, ParserState(\"[NODE]\"), 1);\n Parent_Selector_Ptr selectorRef = SASS_MEMORY_NEW(Parent_Selector, ParserState(\"[NODE]\"));\n fakeHead->elements().push_back(selectorRef);\n if (toConvert.got_line_feed) pFirst->has_line_feed(toConvert.got_line_feed);\n // pFirst->has_line_feed(pFirst->has_line_feed() || pFirst->tail()->has_line_feed() || toConvert.got_line_feed);\n pFirst->head(fakeHead);\n return SASS_MEMORY_COPY(pFirst);\n }\n\n // A very naive trim function, which removes duplicates in a node\n // This is only used in Complex_Selector::unify_with for now, may need modifications to fit other needs\n Node Node::naiveTrim(Node& seqses) {\n\n std::vector res;\n std::vector known;\n\n NodeDeque::reverse_iterator seqsesIter = seqses.collection()->rbegin(),\n seqsesIterEnd = seqses.collection()->rend();\n\n for (; seqsesIter != seqsesIterEnd; ++seqsesIter)\n {\n Node& seqs1 = *seqsesIter;\n if( seqs1.isSelector() ) {\n Complex_Selector_Obj sel = seqs1.selector();\n std::vector::iterator it;\n bool found = false;\n for (it = known.begin(); it != known.end(); ++it) {\n if (**it == *sel) { found = true; break; }\n }\n if( !found ) {\n known.push_back(seqs1.selector());\n res.push_back(&seqs1);\n }\n } else {\n res.push_back(&seqs1);\n }\n }\n\n Node result = Node::createCollection();\n\n for (size_t i = res.size() - 1; i != std::string::npos; --i) {\n result.collection()->push_back(*res[i]);\n }\n\n return result;\n }\n}\n" }, { "path": "libsass-build/node.hpp", "content": "#ifndef SASS_NODE_H\n#define SASS_NODE_H\n\n#include \n#include \n\n#include \"ast.hpp\"\n\n\nnamespace Sass {\n\n\n\n\n class Context;\n\n /*\n There are a lot of stumbling blocks when trying to port the ruby extend code to C++. The biggest is the choice of\n data type. The ruby code will pretty seamlessly switch types between an Array (libsass'\n equivalent is the Complex_Selector) to a Sequence, which contains more metadata about the sequence than just the\n selector info. They also have the ability to have arbitrary nestings of arrays like [1, [2]], which is hard to\n implement using Array equivalents in C++ (like the deque or vector). They also have the ability to include nil\n in the arrays, like [1, nil, 3], which has potential semantic differences than an empty array [1, [], 3]. To be\n able to represent all of these as unique cases, we need to create a tree of variant objects. The tree nature allows\n the inconsistent nesting levels. The variant nature (while making some of the C++ code uglier) allows the code to\n more closely match the ruby code, which is a huge benefit when attempting to implement an complex algorithm like\n the Extend operator.\n\n Note that the current libsass data model also pairs the combinator with the Complex_Selector that follows it, but\n ruby sass has no such restriction, so we attempt to create a data structure that can handle them split apart.\n */\n\n class Node;\n typedef std::deque NodeDeque;\n typedef std::shared_ptr NodeDequePtr;\n\n class Node {\n public:\n enum TYPE {\n SELECTOR,\n COMBINATOR,\n COLLECTION,\n NIL\n };\n\n TYPE type() const { return mType; }\n bool isCombinator() const { return mType == COMBINATOR; }\n bool isSelector() const { return mType == SELECTOR; }\n bool isCollection() const { return mType == COLLECTION; }\n bool isNil() const { return mType == NIL; }\n bool got_line_feed;\n\n Complex_Selector::Combinator combinator() const { return mCombinator; }\n\n Complex_Selector_Obj selector() { return mpSelector; }\n Complex_Selector_Obj selector() const { return mpSelector; }\n\n NodeDequePtr collection() { return mpCollection; }\n const NodeDequePtr collection() const { return mpCollection; }\n\n static Node createCombinator(const Complex_Selector::Combinator& combinator);\n\n // This method will klone the selector, stripping off the tail and combinator\n static Node createSelector(const Complex_Selector& pSelector);\n\n static Node createCollection();\n static Node createCollection(const NodeDeque& values);\n\n static Node createNil();\n static Node naiveTrim(Node& seqses);\n\n Node klone() const;\n\n bool operator==(const Node& rhs) const;\n inline bool operator!=(const Node& rhs) const { return !(*this == rhs); }\n\n\n /*\n COLLECTION FUNCTIONS\n\n Most types don't need any helper methods (nil and combinator due to their simplicity and\n selector due to the fact that we leverage the non-node selector code on the Complex_Selector\n whereever possible). The following methods are intended to be called on Node objects whose\n type is COLLECTION only.\n */\n\n // rhs and this must be node collections. Shallow copy the nodes from rhs to the end of this.\n // This function DOES NOT remove the nodes from rhs.\n void plus(Node& rhs);\n\n // potentialChild must be a node collection of selectors/combinators. this must be a collection\n // of collections of nodes/combinators. This method checks if potentialChild is a child of this\n // Node.\n bool contains(const Node& potentialChild) const;\n\n private:\n // Private constructor; Use the static methods (like createCombinator and createSelector)\n // to instantiate this object. This is more expressive, and it allows us to break apart each\n // case into separate functions.\n Node(const TYPE& type, Complex_Selector::Combinator combinator, Complex_Selector_Ptr pSelector, NodeDequePtr& pCollection);\n\n TYPE mType;\n\n // TODO: can we union these to save on memory?\n Complex_Selector::Combinator mCombinator;\n Complex_Selector_Obj mpSelector;\n NodeDequePtr mpCollection;\n };\n\n#ifdef DEBUG\n std::ostream& operator<<(std::ostream& os, const Node& node);\n#endif\n Node complexSelectorToNode(Complex_Selector_Ptr pToConvert);\n Complex_Selector_Ptr nodeToComplexSelector(const Node& toConvert);\n\n}\n\n#endif\n" }, { "path": "libsass-build/operation.hpp", "content": "#ifndef SASS_OPERATION_H\n#define SASS_OPERATION_H\n\n#include \"ast_fwd_decl.hpp\"\n\nnamespace Sass {\n\n template\n class Operation {\n public:\n virtual T operator()(AST_Node_Ptr x) = 0;\n virtual ~Operation() { }\n // statements\n virtual T operator()(Block_Ptr x) = 0;\n virtual T operator()(Ruleset_Ptr x) = 0;\n virtual T operator()(Bubble_Ptr x) = 0;\n virtual T operator()(Trace_Ptr x) = 0;\n virtual T operator()(Supports_Block_Ptr x) = 0;\n virtual T operator()(Media_Block_Ptr x) = 0;\n virtual T operator()(At_Root_Block_Ptr x) = 0;\n virtual T operator()(Directive_Ptr x) = 0;\n virtual T operator()(Keyframe_Rule_Ptr x) = 0;\n virtual T operator()(Declaration_Ptr x) = 0;\n virtual T operator()(Assignment_Ptr x) = 0;\n virtual T operator()(Import_Ptr x) = 0;\n virtual T operator()(Import_Stub_Ptr x) = 0;\n virtual T operator()(Warning_Ptr x) = 0;\n virtual T operator()(Error_Ptr x) = 0;\n virtual T operator()(Debug_Ptr x) = 0;\n virtual T operator()(Comment_Ptr x) = 0;\n virtual T operator()(If_Ptr x) = 0;\n virtual T operator()(For_Ptr x) = 0;\n virtual T operator()(Each_Ptr x) = 0;\n virtual T operator()(While_Ptr x) = 0;\n virtual T operator()(Return_Ptr x) = 0;\n virtual T operator()(Content_Ptr x) = 0;\n virtual T operator()(Extension_Ptr x) = 0;\n virtual T operator()(Definition_Ptr x) = 0;\n virtual T operator()(Mixin_Call_Ptr x) = 0;\n // expressions\n virtual T operator()(List_Ptr x) = 0;\n virtual T operator()(Map_Ptr x) = 0;\n virtual T operator()(Function_Ptr x) = 0;\n virtual T operator()(Binary_Expression_Ptr x) = 0;\n virtual T operator()(Unary_Expression_Ptr x) = 0;\n virtual T operator()(Function_Call_Ptr x) = 0;\n virtual T operator()(Function_Call_Schema_Ptr x) = 0;\n virtual T operator()(Custom_Warning_Ptr x) = 0;\n virtual T operator()(Custom_Error_Ptr x) = 0;\n virtual T operator()(Variable_Ptr x) = 0;\n virtual T operator()(Number_Ptr x) = 0;\n virtual T operator()(Color_Ptr x) = 0;\n virtual T operator()(Boolean_Ptr x) = 0;\n virtual T operator()(String_Schema_Ptr x) = 0;\n virtual T operator()(String_Quoted_Ptr x) = 0;\n virtual T operator()(String_Constant_Ptr x) = 0;\n virtual T operator()(Supports_Condition_Ptr x) = 0;\n virtual T operator()(Supports_Operator_Ptr x) = 0;\n virtual T operator()(Supports_Negation_Ptr x) = 0;\n virtual T operator()(Supports_Declaration_Ptr x) = 0;\n virtual T operator()(Supports_Interpolation_Ptr x) = 0;\n virtual T operator()(Media_Query_Ptr x) = 0;\n virtual T operator()(Media_Query_Expression_Ptr x) = 0;\n virtual T operator()(At_Root_Query_Ptr x) = 0;\n virtual T operator()(Null_Ptr x) = 0;\n virtual T operator()(Parent_Selector_Ptr x) = 0;\n // parameters and arguments\n virtual T operator()(Parameter_Ptr x) = 0;\n virtual T operator()(Parameters_Ptr x) = 0;\n virtual T operator()(Argument_Ptr x) = 0;\n virtual T operator()(Arguments_Ptr x) = 0;\n // selectors\n virtual T operator()(Selector_Schema_Ptr x) = 0;\n virtual T operator()(Placeholder_Selector_Ptr x) = 0;\n virtual T operator()(Element_Selector_Ptr x) = 0;\n virtual T operator()(Class_Selector_Ptr x) = 0;\n virtual T operator()(Id_Selector_Ptr x) = 0;\n virtual T operator()(Attribute_Selector_Ptr x) = 0;\n virtual T operator()(Pseudo_Selector_Ptr x) = 0;\n virtual T operator()(Wrapped_Selector_Ptr x) = 0;\n virtual T operator()(Compound_Selector_Ptr x)= 0;\n virtual T operator()(Complex_Selector_Ptr x) = 0;\n virtual T operator()(Selector_List_Ptr x) = 0;\n\n template \n T fallback(U x) { return T(); }\n };\n\n template \n class Operation_CRTP : public Operation {\n public:\n D& impl() { return static_cast(*this); }\n public:\n T operator()(AST_Node_Ptr x) { return static_cast(this)->fallback(x); }\n // statements\n T operator()(Block_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Ruleset_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Bubble_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Trace_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Supports_Block_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Media_Block_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(At_Root_Block_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Directive_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Keyframe_Rule_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Declaration_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Assignment_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Import_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Import_Stub_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Warning_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Error_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Debug_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Comment_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(If_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(For_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Each_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(While_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Return_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Content_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Extension_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Definition_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Mixin_Call_Ptr x) { return static_cast(this)->fallback(x); }\n // expressions\n T operator()(List_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Map_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Function_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Binary_Expression_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Unary_Expression_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Function_Call_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Function_Call_Schema_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Custom_Warning_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Custom_Error_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Variable_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Number_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Color_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Boolean_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(String_Schema_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(String_Constant_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(String_Quoted_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Supports_Condition_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Supports_Operator_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Supports_Negation_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Supports_Declaration_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Supports_Interpolation_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Media_Query_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Media_Query_Expression_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(At_Root_Query_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Null_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Parent_Selector_Ptr x) { return static_cast(this)->fallback(x); }\n // parameters and arguments\n T operator()(Parameter_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Parameters_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Argument_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Arguments_Ptr x) { return static_cast(this)->fallback(x); }\n // selectors\n T operator()(Selector_Schema_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Placeholder_Selector_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Element_Selector_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Class_Selector_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Id_Selector_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Attribute_Selector_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Pseudo_Selector_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Wrapped_Selector_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Compound_Selector_Ptr x){ return static_cast(this)->fallback(x); }\n T operator()(Complex_Selector_Ptr x) { return static_cast(this)->fallback(x); }\n T operator()(Selector_List_Ptr x) { return static_cast(this)->fallback(x); }\n\n template \n T fallback(U x) { return T(); }\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/operators.cpp", "content": "#include \"sass.hpp\"\n#include \"operators.hpp\"\n\nnamespace Sass {\n\n namespace Operators {\n\n inline double add(double x, double y) { return x + y; }\n inline double sub(double x, double y) { return x - y; }\n inline double mul(double x, double y) { return x * y; }\n inline double div(double x, double y) { return x / y; } // x/0 checked by caller\n\n inline double mod(double x, double y) { // x/0 checked by caller\n if ((x > 0 && y < 0) || (x < 0 && y > 0)) {\n double ret = std::fmod(x, y);\n return ret ? ret + y : ret;\n } else {\n return std::fmod(x, y);\n }\n }\n\n typedef double (*bop)(double, double);\n bop ops[Sass_OP::NUM_OPS] = {\n 0, 0, // and, or\n 0, 0, 0, 0, 0, 0, // eq, neq, gt, gte, lt, lte\n add, sub, mul, div, mod\n };\n\n /* static function, has no pstate or traces */\n bool eq(Expression_Obj lhs, Expression_Obj rhs)\n {\n // operation is undefined if one is not a number\n if (!lhs || !rhs) throw Exception::UndefinedOperation(lhs, rhs, Sass_OP::EQ);\n // use compare operator from ast node\n return *lhs == *rhs;\n }\n\n /* static function, throws OperationError, has no pstate or traces */\n bool cmp(Expression_Obj lhs, Expression_Obj rhs, const Sass_OP op)\n {\n // can only compare numbers!?\n Number_Obj l = Cast(lhs);\n Number_Obj r = Cast(rhs);\n // operation is undefined if one is not a number\n if (!l || !r) throw Exception::UndefinedOperation(lhs, rhs, op);\n // use compare operator from ast node\n return *l < *r;\n }\n\n /* static functions, throws OperationError, has no pstate or traces */\n bool lt(Expression_Obj lhs, Expression_Obj rhs) { return cmp(lhs, rhs, Sass_OP::LT); }\n bool neq(Expression_Obj lhs, Expression_Obj rhs) { return eq(lhs, rhs) == false; }\n bool gt(Expression_Obj lhs, Expression_Obj rhs) { return !cmp(lhs, rhs, Sass_OP::GT) && neq(lhs, rhs); }\n bool lte(Expression_Obj lhs, Expression_Obj rhs) { return cmp(lhs, rhs, Sass_OP::LTE) || eq(lhs, rhs); }\n bool gte(Expression_Obj lhs, Expression_Obj rhs) { return !cmp(lhs, rhs, Sass_OP::GTE) || eq(lhs, rhs); }\n\n /* colour math deprecation warning */\n void op_color_deprecation(enum Sass_OP op, std::string lsh, std::string rhs, const ParserState& pstate)\n {\n std::string op_str(\n op == Sass_OP::ADD ? \"plus\" :\n op == Sass_OP::DIV ? \"div\" :\n op == Sass_OP::SUB ? \"minus\" :\n op == Sass_OP::MUL ? \"times\" : \"\"\n );\n\n std::string msg(\"The operation `\" + lsh + \" \" + op_str + \" \" + rhs + \"` is deprecated and will be an error in future versions.\");\n std::string tail(\"Consider using Sass's color functions instead.\\nhttp://sass-lang.com/documentation/Sass/Script/Functions.html#other_color_functions\");\n\n deprecated(msg, tail, false, pstate);\n }\n\n /* static function, throws OperationError, has no traces but optional pstate for returned value */\n Value_Ptr op_strings(Sass::Operand operand, Value& lhs, Value& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)\n {\n enum Sass_OP op = operand.operand;\n\n String_Quoted_Ptr lqstr = Cast(&lhs);\n String_Quoted_Ptr rqstr = Cast(&rhs);\n\n std::string lstr(lqstr ? lqstr->value() : lhs.to_string(opt));\n std::string rstr(rqstr ? rqstr->value() : rhs.to_string(opt));\n\n if (Cast(&lhs)) throw Exception::InvalidNullOperation(&lhs, &rhs, op);\n if (Cast(&rhs)) throw Exception::InvalidNullOperation(&lhs, &rhs, op);\n\n std::string sep;\n switch (op) {\n case Sass_OP::ADD: sep = \"\"; break;\n case Sass_OP::SUB: sep = \"-\"; break;\n case Sass_OP::DIV: sep = \"/\"; break;\n case Sass_OP::EQ: sep = \"==\"; break;\n case Sass_OP::NEQ: sep = \"!=\"; break;\n case Sass_OP::LT: sep = \"<\"; break;\n case Sass_OP::GT: sep = \">\"; break;\n case Sass_OP::LTE: sep = \"<=\"; break;\n case Sass_OP::GTE: sep = \">=\"; break;\n default:\n throw Exception::UndefinedOperation(&lhs, &rhs, op);\n break;\n }\n\n if (op == Sass_OP::ADD) {\n // create string that might be quoted on output (but do not unquote what we pass)\n return SASS_MEMORY_NEW(String_Quoted, pstate, lstr + rstr, 0, false, true);\n }\n\n // add whitespace around operator\n // but only if result is not delayed\n if (sep != \"\" && delayed == false) {\n if (operand.ws_before) sep = \" \" + sep;\n if (operand.ws_after) sep = sep + \" \";\n }\n\n if (op == Sass_OP::SUB || op == Sass_OP::DIV) {\n if (lqstr && lqstr->quote_mark()) lstr = quote(lstr);\n if (rqstr && rqstr->quote_mark()) rstr = quote(rstr);\n }\n\n return SASS_MEMORY_NEW(String_Constant, pstate, lstr + sep + rstr);\n }\n\n /* static function, throws OperationError, has no traces but optional pstate for returned value */\n Value_Ptr op_colors(enum Sass_OP op, const Color& lhs, const Color& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)\n {\n\n if (lhs.a() != rhs.a()) {\n throw Exception::AlphaChannelsNotEqual(&lhs, &rhs, op);\n }\n if ((op == Sass_OP::DIV || op == Sass_OP::MOD) && (!rhs.r() || !rhs.g() || !rhs.b())) {\n throw Exception::ZeroDivisionError(lhs, rhs);\n }\n\n op_color_deprecation(op, lhs.to_string(), rhs.to_string(), pstate);\n\n return SASS_MEMORY_NEW(Color,\n pstate,\n ops[op](lhs.r(), rhs.r()),\n ops[op](lhs.g(), rhs.g()),\n ops[op](lhs.b(), rhs.b()),\n lhs.a());\n }\n\n /* static function, throws OperationError, has no traces but optional pstate for returned value */\n Value_Ptr op_numbers(enum Sass_OP op, const Number& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)\n {\n double lval = lhs.value();\n double rval = rhs.value();\n\n if (op == Sass_OP::MOD && rval == 0) {\n return SASS_MEMORY_NEW(String_Quoted, pstate, \"NaN\");\n }\n\n if (op == Sass_OP::DIV && rval == 0) {\n std::string result(lval ? \"Infinity\" : \"NaN\");\n return SASS_MEMORY_NEW(String_Quoted, pstate, result);\n }\n\n size_t l_n_units = lhs.numerators.size();\n size_t l_d_units = lhs.numerators.size();\n size_t r_n_units = rhs.denominators.size();\n size_t r_d_units = rhs.denominators.size();\n // optimize out the most common and simplest case\n if (l_n_units == r_n_units && l_d_units == r_d_units) {\n if (l_n_units + l_d_units <= 1 && r_n_units + r_d_units <= 1) {\n if (lhs.numerators == rhs.numerators) {\n if (lhs.denominators == rhs.denominators) {\n Number_Ptr v = SASS_MEMORY_COPY(&lhs);\n v->value(ops[op](lval, rval));\n return v;\n }\n }\n }\n }\n\n Number_Obj v = SASS_MEMORY_COPY(&lhs);\n\n if (lhs.is_unitless() && (op == Sass_OP::ADD || op == Sass_OP::SUB || op == Sass_OP::MOD)) {\n v->numerators = rhs.numerators;\n v->denominators = rhs.denominators;\n }\n\n if (op == Sass_OP::MUL) {\n v->value(ops[op](lval, rval));\n v->numerators.insert(v->numerators.end(),\n rhs.numerators.begin(), rhs.numerators.end()\n );\n v->denominators.insert(v->denominators.end(),\n rhs.denominators.begin(), rhs.denominators.end()\n );\n v->reduce();\n }\n else if (op == Sass_OP::DIV) {\n v->value(ops[op](lval, rval));\n v->numerators.insert(v->numerators.end(),\n rhs.denominators.begin(), rhs.denominators.end()\n );\n v->denominators.insert(v->denominators.end(),\n rhs.numerators.begin(), rhs.numerators.end()\n );\n v->reduce();\n }\n else {\n Number ln(lhs), rn(rhs);\n ln.reduce(); rn.reduce();\n double f(rn.convert_factor(ln));\n v->value(ops[op](lval, rn.value() * f));\n }\n\n v->pstate(pstate);\n return v.detach();\n }\n\n /* static function, throws OperationError, has no traces but optional pstate for returned value */\n Value_Ptr op_number_color(enum Sass_OP op, const Number& lhs, const Color& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)\n {\n double lval = lhs.value();\n\n switch (op) {\n case Sass_OP::ADD:\n case Sass_OP::MUL: {\n op_color_deprecation(op, lhs.to_string(), rhs.to_string(opt), pstate);\n return SASS_MEMORY_NEW(Color,\n pstate,\n ops[op](lval, rhs.r()),\n ops[op](lval, rhs.g()),\n ops[op](lval, rhs.b()),\n rhs.a());\n }\n case Sass_OP::SUB:\n case Sass_OP::DIV: {\n std::string color(rhs.to_string(opt));\n op_color_deprecation(op, lhs.to_string(), color, pstate);\n return SASS_MEMORY_NEW(String_Quoted,\n pstate,\n lhs.to_string(opt)\n + sass_op_separator(op)\n + color);\n }\n default: break;\n }\n throw Exception::UndefinedOperation(&lhs, &rhs, op);\n }\n\n /* static function, throws OperationError, has no traces but optional pstate for returned value */\n Value_Ptr op_color_number(enum Sass_OP op, const Color& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)\n {\n double rval = rhs.value();\n\n if ((op == Sass_OP::DIV || op == Sass_OP::DIV) && rval == 0) {\n // comparison of Fixnum with Float failed?\n throw Exception::ZeroDivisionError(lhs, rhs);\n }\n\n op_color_deprecation(op, lhs.to_string(), rhs.to_string(), pstate);\n\n return SASS_MEMORY_NEW(Color,\n pstate,\n ops[op](lhs.r(), rval),\n ops[op](lhs.g(), rval),\n ops[op](lhs.b(), rval),\n lhs.a());\n }\n\n }\n\n}\n" }, { "path": "libsass-build/operators.hpp", "content": "#ifndef SASS_OPERATORS_H\n#define SASS_OPERATORS_H\n\n#include \"values.hpp\"\n#include \"sass/values.h\"\n\nnamespace Sass {\n\n namespace Operators {\n\n // equality operator using AST Node operator==\n bool eq(Expression_Obj, Expression_Obj);\n bool neq(Expression_Obj, Expression_Obj);\n // specific operators based on cmp and eq\n bool lt(Expression_Obj, Expression_Obj);\n bool gt(Expression_Obj, Expression_Obj);\n bool lte(Expression_Obj, Expression_Obj);\n bool gte(Expression_Obj, Expression_Obj);\n // arithmetic for all the combinations that matter\n Value_Ptr op_strings(Sass::Operand, Value&, Value&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);\n Value_Ptr op_colors(enum Sass_OP, const Color&, const Color&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);\n Value_Ptr op_numbers(enum Sass_OP, const Number&, const Number&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);\n Value_Ptr op_number_color(enum Sass_OP, const Number&, const Color&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);\n Value_Ptr op_color_number(enum Sass_OP, const Color&, const Number&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);\n\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/output.cpp", "content": "#include \"sass.hpp\"\n#include \"ast.hpp\"\n#include \"output.hpp\"\n\nnamespace Sass {\n\n Output::Output(Sass_Output_Options& opt)\n : Inspect(Emitter(opt)),\n charset(\"\"),\n top_nodes(0)\n {}\n\n Output::~Output() { }\n\n void Output::fallback_impl(AST_Node_Ptr n)\n {\n return n->perform(this);\n }\n\n void Output::operator()(Number_Ptr n)\n {\n // check for a valid unit here\n // includes result for reporting\n if (!n->is_valid_css_unit()) {\n // should be handle in check_expression\n throw Exception::InvalidValue({}, *n);\n }\n // use values to_string facility\n std::string res = n->to_string(opt);\n // output the final token\n append_token(res, n);\n }\n\n void Output::operator()(Import_Ptr imp)\n {\n top_nodes.push_back(imp);\n }\n\n void Output::operator()(Map_Ptr m)\n {\n // should be handle in check_expression\n throw Exception::InvalidValue({}, *m);\n }\n\n OutputBuffer Output::get_buffer(void)\n {\n\n Emitter emitter(opt);\n Inspect inspect(emitter);\n\n size_t size_nodes = top_nodes.size();\n for (size_t i = 0; i < size_nodes; i++) {\n top_nodes[i]->perform(&inspect);\n inspect.append_mandatory_linefeed();\n }\n\n // flush scheduled outputs\n // maybe omit semicolon if possible\n inspect.finalize(wbuf.buffer.size() == 0);\n // prepend buffer on top\n prepend_output(inspect.output());\n // make sure we end with a linefeed\n if (!ends_with(wbuf.buffer, opt.linefeed)) {\n // if the output is not completely empty\n if (!wbuf.buffer.empty()) append_string(opt.linefeed);\n }\n\n // search for unicode char\n for(const char& chr : wbuf.buffer) {\n // skip all ascii chars\n // static cast to unsigned to handle `char` being signed / unsigned\n if (static_cast(chr) < 128) continue;\n // declare the charset\n if (output_style() != COMPRESSED)\n charset = \"@charset \\\"UTF-8\\\";\"\n + std::string(opt.linefeed);\n else charset = \"\\xEF\\xBB\\xBF\";\n // abort search\n break;\n }\n\n // add charset as first line, before comments and imports\n if (!charset.empty()) prepend_string(charset);\n\n return wbuf;\n\n }\n\n void Output::operator()(Comment_Ptr c)\n {\n std::string txt = c->text()->to_string(opt);\n // if (indentation && txt == \"/**/\") return;\n bool important = c->is_important();\n if (output_style() != COMPRESSED || important) {\n if (buffer().size() == 0) {\n top_nodes.push_back(c);\n } else {\n in_comment = true;\n append_indentation();\n c->text()->perform(this);\n in_comment = false;\n if (indentation == 0) {\n append_mandatory_linefeed();\n } else {\n append_optional_linefeed();\n }\n }\n }\n }\n\n void Output::operator()(Ruleset_Ptr r)\n {\n Selector_Obj s = r->selector();\n Block_Obj b = r->block();\n\n // Filter out rulesets that aren't printable (process its children though)\n if (!Util::isPrintable(r, output_style())) {\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n const Statement_Obj& stm = b->at(i);\n if (Cast(stm)) {\n if (!Cast(stm)) {\n stm->perform(this);\n }\n }\n }\n return;\n }\n\n if (output_style() == NESTED) indentation += r->tabs();\n if (opt.source_comments) {\n std::stringstream ss;\n append_indentation();\n std::string path(File::abs2rel(r->pstate().path));\n ss << \"/* line \" << r->pstate().line + 1 << \", \" << path << \" */\";\n append_string(ss.str());\n append_optional_linefeed();\n }\n scheduled_crutch = s;\n if (s) s->perform(this);\n append_scope_opener(b);\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj stm = b->at(i);\n bool bPrintExpression = true;\n // Check print conditions\n if (Declaration_Ptr dec = Cast(stm)) {\n if (String_Constant_Ptr valConst = Cast(dec->value())) {\n std::string val(valConst->value());\n if (String_Quoted_Ptr qstr = Cast(valConst)) {\n if (!qstr->quote_mark() && val.empty()) {\n bPrintExpression = false;\n }\n }\n }\n else if (List_Ptr list = Cast(dec->value())) {\n bool all_invisible = true;\n for (size_t list_i = 0, list_L = list->length(); list_i < list_L; ++list_i) {\n Expression_Ptr item = list->at(list_i);\n if (!item->is_invisible()) all_invisible = false;\n }\n if (all_invisible && !list->is_bracketed()) bPrintExpression = false;\n }\n }\n // Print if OK\n if (bPrintExpression) {\n stm->perform(this);\n }\n }\n if (output_style() == NESTED) indentation -= r->tabs();\n append_scope_closer(b);\n\n }\n void Output::operator()(Keyframe_Rule_Ptr r)\n {\n Block_Obj b = r->block();\n Selector_Obj v = r->name();\n\n if (!v.isNull()) {\n v->perform(this);\n }\n\n if (!b) {\n append_colon_separator();\n return;\n }\n\n append_scope_opener();\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj stm = b->at(i);\n stm->perform(this);\n if (i < L - 1) append_special_linefeed();\n }\n append_scope_closer();\n }\n\n void Output::operator()(Supports_Block_Ptr f)\n {\n if (f->is_invisible()) return;\n\n Supports_Condition_Obj c = f->condition();\n Block_Obj b = f->block();\n\n // Filter out feature blocks that aren't printable (process its children though)\n if (!Util::isPrintable(f, output_style())) {\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj stm = b->at(i);\n if (Cast(stm)) {\n stm->perform(this);\n }\n }\n return;\n }\n\n if (output_style() == NESTED) indentation += f->tabs();\n append_indentation();\n append_token(\"@supports\", f);\n append_mandatory_space();\n c->perform(this);\n append_scope_opener();\n\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj stm = b->at(i);\n stm->perform(this);\n if (i < L - 1) append_special_linefeed();\n }\n\n if (output_style() == NESTED) indentation -= f->tabs();\n\n append_scope_closer();\n\n }\n\n void Output::operator()(Media_Block_Ptr m)\n {\n if (m->is_invisible()) return;\n\n Block_Obj b = m->block();\n\n // Filter out media blocks that aren't printable (process its children though)\n if (!Util::isPrintable(m, output_style())) {\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj stm = b->at(i);\n if (Cast(stm)) {\n stm->perform(this);\n }\n }\n return;\n }\n if (output_style() == NESTED) indentation += m->tabs();\n append_indentation();\n append_token(\"@media\", m);\n append_mandatory_space();\n in_media_block = true;\n m->media_queries()->perform(this);\n in_media_block = false;\n append_scope_opener();\n\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n if (b->at(i)) {\n Statement_Obj stm = b->at(i);\n stm->perform(this);\n }\n if (i < L - 1) append_special_linefeed();\n }\n\n if (output_style() == NESTED) indentation -= m->tabs();\n append_scope_closer();\n }\n\n void Output::operator()(Directive_Ptr a)\n {\n std::string kwd = a->keyword();\n Selector_Obj s = a->selector();\n Expression_Obj v = a->value();\n Block_Obj b = a->block();\n\n append_indentation();\n append_token(kwd, a);\n if (s) {\n append_mandatory_space();\n in_wrapped = true;\n s->perform(this);\n in_wrapped = false;\n }\n if (v) {\n append_mandatory_space();\n // ruby sass bug? should use options?\n append_token(v->to_string(/* opt */), v);\n }\n if (!b) {\n append_delimiter();\n return;\n }\n\n if (b->is_invisible() || b->length() == 0) {\n append_optional_space();\n return append_string(\"{}\");\n }\n\n append_scope_opener();\n\n bool format = kwd != \"@font-face\";;\n\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj stm = b->at(i);\n stm->perform(this);\n if (i < L - 1 && format) append_special_linefeed();\n }\n\n append_scope_closer();\n }\n\n void Output::operator()(String_Quoted_Ptr s)\n {\n if (s->quote_mark()) {\n append_token(quote(s->value(), s->quote_mark()), s);\n } else if (!in_comment) {\n append_token(string_to_output(s->value()), s);\n } else {\n append_token(s->value(), s);\n }\n }\n\n void Output::operator()(String_Constant_Ptr s)\n {\n std::string value(s->value());\n if (s->can_compress_whitespace() && output_style() == COMPRESSED) {\n value.erase(std::remove_if(value.begin(), value.end(), ::isspace), value.end());\n }\n if (!in_comment && !in_custom_property) {\n append_token(string_to_output(value), s);\n } else {\n append_token(value, s);\n }\n }\n\n}\n" }, { "path": "libsass-build/output.hpp", "content": "#ifndef SASS_OUTPUT_H\n#define SASS_OUTPUT_H\n\n#include \n#include \n\n#include \"util.hpp\"\n#include \"inspect.hpp\"\n#include \"operation.hpp\"\n\nnamespace Sass {\n class Context;\n\n // Refactor to make it generic to find linefeed (look behind)\n inline bool ends_with(std::string const & value, std::string const & ending)\n {\n if (ending.size() > value.size()) return false;\n return std::equal(ending.rbegin(), ending.rend(), value.rbegin());\n }\n\n class Output : public Inspect {\n protected:\n using Inspect::operator();\n\n public:\n Output(Sass_Output_Options& opt);\n virtual ~Output();\n\n protected:\n std::string charset;\n std::vector top_nodes;\n\n public:\n OutputBuffer get_buffer(void);\n\n virtual void operator()(Map_Ptr);\n virtual void operator()(Ruleset_Ptr);\n virtual void operator()(Supports_Block_Ptr);\n virtual void operator()(Media_Block_Ptr);\n virtual void operator()(Directive_Ptr);\n virtual void operator()(Keyframe_Rule_Ptr);\n virtual void operator()(Import_Ptr);\n virtual void operator()(Comment_Ptr);\n virtual void operator()(Number_Ptr);\n virtual void operator()(String_Quoted_Ptr);\n virtual void operator()(String_Constant_Ptr);\n\n void fallback_impl(AST_Node_Ptr n);\n\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/parser.cpp", "content": "#include \"sass.hpp\"\n#include \"parser.hpp\"\n#include \"file.hpp\"\n#include \"inspect.hpp\"\n#include \"constants.hpp\"\n#include \"util.hpp\"\n#include \"prelexer.hpp\"\n#include \"color_maps.hpp\"\n#include \"sass/functions.h\"\n#include \"error_handling.hpp\"\n\n// Notes about delayed: some ast nodes can have delayed evaluation so\n// they can preserve their original semantics if needed. This is most\n// prominently exhibited by the division operation, since it is not\n// only a valid operation, but also a valid css statement (i.e. for\n// fonts, as in `16px/24px`). When parsing lists and expression we\n// unwrap single items from lists and other operations. A nested list\n// must not be delayed, only the items of the first level sometimes\n// are delayed (as with argument lists). To achieve this we need to\n// pass status to the list parser, so this can be set correctly.\n// Another case with delayed values are colors. In compressed mode\n// only processed values get compressed (other are left as written).\n\n#include \n#include \n#include \n#include \n\nnamespace Sass {\n using namespace Constants;\n using namespace Prelexer;\n\n Parser Parser::from_c_str(const char* beg, Context& ctx, Backtraces traces, ParserState pstate, const char* source)\n {\n pstate.offset.column = 0;\n pstate.offset.line = 0;\n Parser p(ctx, pstate, traces);\n p.source = source ? source : beg;\n p.position = beg ? beg : p.source;\n p.end = p.position + strlen(p.position);\n Block_Obj root = SASS_MEMORY_NEW(Block, pstate);\n p.block_stack.push_back(root);\n root->is_root(true);\n return p;\n }\n\n Parser Parser::from_c_str(const char* beg, const char* end, Context& ctx, Backtraces traces, ParserState pstate, const char* source)\n {\n pstate.offset.column = 0;\n pstate.offset.line = 0;\n Parser p(ctx, pstate, traces);\n p.source = source ? source : beg;\n p.position = beg ? beg : p.source;\n p.end = end ? end : p.position + strlen(p.position);\n Block_Obj root = SASS_MEMORY_NEW(Block, pstate);\n p.block_stack.push_back(root);\n root->is_root(true);\n return p;\n }\n\n void Parser::advanceToNextToken() {\n lex < css_comments >(false);\n // advance to position\n pstate += pstate.offset;\n pstate.offset.column = 0;\n pstate.offset.line = 0;\n }\n\n Selector_List_Obj Parser::parse_selector(const char* beg, Context& ctx, Backtraces traces, ParserState pstate, const char* source)\n {\n Parser p = Parser::from_c_str(beg, ctx, traces, pstate, source);\n // ToDo: ruby sass errors on parent references\n // ToDo: remap the source-map entries somehow\n return p.parse_selector_list(false);\n }\n\n bool Parser::peek_newline(const char* start)\n {\n return peek_linefeed(start ? start : position)\n && ! peek_css>(start);\n }\n\n Parser Parser::from_token(Token t, Context& ctx, Backtraces traces, ParserState pstate, const char* source)\n {\n Parser p(ctx, pstate, traces);\n p.source = source ? source : t.begin;\n p.position = t.begin ? t.begin : p.source;\n p.end = t.end ? t.end : p.position + strlen(p.position);\n Block_Obj root = SASS_MEMORY_NEW(Block, pstate);\n p.block_stack.push_back(root);\n root->is_root(true);\n return p;\n }\n\n /* main entry point to parse root block */\n Block_Obj Parser::parse()\n {\n\n // consume unicode BOM\n read_bom();\n\n // scan the input to find invalid utf8 sequences\n const char* it = utf8::find_invalid(position, end);\n\n // report invalid utf8\n if (it != end) {\n pstate += Offset::init(position, it);\n traces.push_back(Backtrace(pstate));\n throw Exception::InvalidSass(pstate, traces, \"Invalid UTF-8 sequence\");\n }\n\n // create a block AST node to hold children\n Block_Obj root = SASS_MEMORY_NEW(Block, pstate, 0, true);\n\n // check seems a bit esoteric but works\n if (ctx.resources.size() == 1) {\n // apply headers only on very first include\n ctx.apply_custom_headers(root, path, pstate);\n }\n\n // parse children nodes\n block_stack.push_back(root);\n parse_block_nodes(true);\n block_stack.pop_back();\n\n // update final position\n root->update_pstate(pstate);\n\n if (position != end) {\n css_error(\"Invalid CSS\", \" after \", \": expected selector or at-rule, was \");\n }\n\n return root;\n }\n\n\n // convenience function for block parsing\n // will create a new block ad-hoc for you\n // this is the base block parsing function\n Block_Obj Parser::parse_css_block(bool is_root)\n {\n\n // parse comments before block\n // lex < optional_css_comments >();\n\n // lex mandatory opener or error out\n if (!lex_css < exactly<'{'> >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected \\\"{\\\", was \");\n }\n // create new block and push to the selector stack\n Block_Obj block = SASS_MEMORY_NEW(Block, pstate, 0, is_root);\n block_stack.push_back(block);\n\n if (!parse_block_nodes(is_root)) css_error(\"Invalid CSS\", \" after \", \": expected \\\"}\\\", was \");\n\n if (!lex_css < exactly<'}'> >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected \\\"}\\\", was \");\n }\n\n // update for end position\n // this seems to be done somewhere else\n // but that fixed selector schema issue\n // block->update_pstate(pstate);\n\n // parse comments after block\n // lex < optional_css_comments >();\n\n block_stack.pop_back();\n\n return block;\n }\n\n // convenience function for block parsing\n // will create a new block ad-hoc for you\n // also updates the `in_at_root` flag\n Block_Obj Parser::parse_block(bool is_root)\n {\n return parse_css_block(is_root);\n }\n\n // the main block parsing function\n // parses stuff between `{` and `}`\n bool Parser::parse_block_nodes(bool is_root)\n {\n\n // loop until end of string\n while (position < end) {\n\n // we should be able to refactor this\n parse_block_comments();\n lex < css_whitespace >();\n\n if (lex < exactly<';'> >()) continue;\n if (peek < end_of_file >()) return true;\n if (peek < exactly<'}'> >()) return true;\n\n if (parse_block_node(is_root)) continue;\n\n parse_block_comments();\n\n if (lex_css < exactly<';'> >()) continue;\n if (peek_css < end_of_file >()) return true;\n if (peek_css < exactly<'}'> >()) return true;\n\n // illegal sass\n return false;\n }\n // return success\n return true;\n }\n\n // parser for a single node in a block\n // semicolons must be lexed beforehand\n bool Parser::parse_block_node(bool is_root) {\n\n Block_Obj block = block_stack.back();\n\n parse_block_comments();\n\n // throw away white-space\n // includes line comments\n lex < css_whitespace >();\n\n Lookahead lookahead_result;\n\n // also parse block comments\n\n // first parse everything that is allowed in functions\n if (lex < variable >(true)) { block->append(parse_assignment()); }\n else if (lex < kwd_err >(true)) { block->append(parse_error()); }\n else if (lex < kwd_dbg >(true)) { block->append(parse_debug()); }\n else if (lex < kwd_warn >(true)) { block->append(parse_warning()); }\n else if (lex < kwd_if_directive >(true)) { block->append(parse_if_directive()); }\n else if (lex < kwd_for_directive >(true)) { block->append(parse_for_directive()); }\n else if (lex < kwd_each_directive >(true)) { block->append(parse_each_directive()); }\n else if (lex < kwd_while_directive >(true)) { block->append(parse_while_directive()); }\n else if (lex < kwd_return_directive >(true)) { block->append(parse_return_directive()); }\n\n // parse imports to process later\n else if (lex < kwd_import >(true)) {\n Scope parent = stack.empty() ? Scope::Rules : stack.back();\n if (parent != Scope::Function && parent != Scope::Root && parent != Scope::Rules && parent != Scope::Media) {\n if (! peek_css< uri_prefix >(position)) { // this seems to go in ruby sass 3.4.20\n error(\"Import directives may not be used within control directives or mixins.\");\n }\n }\n // this puts the parsed doc into sheets\n // import stub will fetch this in expand\n Import_Obj imp = parse_import();\n // if it is a url, we only add the statement\n if (!imp->urls().empty()) block->append(imp);\n // process all resources now (add Import_Stub nodes)\n for (size_t i = 0, S = imp->incs().size(); i < S; ++i) {\n block->append(SASS_MEMORY_NEW(Import_Stub, pstate, imp->incs()[i]));\n }\n }\n\n else if (lex < kwd_extend >(true)) {\n Lookahead lookahead = lookahead_for_include(position);\n if (!lookahead.found) css_error(\"Invalid CSS\", \" after \", \": expected selector, was \");\n Selector_List_Obj target;\n if (!lookahead.has_interpolants) {\n target = parse_selector_list(true);\n }\n else {\n target = SASS_MEMORY_NEW(Selector_List, pstate);\n target->schema(parse_selector_schema(lookahead.found, true));\n }\n\n block->append(SASS_MEMORY_NEW(Extension, pstate, target));\n }\n\n // selector may contain interpolations which need delayed evaluation\n else if (\n !(lookahead_result = lookahead_for_selector(position)).error &&\n !lookahead_result.is_custom_property\n )\n {\n block->append(parse_ruleset(lookahead_result));\n }\n\n // parse multiple specific keyword directives\n else if (lex < kwd_media >(true)) { block->append(parse_media_block()); }\n else if (lex < kwd_at_root >(true)) { block->append(parse_at_root_block()); }\n else if (lex < kwd_include_directive >(true)) { block->append(parse_include_directive()); }\n else if (lex < kwd_content_directive >(true)) { block->append(parse_content_directive()); }\n else if (lex < kwd_supports_directive >(true)) { block->append(parse_supports_directive()); }\n else if (lex < kwd_mixin >(true)) { block->append(parse_definition(Definition::MIXIN)); }\n else if (lex < kwd_function >(true)) { block->append(parse_definition(Definition::FUNCTION)); }\n\n // ignore the @charset directive for now\n else if (lex< kwd_charset_directive >(true)) { parse_charset_directive(); }\n\n // generic at keyword (keep last)\n else if (lex< re_special_directive >(true)) { block->append(parse_special_directive()); }\n else if (lex< re_prefixed_directive >(true)) { block->append(parse_prefixed_directive()); }\n else if (lex< at_keyword >(true)) { block->append(parse_directive()); }\n\n else if (is_root && stack.back() != Scope::AtRoot /* && block->is_root() */) {\n lex< css_whitespace >();\n if (position >= end) return true;\n css_error(\"Invalid CSS\", \" after \", \": expected 1 selector or at-rule, was \");\n }\n // parse a declaration\n else\n {\n // ToDo: how does it handle parse errors?\n // maybe we are expected to parse something?\n Declaration_Obj decl = parse_declaration();\n decl->tabs(indentation);\n block->append(decl);\n // maybe we have a \"sub-block\"\n if (peek< exactly<'{'> >()) {\n if (decl->is_indented()) ++ indentation;\n // parse a propset that rides on the declaration's property\n stack.push_back(Scope::Properties);\n decl->block(parse_block());\n stack.pop_back();\n if (decl->is_indented()) -- indentation;\n }\n }\n // something matched\n return true;\n }\n // EO parse_block_nodes\n\n // parse imports inside the\n Import_Obj Parser::parse_import()\n {\n Import_Obj imp = SASS_MEMORY_NEW(Import, pstate);\n std::vector> to_import;\n bool first = true;\n do {\n while (lex< block_comment >());\n if (lex< quoted_string >()) {\n to_import.push_back(std::pair(std::string(lexed), 0));\n }\n else if (lex< uri_prefix >()) {\n Arguments_Obj args = SASS_MEMORY_NEW(Arguments, pstate);\n Function_Call_Obj result = SASS_MEMORY_NEW(Function_Call, pstate, \"url\", args);\n\n if (lex< quoted_string >()) {\n Expression_Obj quoted_url = parse_string();\n args->append(SASS_MEMORY_NEW(Argument, quoted_url->pstate(), quoted_url));\n }\n else if (String_Obj string_url = parse_url_function_argument()) {\n args->append(SASS_MEMORY_NEW(Argument, string_url->pstate(), string_url));\n }\n else if (peek < skip_over_scopes < exactly < '(' >, exactly < ')' > > >(position)) {\n Expression_Obj braced_url = parse_list(); // parse_interpolated_chunk(lexed);\n args->append(SASS_MEMORY_NEW(Argument, braced_url->pstate(), braced_url));\n }\n else {\n error(\"malformed URL\");\n }\n if (!lex< exactly<')'> >()) error(\"URI is missing ')'\");\n to_import.push_back(std::pair(\"\", result));\n }\n else {\n if (first) error(\"@import directive requires a url or quoted path\");\n else error(\"expecting another url or quoted path in @import list\");\n }\n first = false;\n } while (lex_css< exactly<','> >());\n\n if (!peek_css< alternatives< exactly<';'>, exactly<'}'>, end_of_file > >()) {\n List_Obj import_queries = parse_media_queries();\n imp->import_queries(import_queries);\n }\n\n for(auto location : to_import) {\n if (location.second) {\n imp->urls().push_back(location.second);\n }\n // check if custom importers want to take over the handling\n else if (!ctx.call_importers(unquote(location.first), path, pstate, imp)) {\n // nobody wants it, so we do our import\n ctx.import_url(imp, location.first, path);\n }\n }\n\n return imp;\n }\n\n Definition_Obj Parser::parse_definition(Definition::Type which_type)\n {\n std::string which_str(lexed);\n if (!lex< identifier >()) error(\"invalid name in \" + which_str + \" definition\");\n std::string name(Util::normalize_underscores(lexed));\n if (which_type == Definition::FUNCTION && (name == \"and\" || name == \"or\" || name == \"not\"))\n { error(\"Invalid function name \\\"\" + name + \"\\\".\"); }\n ParserState source_position_of_def = pstate;\n Parameters_Obj params = parse_parameters();\n if (which_type == Definition::MIXIN) stack.push_back(Scope::Mixin);\n else stack.push_back(Scope::Function);\n Block_Obj body = parse_block();\n stack.pop_back();\n return SASS_MEMORY_NEW(Definition, source_position_of_def, name, params, body, which_type);\n }\n\n Parameters_Obj Parser::parse_parameters()\n {\n Parameters_Obj params = SASS_MEMORY_NEW(Parameters, pstate);\n if (lex_css< exactly<'('> >()) {\n // if there's anything there at all\n if (!peek_css< exactly<')'> >()) {\n do {\n if (peek< exactly<')'> >()) break;\n params->append(parse_parameter());\n } while (lex_css< exactly<','> >());\n }\n if (!lex_css< exactly<')'> >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected \\\")\\\", was \");\n }\n }\n return params;\n }\n\n Parameter_Obj Parser::parse_parameter()\n {\n if (peek< alternatives< exactly<','>, exactly< '{' >, exactly<';'> > >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected variable (e.g. $foo), was \");\n }\n while (lex< alternatives < spaces, block_comment > >());\n lex < variable >();\n std::string name(Util::normalize_underscores(lexed));\n ParserState pos = pstate;\n Expression_Obj val;\n bool is_rest = false;\n while (lex< alternatives < spaces, block_comment > >());\n if (lex< exactly<':'> >()) { // there's a default value\n while (lex< block_comment >());\n val = parse_space_list();\n }\n else if (lex< exactly< ellipsis > >()) {\n is_rest = true;\n }\n return SASS_MEMORY_NEW(Parameter, pos, name, val, is_rest);\n }\n\n Arguments_Obj Parser::parse_arguments()\n {\n Arguments_Obj args = SASS_MEMORY_NEW(Arguments, pstate);\n if (lex_css< exactly<'('> >()) {\n // if there's anything there at all\n if (!peek_css< exactly<')'> >()) {\n do {\n if (peek< exactly<')'> >()) break;\n args->append(parse_argument());\n } while (lex_css< exactly<','> >());\n }\n if (!lex_css< exactly<')'> >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \");\n }\n }\n return args;\n }\n\n Argument_Obj Parser::parse_argument()\n {\n if (peek< alternatives< exactly<','>, exactly< '{' >, exactly<';'> > >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected \\\")\\\", was \");\n }\n if (peek_css< sequence < exactly< hash_lbrace >, exactly< rbrace > > >()) {\n position += 2;\n css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \");\n }\n\n Argument_Obj arg;\n if (peek_css< sequence < variable, optional_css_comments, exactly<':'> > >()) {\n lex_css< variable >();\n std::string name(Util::normalize_underscores(lexed));\n ParserState p = pstate;\n lex_css< exactly<':'> >();\n Expression_Obj val = parse_space_list();\n arg = SASS_MEMORY_NEW(Argument, p, val, name);\n }\n else {\n bool is_arglist = false;\n bool is_keyword = false;\n Expression_Obj val = parse_space_list();\n List_Ptr l = Cast(val);\n if (lex_css< exactly< ellipsis > >()) {\n if (val->concrete_type() == Expression::MAP || (\n (l != NULL && l->separator() == SASS_HASH)\n )) is_keyword = true;\n else is_arglist = true;\n }\n arg = SASS_MEMORY_NEW(Argument, pstate, val, \"\", is_arglist, is_keyword);\n }\n return arg;\n }\n\n Assignment_Obj Parser::parse_assignment()\n {\n std::string name(Util::normalize_underscores(lexed));\n ParserState var_source_position = pstate;\n if (!lex< exactly<':'> >()) error(\"expected ':' after \" + name + \" in assignment statement\");\n if (peek_css< alternatives < exactly<';'>, end_of_file > >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \");\n }\n Expression_Obj val;\n Lookahead lookahead = lookahead_for_value(position);\n if (lookahead.has_interpolants && lookahead.found) {\n val = parse_value_schema(lookahead.found);\n } else {\n val = parse_list();\n }\n bool is_default = false;\n bool is_global = false;\n while (peek< alternatives < default_flag, global_flag > >()) {\n if (lex< default_flag >()) is_default = true;\n else if (lex< global_flag >()) is_global = true;\n }\n return SASS_MEMORY_NEW(Assignment, var_source_position, name, val, is_default, is_global);\n }\n\n // a ruleset connects a selector and a block\n Ruleset_Obj Parser::parse_ruleset(Lookahead lookahead)\n {\n NESTING_GUARD(nestings);\n // inherit is_root from parent block\n Block_Obj parent = block_stack.back();\n bool is_root = parent && parent->is_root();\n // make sure to move up the the last position\n lex < optional_css_whitespace >(false, true);\n // create the connector object (add parts later)\n Ruleset_Obj ruleset = SASS_MEMORY_NEW(Ruleset, pstate);\n // parse selector static or as schema to be evaluated later\n if (lookahead.parsable) ruleset->selector(parse_selector_list(false));\n else {\n Selector_List_Obj list = SASS_MEMORY_NEW(Selector_List, pstate);\n list->schema(parse_selector_schema(lookahead.position, false));\n ruleset->selector(list);\n }\n // then parse the inner block\n stack.push_back(Scope::Rules);\n ruleset->block(parse_block());\n stack.pop_back();\n // update for end position\n ruleset->update_pstate(pstate);\n ruleset->block()->update_pstate(pstate);\n // need this info for sanity checks\n ruleset->is_root(is_root);\n // return AST Node\n return ruleset;\n }\n\n // parse a selector schema that will be evaluated in the eval stage\n // uses a string schema internally to do the actual schema handling\n // in the eval stage we will be re-parse it into an actual selector\n Selector_Schema_Obj Parser::parse_selector_schema(const char* end_of_selector, bool chroot)\n {\n NESTING_GUARD(nestings);\n // move up to the start\n lex< optional_spaces >();\n const char* i = position;\n // selector schema re-uses string schema implementation\n String_Schema_Ptr schema = SASS_MEMORY_NEW(String_Schema, pstate);\n // the selector schema is pretty much just a wrapper for the string schema\n Selector_Schema_Obj selector_schema = SASS_MEMORY_NEW(Selector_Schema, pstate, schema);\n selector_schema->connect_parent(chroot == false);\n selector_schema->media_block(last_media_block);\n\n // process until end\n while (i < end_of_selector) {\n // try to parse mutliple interpolants\n if (const char* p = find_first_in_interval< exactly, block_comment >(i, end_of_selector)) {\n // accumulate the preceding segment if the position has advanced\n if (i < p) {\n std::string parsed(i, p);\n String_Constant_Obj str = SASS_MEMORY_NEW(String_Constant, pstate, parsed);\n pstate += Offset(parsed);\n str->update_pstate(pstate);\n schema->append(str);\n }\n\n // skip over all nested inner interpolations up to our own delimiter\n const char* j = skip_over_scopes< exactly, exactly >(p + 2, end_of_selector);\n // check if the interpolation never ends of only contains white-space (error out)\n if (!j || peek < sequence < optional_spaces, exactly > >(p+2)) {\n position = p+2;\n css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \");\n }\n // pass inner expression to the parser to resolve nested interpolations\n pstate.add(p, p+2);\n Expression_Obj interpolant = Parser::from_c_str(p+2, j, ctx, traces, pstate).parse_list();\n // set status on the list expression\n interpolant->is_interpolant(true);\n // schema->has_interpolants(true);\n // add to the string schema\n schema->append(interpolant);\n // advance parser state\n pstate.add(p+2, j);\n // advance position\n i = j;\n }\n // no more interpolants have been found\n // add the last segment if there is one\n else {\n // make sure to add the last bits of the string up to the end (if any)\n if (i < end_of_selector) {\n std::string parsed(i, end_of_selector);\n String_Constant_Obj str = SASS_MEMORY_NEW(String_Constant, pstate, parsed);\n pstate += Offset(parsed);\n str->update_pstate(pstate);\n i = end_of_selector;\n schema->append(str);\n }\n // exit loop\n }\n }\n // EO until eos\n\n // update position\n position = i;\n\n // update for end position\n selector_schema->update_pstate(pstate);\n schema->update_pstate(pstate);\n\n after_token = before_token = pstate;\n\n // return parsed result\n return selector_schema.detach();\n }\n // EO parse_selector_schema\n\n void Parser::parse_charset_directive()\n {\n lex <\n sequence <\n quoted_string,\n optional_spaces,\n exactly <';'>\n >\n >();\n }\n\n // called after parsing `kwd_include_directive`\n Mixin_Call_Obj Parser::parse_include_directive()\n {\n // lex identifier into `lexed` var\n lex_identifier(); // may error out\n // normalize underscores to hyphens\n std::string name(Util::normalize_underscores(lexed));\n // create the initial mixin call object\n Mixin_Call_Obj call = SASS_MEMORY_NEW(Mixin_Call, pstate, name, 0, 0);\n // parse mandatory arguments\n call->arguments(parse_arguments());\n // parse optional block\n if (peek < exactly <'{'> >()) {\n call->block(parse_block());\n }\n // return ast node\n return call.detach();\n }\n // EO parse_include_directive\n\n // parse a list of complex selectors\n // this is the main entry point for most\n Selector_List_Obj Parser::parse_selector_list(bool chroot)\n {\n bool reloop;\n bool had_linefeed = false;\n NESTING_GUARD(nestings);\n Complex_Selector_Obj sel;\n Selector_List_Obj group = SASS_MEMORY_NEW(Selector_List, pstate);\n group->media_block(last_media_block);\n\n if (peek_css< alternatives < end_of_file, exactly <'{'>, exactly <','> > >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected selector, was \");\n }\n\n do {\n reloop = false;\n\n had_linefeed = had_linefeed || peek_newline();\n\n if (peek_css< alternatives < class_char < selector_list_delims > > >())\n break; // in case there are superfluous commas at the end\n\n // now parse the complex selector\n sel = parse_complex_selector(chroot);\n\n if (!sel) return group.detach();\n\n sel->has_line_feed(had_linefeed);\n\n had_linefeed = false;\n\n while (peek_css< exactly<','> >())\n {\n lex< css_comments >(false);\n // consume everything up and including the comma separator\n reloop = lex< exactly<','> >() != 0;\n // remember line break (also between some commas)\n had_linefeed = had_linefeed || peek_newline();\n // remember line break (also between some commas)\n }\n group->append(sel);\n }\n while (reloop);\n while (lex_css< kwd_optional >()) {\n group->is_optional(true);\n }\n // update for end position\n group->update_pstate(pstate);\n if (sel) sel->last()->has_line_break(false);\n return group.detach();\n }\n // EO parse_selector_list\n\n // a complex selector combines a compound selector with another\n // complex selector, with one of four combinator operations.\n // the compound selector (head) is optional, since the combinator\n // can come first in the whole selector sequence (like `> DIV').\n Complex_Selector_Obj Parser::parse_complex_selector(bool chroot)\n {\n\n NESTING_GUARD(nestings);\n String_Obj reference = 0;\n lex < block_comment >();\n advanceToNextToken();\n Complex_Selector_Obj sel = SASS_MEMORY_NEW(Complex_Selector, pstate);\n\n if (peek < end_of_file >()) return 0;\n\n // parse the left hand side\n Compound_Selector_Obj lhs;\n // special case if it starts with combinator ([+~>])\n if (!peek_css< class_char < selector_combinator_ops > >()) {\n // parse the left hand side\n lhs = parse_compound_selector();\n }\n\n\n // parse combinator between lhs and rhs\n Complex_Selector::Combinator combinator = Complex_Selector::ANCESTOR_OF;\n if (lex< exactly<'+'> >()) combinator = Complex_Selector::ADJACENT_TO;\n else if (lex< exactly<'~'> >()) combinator = Complex_Selector::PRECEDES;\n else if (lex< exactly<'>'> >()) combinator = Complex_Selector::PARENT_OF;\n else if (lex< sequence < exactly<'/'>, negate < exactly < '*' > > > >()) {\n // comments are allowed, but not spaces?\n combinator = Complex_Selector::REFERENCE;\n if (!lex < re_reference_combinator >()) return 0;\n reference = SASS_MEMORY_NEW(String_Constant, pstate, lexed);\n if (!lex < exactly < '/' > >()) return 0; // ToDo: error msg?\n }\n\n if (!lhs && combinator == Complex_Selector::ANCESTOR_OF) return 0;\n\n // lex < block_comment >();\n sel->head(lhs);\n sel->combinator(combinator);\n sel->media_block(last_media_block);\n\n if (combinator == Complex_Selector::REFERENCE) sel->reference(reference);\n // has linfeed after combinator?\n sel->has_line_break(peek_newline());\n // sel->has_line_feed(has_line_feed);\n\n // check if we got the abort condition (ToDo: optimize)\n if (!peek_css< class_char < complex_selector_delims > >()) {\n // parse next selector in sequence\n sel->tail(parse_complex_selector(true));\n }\n\n // add a parent selector if we are not in a root\n // also skip adding parent ref if we only have refs\n if (!sel->has_parent_ref() && !chroot) {\n // create the objects to wrap parent selector reference\n Compound_Selector_Obj head = SASS_MEMORY_NEW(Compound_Selector, pstate);\n Parent_Selector_Ptr parent = SASS_MEMORY_NEW(Parent_Selector, pstate, false);\n parent->media_block(last_media_block);\n head->media_block(last_media_block);\n // add simple selector\n head->append(parent);\n // selector may not have any head yet\n if (!sel->head()) { sel->head(head); }\n // otherwise we need to create a new complex selector and set the old one as its tail\n else {\n sel = SASS_MEMORY_NEW(Complex_Selector, pstate, Complex_Selector::ANCESTOR_OF, head, sel);\n sel->media_block(last_media_block);\n }\n // peek for linefeed and remember result on head\n // if (peek_newline()) head->has_line_break(true);\n }\n\n sel->update_pstate(pstate);\n // complex selector\n return sel;\n }\n // EO parse_complex_selector\n\n // parse one compound selector, which is basically\n // a list of simple selectors (directly adjacent)\n // lex them exactly (without skipping white-space)\n Compound_Selector_Obj Parser::parse_compound_selector()\n {\n // init an empty compound selector wrapper\n Compound_Selector_Obj seq = SASS_MEMORY_NEW(Compound_Selector, pstate);\n seq->media_block(last_media_block);\n\n // skip initial white-space\n lex< css_whitespace >();\n\n // parse list\n while (true)\n {\n // remove all block comments (don't skip white-space)\n lex< delimited_by< slash_star, star_slash, false > >(false);\n // parse functional\n if (match < re_pseudo_selector >())\n {\n seq->append(parse_simple_selector());\n }\n // parse parent selector\n else if (lex< exactly<'&'> >(false))\n {\n // this produces a linefeed!?\n seq->has_parent_reference(true);\n seq->append(SASS_MEMORY_NEW(Parent_Selector, pstate));\n // parent selector only allowed at start\n // upcoming Sass may allow also trailing\n if (seq->length() > 1) {\n ParserState state(pstate);\n Simple_Selector_Obj cur = (*seq)[seq->length()-1];\n Simple_Selector_Obj prev = (*seq)[seq->length()-2];\n std::string sel(prev->to_string({ NESTED, 5 }));\n std::string found(cur->to_string({ NESTED, 5 }));\n if (lex < identifier >()) { found += std::string(lexed); }\n error(\"Invalid CSS after \\\"\" + sel + \"\\\": expected \\\"{\\\", was \\\"\" + found + \"\\\"\\n\\n\"\n \"\\\"\" + found + \"\\\" may only be used at the beginning of a compound selector.\", state);\n }\n }\n // parse type selector\n else if (lex< re_type_selector >(false))\n {\n seq->append(SASS_MEMORY_NEW(Element_Selector, pstate, lexed));\n }\n // peek for abort conditions\n else if (peek< spaces >()) break;\n else if (peek< end_of_file >()) { break; }\n else if (peek_css < class_char < selector_combinator_ops > >()) break;\n else if (peek_css < class_char < complex_selector_delims > >()) break;\n // otherwise parse another simple selector\n else {\n Simple_Selector_Obj sel = parse_simple_selector();\n if (!sel) return 0;\n seq->append(sel);\n }\n }\n\n if (seq && !peek_css>>()) {\n seq->has_line_break(peek_newline());\n }\n\n // EO while true\n return seq;\n\n }\n // EO parse_compound_selector\n\n Simple_Selector_Obj Parser::parse_simple_selector()\n {\n lex < css_comments >(false);\n if (lex< class_name >()) {\n return SASS_MEMORY_NEW(Class_Selector, pstate, lexed);\n }\n else if (lex< id_name >()) {\n return SASS_MEMORY_NEW(Id_Selector, pstate, lexed);\n }\n else if (lex< alternatives < variable, number, static_reference_combinator > >()) {\n return SASS_MEMORY_NEW(Element_Selector, pstate, lexed);\n }\n else if (peek< pseudo_not >()) {\n return parse_negated_selector();\n }\n else if (peek< re_pseudo_selector >()) {\n return parse_pseudo_selector();\n }\n else if (peek< exactly<':'> >()) {\n return parse_pseudo_selector();\n }\n else if (lex < exactly<'['> >()) {\n return parse_attribute_selector();\n }\n else if (lex< placeholder >()) {\n Placeholder_Selector_Ptr sel = SASS_MEMORY_NEW(Placeholder_Selector, pstate, lexed);\n sel->media_block(last_media_block);\n return sel;\n }\n else {\n css_error(\"Invalid CSS\", \" after \", \": expected selector, was \");\n }\n // failed\n return 0;\n }\n\n Wrapped_Selector_Obj Parser::parse_negated_selector()\n {\n lex< pseudo_not >();\n std::string name(lexed);\n ParserState nsource_position = pstate;\n Selector_List_Obj negated = parse_selector_list(true);\n if (!lex< exactly<')'> >()) {\n error(\"negated selector is missing ')'\");\n }\n name.erase(name.size() - 1);\n return SASS_MEMORY_NEW(Wrapped_Selector, nsource_position, name, negated);\n }\n\n // a pseudo selector often starts with one or two colons\n // it can contain more selectors inside parentheses\n Simple_Selector_Obj Parser::parse_pseudo_selector() {\n if (lex< sequence<\n optional < pseudo_prefix >,\n // we keep the space within the name, strange enough\n // ToDo: refactor output to schedule the space for it\n // or do we really want to keep the real white-space?\n sequence< identifier, optional < block_comment >, exactly<'('> >\n > >())\n {\n\n std::string name(lexed);\n name.erase(name.size() - 1);\n ParserState p = pstate;\n\n // specially parse static stuff\n // ToDo: really everything static?\n if (peek_css <\n sequence <\n alternatives <\n static_value,\n binomial\n >,\n optional_css_whitespace,\n exactly<')'>\n >\n >()\n ) {\n lex_css< alternatives < static_value, binomial > >();\n String_Constant_Obj expr = SASS_MEMORY_NEW(String_Constant, pstate, lexed);\n if (lex_css< exactly<')'> >()) {\n expr->can_compress_whitespace(true);\n return SASS_MEMORY_NEW(Pseudo_Selector, p, name, expr);\n }\n }\n else if (Selector_List_Obj wrapped = parse_selector_list(true)) {\n if (wrapped && lex_css< exactly<')'> >()) {\n return SASS_MEMORY_NEW(Wrapped_Selector, p, name, wrapped);\n }\n }\n\n }\n // EO if pseudo selector\n\n else if (lex < sequence< optional < pseudo_prefix >, identifier > >()) {\n return SASS_MEMORY_NEW(Pseudo_Selector, pstate, lexed);\n }\n else if(lex < pseudo_prefix >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected pseudoclass or pseudoelement, was \");\n }\n\n css_error(\"Invalid CSS\", \" after \", \": expected \\\")\\\", was \");\n\n // unreachable statement\n return 0;\n }\n\n const char* Parser::re_attr_sensitive_close(const char* src)\n {\n return alternatives < exactly<']'>, exactly<'/'> >(src);\n }\n\n const char* Parser::re_attr_insensitive_close(const char* src)\n {\n return sequence < insensitive<'i'>, re_attr_sensitive_close >(src);\n }\n\n Attribute_Selector_Obj Parser::parse_attribute_selector()\n {\n ParserState p = pstate;\n if (!lex_css< attribute_name >()) error(\"invalid attribute name in attribute selector\");\n std::string name(lexed);\n if (lex_css< re_attr_sensitive_close >()) {\n return SASS_MEMORY_NEW(Attribute_Selector, p, name, \"\", 0, 0);\n }\n else if (lex_css< re_attr_insensitive_close >()) {\n char modifier = lexed.begin[0];\n return SASS_MEMORY_NEW(Attribute_Selector, p, name, \"\", 0, modifier);\n }\n if (!lex_css< alternatives< exact_match, class_match, dash_match,\n prefix_match, suffix_match, substring_match > >()) {\n error(\"invalid operator in attribute selector for \" + name);\n }\n std::string matcher(lexed);\n\n String_Obj value = 0;\n if (lex_css< identifier >()) {\n value = SASS_MEMORY_NEW(String_Constant, p, lexed);\n }\n else if (lex_css< quoted_string >()) {\n value = parse_interpolated_chunk(lexed, true); // needed!\n }\n else {\n error(\"expected a string constant or identifier in attribute selector for \" + name);\n }\n\n if (lex_css< re_attr_sensitive_close >()) {\n return SASS_MEMORY_NEW(Attribute_Selector, p, name, matcher, value, 0);\n }\n else if (lex_css< re_attr_insensitive_close >()) {\n char modifier = lexed.begin[0];\n return SASS_MEMORY_NEW(Attribute_Selector, p, name, matcher, value, modifier);\n }\n error(\"unterminated attribute selector for \" + name);\n return NULL; // to satisfy compilers (error must not return)\n }\n\n /* parse block comment and add to block */\n void Parser::parse_block_comments()\n {\n Block_Obj block = block_stack.back();\n\n while (lex< block_comment >()) {\n bool is_important = lexed.begin[2] == '!';\n // flag on second param is to skip loosely over comments\n String_Obj contents = parse_interpolated_chunk(lexed, true, false);\n block->append(SASS_MEMORY_NEW(Comment, pstate, contents, is_important));\n }\n }\n\n Declaration_Obj Parser::parse_declaration() {\n String_Obj prop;\n bool is_custom_property = false;\n if (lex< sequence< optional< exactly<'*'> >, identifier_schema > >()) {\n const std::string property(lexed);\n is_custom_property = property.compare(0, 2, \"--\") == 0;\n prop = parse_identifier_schema();\n }\n else if (lex< sequence< optional< exactly<'*'> >, identifier, zero_plus< block_comment > > >()) {\n const std::string property(lexed);\n is_custom_property = property.compare(0, 2, \"--\") == 0;\n prop = SASS_MEMORY_NEW(String_Constant, pstate, lexed);\n }\n else {\n css_error(\"Invalid CSS\", \" after \", \": expected \\\"}\\\", was \");\n }\n bool is_indented = true;\n const std::string property(lexed);\n if (!lex_css< one_plus< exactly<':'> > >()) error(\"property \\\"\" + escape_string(property) + \"\\\" must be followed by a ':'\");\n if (!is_custom_property && match< sequence< optional_css_comments, exactly<';'> > >()) error(\"style declaration must contain a value\");\n if (match< sequence< optional_css_comments, exactly<'{'> > >()) is_indented = false; // don't indent if value is empty\n if (is_custom_property) {\n return SASS_MEMORY_NEW(Declaration, prop->pstate(), prop, parse_css_variable_value(), false, true);\n }\n lex < css_comments >(false);\n if (peek_css< static_value >()) {\n return SASS_MEMORY_NEW(Declaration, prop->pstate(), prop, parse_static_value()/*, lex()*/);\n }\n else {\n Expression_Obj value;\n Lookahead lookahead = lookahead_for_value(position);\n if (lookahead.found) {\n if (lookahead.has_interpolants) {\n value = parse_value_schema(lookahead.found);\n } else {\n value = parse_list(DELAYED);\n }\n }\n else {\n value = parse_list(DELAYED);\n if (List_Ptr list = Cast(value)) {\n if (!list->is_bracketed() && list->length() == 0 && !peek< exactly <'{'> >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \");\n }\n }\n }\n lex < css_comments >(false);\n Declaration_Obj decl = SASS_MEMORY_NEW(Declaration, prop->pstate(), prop, value/*, lex()*/);\n decl->is_indented(is_indented);\n decl->update_pstate(pstate);\n return decl;\n }\n }\n\n // parse +/- and return false if negative\n // this is never hit via spec tests\n bool Parser::parse_number_prefix()\n {\n bool positive = true;\n while(true) {\n if (lex < block_comment >()) continue;\n if (lex < number_prefix >()) continue;\n if (lex < exactly < '-' > >()) {\n positive = !positive;\n continue;\n }\n break;\n }\n return positive;\n }\n\n Expression_Obj Parser::parse_map()\n {\n NESTING_GUARD(nestings);\n Expression_Obj key = parse_list();\n List_Obj map = SASS_MEMORY_NEW(List, pstate, 0, SASS_HASH);\n\n // it's not a map so return the lexed value as a list value\n if (!lex_css< exactly<':'> >())\n { return key; }\n\n List_Obj l = Cast(key);\n if (l && l->separator() == SASS_COMMA) {\n css_error(\"Invalid CSS\", \" after \", \": expected \\\")\\\", was \");\n }\n\n Expression_Obj value = parse_space_list();\n\n map->append(key);\n map->append(value);\n\n while (lex_css< exactly<','> >())\n {\n // allow trailing commas - #495\n if (peek_css< exactly<')'> >(position))\n { break; }\n\n key = parse_space_list();\n\n if (!(lex< exactly<':'> >()))\n { css_error(\"Invalid CSS\", \" after \", \": expected \\\":\\\", was \"); }\n\n value = parse_space_list();\n\n map->append(key);\n map->append(value);\n }\n\n ParserState ps = map->pstate();\n ps.offset = pstate - ps + pstate.offset;\n map->pstate(ps);\n\n return map;\n }\n\n Expression_Obj Parser::parse_bracket_list()\n {\n NESTING_GUARD(nestings);\n // check if we have an empty list\n // return the empty list as such\n if (peek_css< list_terminator >(position))\n {\n // return an empty list (nothing to delay)\n return SASS_MEMORY_NEW(List, pstate, 0, SASS_SPACE, false, true);\n }\n\n bool has_paren = peek_css< exactly<'('> >() != NULL;\n\n // now try to parse a space list\n Expression_Obj list = parse_space_list();\n // if it's a singleton, return it (don't wrap it)\n if (!peek_css< exactly<','> >(position)) {\n List_Obj l = Cast(list);\n if (!l || l->is_bracketed() || has_paren) {\n List_Obj bracketed_list = SASS_MEMORY_NEW(List, pstate, 1, SASS_SPACE, false, true);\n bracketed_list->append(list);\n return bracketed_list;\n }\n l->is_bracketed(true);\n return l;\n }\n\n // if we got so far, we actually do have a comma list\n List_Obj bracketed_list = SASS_MEMORY_NEW(List, pstate, 2, SASS_COMMA, false, true);\n // wrap the first expression\n bracketed_list->append(list);\n\n while (lex_css< exactly<','> >())\n {\n // check for abort condition\n if (peek_css< list_terminator >(position)\n ) { break; }\n // otherwise add another expression\n bracketed_list->append(parse_space_list());\n }\n // return the list\n return bracketed_list;\n }\n\n // parse list returns either a space separated list,\n // a comma separated list or any bare expression found.\n // so to speak: we unwrap items from lists if possible here!\n Expression_Obj Parser::parse_list(bool delayed)\n {\n NESTING_GUARD(nestings);\n return parse_comma_list(delayed);\n }\n\n // will return singletons unwrapped\n Expression_Obj Parser::parse_comma_list(bool delayed)\n {\n NESTING_GUARD(nestings);\n // check if we have an empty list\n // return the empty list as such\n if (peek_css< list_terminator >(position))\n {\n // return an empty list (nothing to delay)\n return SASS_MEMORY_NEW(List, pstate, 0);\n }\n\n // now try to parse a space list\n Expression_Obj list = parse_space_list();\n // if it's a singleton, return it (don't wrap it)\n if (!peek_css< exactly<','> >(position)) {\n // set_delay doesn't apply to list children\n // so this will only undelay single values\n if (!delayed) list->set_delayed(false);\n return list;\n }\n\n // if we got so far, we actually do have a comma list\n List_Obj comma_list = SASS_MEMORY_NEW(List, pstate, 2, SASS_COMMA);\n // wrap the first expression\n comma_list->append(list);\n\n while (lex_css< exactly<','> >())\n {\n // check for abort condition\n if (peek_css< list_terminator >(position)\n ) { break; }\n // otherwise add another expression\n comma_list->append(parse_space_list());\n }\n // return the list\n return comma_list;\n }\n // EO parse_comma_list\n\n // will return singletons unwrapped\n Expression_Obj Parser::parse_space_list()\n {\n NESTING_GUARD(nestings);\n Expression_Obj disj1 = parse_disjunction();\n // if it's a singleton, return it (don't wrap it)\n if (peek_css< space_list_terminator >(position)\n ) {\n return disj1; }\n\n List_Obj space_list = SASS_MEMORY_NEW(List, pstate, 2, SASS_SPACE);\n space_list->append(disj1);\n\n while (\n !(peek_css< space_list_terminator >(position)) &&\n peek_css< optional_css_whitespace >() != end\n ) {\n // the space is parsed implicitly?\n space_list->append(parse_disjunction());\n }\n // return the list\n return space_list;\n }\n // EO parse_space_list\n\n // parse logical OR operation\n Expression_Obj Parser::parse_disjunction()\n {\n NESTING_GUARD(nestings);\n advanceToNextToken();\n ParserState state(pstate);\n // parse the left hand side conjunction\n Expression_Obj conj = parse_conjunction();\n // parse multiple right hand sides\n std::vector operands;\n while (lex_css< kwd_or >())\n operands.push_back(parse_conjunction());\n // if it's a singleton, return it directly\n if (operands.size() == 0) return conj;\n // fold all operands into one binary expression\n Expression_Obj ex = fold_operands(conj, operands, { Sass_OP::OR });\n state.offset = pstate - state + pstate.offset;\n ex->pstate(state);\n return ex;\n }\n // EO parse_disjunction\n\n // parse logical AND operation\n Expression_Obj Parser::parse_conjunction()\n {\n NESTING_GUARD(nestings);\n advanceToNextToken();\n ParserState state(pstate);\n // parse the left hand side relation\n Expression_Obj rel = parse_relation();\n // parse multiple right hand sides\n std::vector operands;\n while (lex_css< kwd_and >()) {\n operands.push_back(parse_relation());\n }\n // if it's a singleton, return it directly\n if (operands.size() == 0) return rel;\n // fold all operands into one binary expression\n Expression_Obj ex = fold_operands(rel, operands, { Sass_OP::AND });\n state.offset = pstate - state + pstate.offset;\n ex->pstate(state);\n return ex;\n }\n // EO parse_conjunction\n\n // parse comparison operations\n Expression_Obj Parser::parse_relation()\n {\n NESTING_GUARD(nestings);\n advanceToNextToken();\n ParserState state(pstate);\n // parse the left hand side expression\n Expression_Obj lhs = parse_expression();\n std::vector operands;\n std::vector operators;\n // if it's a singleton, return it (don't wrap it)\n while (peek< alternatives <\n kwd_eq,\n kwd_neq,\n kwd_gte,\n kwd_gt,\n kwd_lte,\n kwd_lt\n > >(position))\n {\n // is directly adjancent to expression?\n bool left_ws = peek < css_comments >() != NULL;\n // parse the operator\n enum Sass_OP op\n = lex() ? Sass_OP::EQ\n : lex() ? Sass_OP::NEQ\n : lex() ? Sass_OP::GTE\n : lex() ? Sass_OP::LTE\n : lex() ? Sass_OP::GT\n : lex() ? Sass_OP::LT\n // we checked the possibilities on top of fn\n : Sass_OP::EQ;\n // is directly adjacent to expression?\n bool right_ws = peek < css_comments >() != NULL;\n operators.push_back({ op, left_ws, right_ws });\n operands.push_back(parse_expression());\n }\n // we are called recursively for list, so we first\n // fold inner binary expression which has delayed\n // correctly set to zero. After folding we also unwrap\n // single nested items. So we cannot set delay on the\n // returned result here, as we have lost nestings ...\n Expression_Obj ex = fold_operands(lhs, operands, operators);\n state.offset = pstate - state + pstate.offset;\n ex->pstate(state);\n return ex;\n }\n // parse_relation\n\n // parse expression valid for operations\n // called from parse_relation\n // called from parse_for_directive\n // called from parse_media_expression\n // parse addition and subtraction operations\n Expression_Obj Parser::parse_expression()\n {\n NESTING_GUARD(nestings);\n advanceToNextToken();\n ParserState state(pstate);\n // parses multiple add and subtract operations\n // NOTE: make sure that identifiers starting with\n // NOTE: dashes do NOT count as subtract operation\n Expression_Obj lhs = parse_operators();\n // if it's a singleton, return it (don't wrap it)\n if (!(peek_css< exactly<'+'> >(position) ||\n // condition is a bit misterious, but some combinations should not be counted as operations\n (peek< no_spaces >(position) && peek< sequence< negate< unsigned_number >, exactly<'-'>, negate< space > > >(position)) ||\n (peek< sequence< negate< unsigned_number >, exactly<'-'>, negate< unsigned_number > > >(position))) ||\n peek< sequence < zero_plus < exactly <'-' > >, identifier > >(position))\n { return lhs; }\n\n std::vector operands;\n std::vector operators;\n bool left_ws = peek < css_comments >() != NULL;\n while (\n lex_css< exactly<'+'> >() ||\n\n (\n ! peek_css< sequence < zero_plus < exactly <'-' > >, identifier > >(position)\n && lex_css< sequence< negate< digit >, exactly<'-'> > >()\n )\n\n ) {\n\n bool right_ws = peek < css_comments >() != NULL;\n operators.push_back({ lexed.to_string() == \"+\" ? Sass_OP::ADD : Sass_OP::SUB, left_ws, right_ws });\n operands.push_back(parse_operators());\n left_ws = peek < css_comments >() != NULL;\n }\n\n if (operands.size() == 0) return lhs;\n Expression_Obj ex = fold_operands(lhs, operands, operators);\n state.offset = pstate - state + pstate.offset;\n ex->pstate(state);\n return ex;\n }\n\n // parse addition and subtraction operations\n Expression_Obj Parser::parse_operators()\n {\n NESTING_GUARD(nestings);\n advanceToNextToken();\n ParserState state(pstate);\n Expression_Obj factor = parse_factor();\n // if it's a singleton, return it (don't wrap it)\n std::vector operands; // factors\n std::vector operators; // ops\n // lex operations to apply to lhs\n const char* left_ws = peek < css_comments >();\n while (lex_css< class_char< static_ops > >()) {\n const char* right_ws = peek < css_comments >();\n switch(*lexed.begin) {\n case '*': operators.push_back({ Sass_OP::MUL, left_ws != 0, right_ws != 0 }); break;\n case '/': operators.push_back({ Sass_OP::DIV, left_ws != 0, right_ws != 0 }); break;\n case '%': operators.push_back({ Sass_OP::MOD, left_ws != 0, right_ws != 0 }); break;\n default: throw std::runtime_error(\"unknown static op parsed\");\n }\n operands.push_back(parse_factor());\n left_ws = peek < css_comments >();\n }\n // operands and operators to binary expression\n Expression_Obj ex = fold_operands(factor, operands, operators);\n state.offset = pstate - state + pstate.offset;\n ex->pstate(state);\n return ex;\n }\n // EO parse_operators\n\n\n // called from parse_operators\n // called from parse_value_schema\n Expression_Obj Parser::parse_factor()\n {\n NESTING_GUARD(nestings);\n lex < css_comments >(false);\n if (lex_css< exactly<'('> >()) {\n // parse_map may return a list\n Expression_Obj value = parse_map();\n // lex the expected closing parenthesis\n if (!lex_css< exactly<')'> >()) error(\"unclosed parenthesis\");\n // expression can be evaluated\n return value;\n }\n else if (lex_css< exactly<'['> >()) {\n // explicit bracketed\n Expression_Obj value = parse_bracket_list();\n // lex the expected closing square bracket\n if (!lex_css< exactly<']'> >()) error(\"unclosed squared bracket\");\n return value;\n }\n // string may be interpolated\n // if (lex< quoted_string >()) {\n // return &parse_string();\n // }\n else if (peek< ie_property >()) {\n return parse_ie_property();\n }\n else if (peek< ie_keyword_arg >()) {\n return parse_ie_keyword_arg();\n }\n else if (peek< sequence < calc_fn_call, exactly <'('> > >()) {\n return parse_calc_function();\n }\n else if (lex < functional_schema >()) {\n return parse_function_call_schema();\n }\n else if (lex< identifier_schema >()) {\n String_Obj string = parse_identifier_schema();\n if (String_Schema_Ptr schema = Cast(string)) {\n if (lex < exactly < '(' > >()) {\n schema->append(parse_list());\n lex < exactly < ')' > >();\n }\n }\n return string;\n }\n else if (peek< sequence< uri_prefix, W, real_uri_value > >()) {\n return parse_url_function_string();\n }\n else if (peek< re_functional >()) {\n return parse_function_call();\n }\n else if (lex< exactly<'+'> >()) {\n Unary_Expression_Ptr ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::PLUS, parse_factor());\n if (ex && ex->operand()) ex->is_delayed(ex->operand()->is_delayed());\n return ex;\n }\n else if (lex< exactly<'-'> >()) {\n Unary_Expression_Ptr ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::MINUS, parse_factor());\n if (ex && ex->operand()) ex->is_delayed(ex->operand()->is_delayed());\n return ex;\n }\n else if (lex< exactly<'/'> >()) {\n Unary_Expression_Ptr ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::SLASH, parse_factor());\n if (ex && ex->operand()) ex->is_delayed(ex->operand()->is_delayed());\n return ex;\n }\n else if (lex< sequence< kwd_not > >()) {\n Unary_Expression_Ptr ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::NOT, parse_factor());\n if (ex && ex->operand()) ex->is_delayed(ex->operand()->is_delayed());\n return ex;\n }\n // this whole branch is never hit via spec tests\n else if (peek < sequence < one_plus < alternatives < css_whitespace, exactly<'-'>, exactly<'+'> > >, number > >()) {\n if (parse_number_prefix()) return parse_value(); // prefix is positive\n Unary_Expression_Ptr ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::MINUS, parse_value());\n if (ex->operand()) ex->is_delayed(ex->operand()->is_delayed());\n return ex;\n }\n else {\n return parse_value();\n }\n }\n\n bool number_has_zero(const std::string& parsed)\n {\n size_t L = parsed.length();\n return !( (L > 0 && parsed.substr(0, 1) == \".\") ||\n (L > 1 && parsed.substr(0, 2) == \"0.\") ||\n (L > 1 && parsed.substr(0, 2) == \"-.\") ||\n (L > 2 && parsed.substr(0, 3) == \"-0.\") );\n }\n\n Number_Ptr Parser::lexed_number(const ParserState& pstate, const std::string& parsed)\n {\n Number_Ptr nr = SASS_MEMORY_NEW(Number,\n pstate,\n sass_strtod(parsed.c_str()),\n \"\",\n number_has_zero(parsed));\n nr->is_interpolant(false);\n nr->is_delayed(true);\n return nr;\n }\n\n Number_Ptr Parser::lexed_percentage(const ParserState& pstate, const std::string& parsed)\n {\n Number_Ptr nr = SASS_MEMORY_NEW(Number,\n pstate,\n sass_strtod(parsed.c_str()),\n \"%\",\n true);\n nr->is_interpolant(false);\n nr->is_delayed(true);\n return nr;\n }\n\n Number_Ptr Parser::lexed_dimension(const ParserState& pstate, const std::string& parsed)\n {\n size_t L = parsed.length();\n size_t num_pos = parsed.find_first_not_of(\" \\n\\r\\t\");\n if (num_pos == std::string::npos) num_pos = L;\n size_t unit_pos = parsed.find_first_not_of(\"-+0123456789.\", num_pos);\n if (parsed[unit_pos] == 'e' && is_number(parsed[unit_pos+1]) ) {\n unit_pos = parsed.find_first_not_of(\"-+0123456789.\", ++ unit_pos);\n }\n if (unit_pos == std::string::npos) unit_pos = L;\n const std::string& num = parsed.substr(num_pos, unit_pos - num_pos);\n Number_Ptr nr = SASS_MEMORY_NEW(Number,\n pstate,\n sass_strtod(num.c_str()),\n Token(number(parsed.c_str())),\n number_has_zero(parsed));\n nr->is_interpolant(false);\n nr->is_delayed(true);\n return nr;\n }\n\n Value_Ptr Parser::lexed_hex_color(const ParserState& pstate, const std::string& parsed)\n {\n Color_Ptr color = NULL;\n if (parsed[0] != '#') {\n return SASS_MEMORY_NEW(String_Quoted, pstate, parsed);\n }\n // chop off the '#'\n std::string hext(parsed.substr(1));\n if (parsed.length() == 4) {\n std::string r(2, parsed[1]);\n std::string g(2, parsed[2]);\n std::string b(2, parsed[3]);\n color = SASS_MEMORY_NEW(Color,\n pstate,\n static_cast(strtol(r.c_str(), NULL, 16)),\n static_cast(strtol(g.c_str(), NULL, 16)),\n static_cast(strtol(b.c_str(), NULL, 16)),\n 1, // alpha channel\n parsed);\n }\n else if (parsed.length() == 5) {\n std::string r(2, parsed[1]);\n std::string g(2, parsed[2]);\n std::string b(2, parsed[3]);\n std::string a(2, parsed[4]);\n color = SASS_MEMORY_NEW(Color,\n pstate,\n static_cast(strtol(r.c_str(), NULL, 16)),\n static_cast(strtol(g.c_str(), NULL, 16)),\n static_cast(strtol(b.c_str(), NULL, 16)),\n static_cast(strtol(a.c_str(), NULL, 16)) / 255,\n parsed);\n }\n else if (parsed.length() == 7) {\n std::string r(parsed.substr(1,2));\n std::string g(parsed.substr(3,2));\n std::string b(parsed.substr(5,2));\n color = SASS_MEMORY_NEW(Color,\n pstate,\n static_cast(strtol(r.c_str(), NULL, 16)),\n static_cast(strtol(g.c_str(), NULL, 16)),\n static_cast(strtol(b.c_str(), NULL, 16)),\n 1, // alpha channel\n parsed);\n }\n else if (parsed.length() == 9) {\n std::string r(parsed.substr(1,2));\n std::string g(parsed.substr(3,2));\n std::string b(parsed.substr(5,2));\n std::string a(parsed.substr(7,2));\n color = SASS_MEMORY_NEW(Color,\n pstate,\n static_cast(strtol(r.c_str(), NULL, 16)),\n static_cast(strtol(g.c_str(), NULL, 16)),\n static_cast(strtol(b.c_str(), NULL, 16)),\n static_cast(strtol(a.c_str(), NULL, 16)) / 255,\n parsed);\n }\n color->is_interpolant(false);\n color->is_delayed(false);\n return color;\n }\n\n Value_Ptr Parser::color_or_string(const std::string& lexed) const\n {\n if (auto color = name_to_color(lexed)) {\n auto c = SASS_MEMORY_NEW(Color, color);\n c->is_delayed(true);\n c->pstate(pstate);\n c->disp(lexed);\n return c;\n } else {\n return SASS_MEMORY_NEW(String_Constant, pstate, lexed);\n }\n }\n\n // parse one value for a list\n Expression_Obj Parser::parse_value()\n {\n lex< css_comments >(false);\n if (lex< ampersand >())\n {\n if (match< ampersand >()) {\n warning(\"In Sass, \\\"&&\\\" means two copies of the parent selector. You probably want to use \\\"and\\\" instead.\", pstate);\n }\n return SASS_MEMORY_NEW(Parent_Selector, pstate); }\n\n if (lex< kwd_important >())\n { return SASS_MEMORY_NEW(String_Constant, pstate, \"!important\"); }\n\n // parse `10%4px` into separated items and not a schema\n if (lex< sequence < percentage, lookahead < number > > >())\n { return lexed_percentage(lexed); }\n\n if (lex< sequence < number, lookahead< sequence < op, number > > > >())\n { return lexed_number(lexed); }\n\n // string may be interpolated\n if (lex< sequence < quoted_string, lookahead < exactly <'-'> > > >())\n { return parse_string(); }\n\n if (const char* stop = peek< value_schema >())\n { return parse_value_schema(stop); }\n\n // string may be interpolated\n if (lex< quoted_string >())\n { return parse_string(); }\n\n if (lex< kwd_true >())\n { return SASS_MEMORY_NEW(Boolean, pstate, true); }\n\n if (lex< kwd_false >())\n { return SASS_MEMORY_NEW(Boolean, pstate, false); }\n\n if (lex< kwd_null >())\n { return SASS_MEMORY_NEW(Null, pstate); }\n\n if (lex< identifier >()) {\n return color_or_string(lexed);\n }\n\n if (lex< percentage >())\n { return lexed_percentage(lexed); }\n\n // match hex number first because 0x000 looks like a number followed by an identifier\n if (lex< sequence < alternatives< hex, hex0 >, negate < exactly<'-'> > > >())\n { return lexed_hex_color(lexed); }\n\n if (lex< hexa >())\n { return lexed_hex_color(lexed); }\n\n if (lex< sequence < exactly <'#'>, identifier > >())\n { return SASS_MEMORY_NEW(String_Quoted, pstate, lexed); }\n\n // also handle the 10em- foo special case\n // alternatives < exactly < '.' >, .. > -- `1.5em-.75em` is split into a list, not a binary expression\n if (lex< sequence< dimension, optional< sequence< exactly<'-'>, lookahead< alternatives < space > > > > > >())\n { return lexed_dimension(lexed); }\n\n if (lex< sequence< static_component, one_plus< strict_identifier > > >())\n { return SASS_MEMORY_NEW(String_Constant, pstate, lexed); }\n\n if (lex< number >())\n { return lexed_number(lexed); }\n\n if (lex< variable >())\n { return SASS_MEMORY_NEW(Variable, pstate, Util::normalize_underscores(lexed)); }\n\n css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \");\n\n // unreachable statement\n return 0;\n }\n\n // this parses interpolation inside other strings\n // means the result should later be quoted again\n String_Obj Parser::parse_interpolated_chunk(Token chunk, bool constant, bool css)\n {\n const char* i = chunk.begin;\n // see if there any interpolants\n const char* p = constant ? find_first_in_interval< exactly >(i, chunk.end) :\n find_first_in_interval< exactly, block_comment >(i, chunk.end);\n\n if (!p) {\n String_Quoted_Ptr str_quoted = SASS_MEMORY_NEW(String_Quoted, pstate, std::string(i, chunk.end), 0, false, false, true, css);\n if (!constant && str_quoted->quote_mark()) str_quoted->quote_mark('*');\n return str_quoted;\n }\n\n String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate, 0, css);\n schema->is_interpolant(true);\n while (i < chunk.end) {\n p = constant ? find_first_in_interval< exactly >(i, chunk.end) :\n find_first_in_interval< exactly, block_comment >(i, chunk.end);\n if (p) {\n if (i < p) {\n // accumulate the preceding segment if it's nonempty\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(i, p), css));\n }\n // we need to skip anything inside strings\n // create a new target in parser/prelexer\n if (peek < sequence < optional_spaces, exactly > >(p+2)) { position = p+2;\n css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \");\n }\n const char* j = skip_over_scopes< exactly, exactly >(p + 2, chunk.end); // find the closing brace\n if (j) { --j;\n // parse the interpolant and accumulate it\n Expression_Obj interp_node = Parser::from_token(Token(p+2, j), ctx, traces, pstate, source).parse_list();\n interp_node->is_interpolant(true);\n schema->append(interp_node);\n i = j;\n }\n else {\n // throw an error if the interpolant is unterminated\n error(\"unterminated interpolant inside string constant \" + chunk.to_string());\n }\n }\n else { // no interpolants left; add the last segment if nonempty\n // check if we need quotes here (was not sure after merge)\n if (i < chunk.end) schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(i, chunk.end), css));\n break;\n }\n ++ i;\n }\n\n return schema.detach();\n }\n\n String_Schema_Obj Parser::parse_css_variable_value(bool top_level)\n {\n String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate);\n String_Schema_Obj tok;\n if (!(tok = parse_css_variable_value_token(top_level))) {\n return NULL;\n }\n\n schema->concat(tok);\n while ((tok = parse_css_variable_value_token(top_level))) {\n schema->concat(tok);\n }\n\n return schema.detach();\n }\n\n String_Schema_Obj Parser::parse_css_variable_value_token(bool top_level)\n {\n String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate);\n if (\n (top_level && lex< css_variable_top_level_value >(false)) ||\n (!top_level && lex< css_variable_value >(false))\n ) {\n Token str(lexed);\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, str));\n }\n else if (Expression_Obj tok = lex_interpolation()) {\n if (String_Schema_Ptr s = Cast(tok)) {\n schema->concat(s);\n } else {\n schema->append(tok);\n }\n }\n else if (lex< quoted_string >()) {\n Expression_Obj tok = parse_string();\n if (String_Schema_Ptr s = Cast(tok)) {\n schema->concat(s);\n } else {\n schema->append(tok);\n }\n }\n else {\n if (peek< alternatives< exactly<'('>, exactly<'['>, exactly<'{'> > >()) {\n if (lex< exactly<'('> >()) {\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(\"(\")));\n if (String_Schema_Obj tok = parse_css_variable_value(false)) schema->concat(tok);\n if (!lex< exactly<')'> >()) css_error(\"Invalid CSS\", \" after \", \": expected \\\")\\\", was \");\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(\")\")));\n }\n else if (lex< exactly<'['> >()) {\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(\"[\")));\n if (String_Schema_Obj tok = parse_css_variable_value(false)) schema->concat(tok);\n if (!lex< exactly<']'> >()) css_error(\"Invalid CSS\", \" after \", \": expected \\\"]\\\", was \");\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(\"]\")));\n }\n else if (lex< exactly<'{'> >()) {\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(\"{\")));\n if (String_Schema_Obj tok = parse_css_variable_value(false)) schema->concat(tok);\n if (!lex< exactly<'}'> >()) css_error(\"Invalid CSS\", \" after \", \": expected \\\"}\\\", was \");\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(\"}\")));\n }\n }\n }\n\n return schema->length() > 0 ? schema.detach() : NULL;\n }\n\n Value_Obj Parser::parse_static_value()\n {\n lex< static_value >();\n Token str(lexed);\n // static values always have trailing white-\n // space and end delimiter (\\s*[;]$) included\n --pstate.offset.column;\n --after_token.column;\n --str.end;\n --position;\n\n return color_or_string(str.time_wspace());;\n }\n\n String_Obj Parser::parse_string()\n {\n return parse_interpolated_chunk(Token(lexed));\n }\n\n String_Obj Parser::parse_ie_property()\n {\n lex< ie_property >();\n Token str(lexed);\n const char* i = str.begin;\n // see if there any interpolants\n const char* p = find_first_in_interval< exactly, block_comment >(str.begin, str.end);\n if (!p) {\n return SASS_MEMORY_NEW(String_Quoted, pstate, std::string(str.begin, str.end));\n }\n\n String_Schema_Ptr schema = SASS_MEMORY_NEW(String_Schema, pstate);\n while (i < str.end) {\n p = find_first_in_interval< exactly, block_comment >(i, str.end);\n if (p) {\n if (i < p) {\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(i, p))); // accumulate the preceding segment if it's nonempty\n }\n if (peek < sequence < optional_spaces, exactly > >(p+2)) { position = p+2;\n css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \");\n }\n const char* j = skip_over_scopes< exactly, exactly >(p+2, str.end); // find the closing brace\n if (j) {\n // parse the interpolant and accumulate it\n Expression_Obj interp_node = Parser::from_token(Token(p+2, j), ctx, traces, pstate, source).parse_list();\n interp_node->is_interpolant(true);\n schema->append(interp_node);\n i = j;\n }\n else {\n // throw an error if the interpolant is unterminated\n error(\"unterminated interpolant inside IE function \" + str.to_string());\n }\n }\n else { // no interpolants left; add the last segment if nonempty\n if (i < str.end) {\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(i, str.end)));\n }\n break;\n }\n }\n return schema;\n }\n\n String_Obj Parser::parse_ie_keyword_arg()\n {\n String_Schema_Ptr kwd_arg = SASS_MEMORY_NEW(String_Schema, pstate, 3);\n if (lex< variable >()) {\n kwd_arg->append(SASS_MEMORY_NEW(Variable, pstate, Util::normalize_underscores(lexed)));\n } else {\n lex< alternatives< identifier_schema, identifier > >();\n kwd_arg->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));\n }\n lex< exactly<'='> >();\n kwd_arg->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));\n if (peek< variable >()) kwd_arg->append(parse_list());\n else if (lex< number >()) {\n std::string parsed(lexed);\n Util::normalize_decimals(parsed);\n kwd_arg->append(lexed_number(parsed));\n }\n else if (peek < ie_keyword_arg_value >()) { kwd_arg->append(parse_list()); }\n return kwd_arg;\n }\n\n String_Schema_Obj Parser::parse_value_schema(const char* stop)\n {\n // initialize the string schema object to add tokens\n String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate);\n\n if (peek>()) {\n css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \");\n }\n\n const char* e;\n const char* ee = end;\n end = stop;\n size_t num_items = 0;\n bool need_space = false;\n while (position < stop) {\n // parse space between tokens\n if (lex< spaces >() && num_items) {\n need_space = true;\n }\n if (need_space) {\n need_space = false;\n // schema->append(SASS_MEMORY_NEW(String_Constant, pstate, \" \"));\n }\n if ((e = peek< re_functional >()) && e < stop) {\n schema->append(parse_function_call());\n }\n // lex an interpolant /#{...}/\n else if (lex< exactly < hash_lbrace > >()) {\n // Try to lex static expression first\n if (peek< exactly< rbrace > >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \");\n }\n Expression_Obj ex;\n if (lex< re_static_expression >()) {\n ex = SASS_MEMORY_NEW(String_Constant, pstate, lexed);\n } else {\n ex = parse_list(true);\n }\n ex->is_interpolant(true);\n schema->append(ex);\n if (!lex < exactly < rbrace > >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected \\\"}\\\", was \");\n }\n }\n // lex some string constants or other valid token\n // Note: [-+] chars are left over from i.e. `#{3}+3`\n else if (lex< alternatives < exactly<'%'>, exactly < '-' >, exactly < '+' > > >()) {\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));\n }\n // lex a quoted string\n else if (lex< quoted_string >()) {\n // need_space = true;\n // if (schema->length()) schema->append(SASS_MEMORY_NEW(String_Constant, pstate, \" \"));\n // else need_space = true;\n schema->append(parse_string());\n if ((*position == '\"' || *position == '\\'') || peek < alternatives < alpha > >()) {\n // need_space = true;\n }\n if (peek < exactly < '-' > >()) break;\n }\n else if (lex< identifier >()) {\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));\n if ((*position == '\"' || *position == '\\'') || peek < alternatives < alpha > >()) {\n // need_space = true;\n }\n }\n // lex (normalized) variable\n else if (lex< variable >()) {\n std::string name(Util::normalize_underscores(lexed));\n schema->append(SASS_MEMORY_NEW(Variable, pstate, name));\n }\n // lex percentage value\n else if (lex< percentage >()) {\n schema->append(lexed_percentage(lexed));\n }\n // lex dimension value\n else if (lex< dimension >()) {\n schema->append(lexed_dimension(lexed));\n }\n // lex number value\n else if (lex< number >()) {\n schema->append(lexed_number(lexed));\n }\n // lex hex color value\n else if (lex< sequence < hex, negate < exactly < '-' > > > >()) {\n schema->append(lexed_hex_color(lexed));\n }\n else if (lex< sequence < exactly <'#'>, identifier > >()) {\n schema->append(SASS_MEMORY_NEW(String_Quoted, pstate, lexed));\n }\n // lex a value in parentheses\n else if (peek< parenthese_scope >()) {\n schema->append(parse_factor());\n }\n else {\n break;\n }\n ++num_items;\n }\n if (position != stop) {\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(position, stop)));\n position = stop;\n }\n end = ee;\n return schema;\n }\n\n // this parses interpolation outside other strings\n // means the result must not be quoted again later\n String_Obj Parser::parse_identifier_schema()\n {\n Token id(lexed);\n const char* i = id.begin;\n // see if there any interpolants\n const char* p = find_first_in_interval< exactly, block_comment >(id.begin, id.end);\n if (!p) {\n return SASS_MEMORY_NEW(String_Constant, pstate, std::string(id.begin, id.end));\n }\n\n String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate);\n while (i < id.end) {\n p = find_first_in_interval< exactly, block_comment >(i, id.end);\n if (p) {\n if (i < p) {\n // accumulate the preceding segment if it's nonempty\n const char* o = position; position = i;\n schema->append(parse_value_schema(p));\n position = o;\n }\n // we need to skip anything inside strings\n // create a new target in parser/prelexer\n if (peek < sequence < optional_spaces, exactly > >(p+2)) { position = p;\n css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \");\n }\n const char* j = skip_over_scopes< exactly, exactly >(p+2, id.end); // find the closing brace\n if (j) {\n // parse the interpolant and accumulate it\n Expression_Obj interp_node = Parser::from_token(Token(p+2, j), ctx, traces, pstate, source).parse_list(DELAYED);\n interp_node->is_interpolant(true);\n schema->append(interp_node);\n // schema->has_interpolants(true);\n i = j;\n }\n else {\n // throw an error if the interpolant is unterminated\n error(\"unterminated interpolant inside interpolated identifier \" + id.to_string());\n }\n }\n else { // no interpolants left; add the last segment if nonempty\n if (i < end) {\n const char* o = position; position = i;\n schema->append(parse_value_schema(id.end));\n position = o;\n }\n break;\n }\n }\n return schema ? schema.detach() : 0;\n }\n\n // calc functions should preserve arguments\n Function_Call_Obj Parser::parse_calc_function()\n {\n lex< identifier >();\n std::string name(lexed);\n ParserState call_pos = pstate;\n lex< exactly<'('> >();\n ParserState arg_pos = pstate;\n const char* arg_beg = position;\n parse_list();\n const char* arg_end = position;\n lex< skip_over_scopes <\n exactly < '(' >,\n exactly < ')' >\n > >();\n\n Argument_Obj arg = SASS_MEMORY_NEW(Argument, arg_pos, parse_interpolated_chunk(Token(arg_beg, arg_end)));\n Arguments_Obj args = SASS_MEMORY_NEW(Arguments, arg_pos);\n args->append(arg);\n return SASS_MEMORY_NEW(Function_Call, call_pos, name, args);\n }\n\n String_Obj Parser::parse_url_function_string()\n {\n std::string prefix(\"\");\n if (lex< uri_prefix >()) {\n prefix = std::string(lexed);\n }\n\n lex < optional_spaces >();\n String_Obj url_string = parse_url_function_argument();\n\n std::string suffix(\"\");\n if (lex< real_uri_suffix >()) {\n suffix = std::string(lexed);\n }\n\n std::string uri(\"\");\n if (url_string) {\n uri = url_string->to_string({ NESTED, 5 });\n }\n\n if (String_Schema_Ptr schema = Cast(url_string)) {\n String_Schema_Obj res = SASS_MEMORY_NEW(String_Schema, pstate);\n res->append(SASS_MEMORY_NEW(String_Constant, pstate, prefix));\n res->append(schema);\n res->append(SASS_MEMORY_NEW(String_Constant, pstate, suffix));\n return res;\n } else {\n std::string res = prefix + uri + suffix;\n return SASS_MEMORY_NEW(String_Constant, pstate, res);\n }\n }\n\n String_Obj Parser::parse_url_function_argument()\n {\n const char* p = position;\n\n std::string uri(\"\");\n if (lex< real_uri_value >(false)) {\n uri = lexed.to_string();\n }\n\n if (peek< exactly< hash_lbrace > >()) {\n const char* pp = position;\n // TODO: error checking for unclosed interpolants\n while (pp && peek< exactly< hash_lbrace > >(pp)) {\n pp = sequence< interpolant, real_uri_value >(pp);\n }\n if (!pp) return 0;\n position = pp;\n return parse_interpolated_chunk(Token(p, position));\n }\n else if (uri != \"\") {\n std::string res = Util::rtrim(uri);\n return SASS_MEMORY_NEW(String_Constant, pstate, res);\n }\n\n return 0;\n }\n\n Function_Call_Obj Parser::parse_function_call()\n {\n lex< identifier >();\n std::string name(lexed);\n\n if (Util::normalize_underscores(name) == \"content-exists\" && stack.back() != Scope::Mixin)\n { error(\"Cannot call content-exists() except within a mixin.\"); }\n\n ParserState call_pos = pstate;\n Arguments_Obj args = parse_arguments();\n return SASS_MEMORY_NEW(Function_Call, call_pos, name, args);\n }\n\n Function_Call_Schema_Obj Parser::parse_function_call_schema()\n {\n String_Obj name = parse_identifier_schema();\n ParserState source_position_of_call = pstate;\n Arguments_Obj args = parse_arguments();\n\n return SASS_MEMORY_NEW(Function_Call_Schema, source_position_of_call, name, args);\n }\n\n Content_Obj Parser::parse_content_directive()\n {\n return SASS_MEMORY_NEW(Content, pstate);\n }\n\n If_Obj Parser::parse_if_directive(bool else_if)\n {\n stack.push_back(Scope::Control);\n ParserState if_source_position = pstate;\n bool root = block_stack.back()->is_root();\n Expression_Obj predicate = parse_list();\n Block_Obj block = parse_block(root);\n Block_Obj alternative = NULL;\n\n // only throw away comment if we parse a case\n // we want all other comments to be parsed\n if (lex_css< elseif_directive >()) {\n alternative = SASS_MEMORY_NEW(Block, pstate);\n alternative->append(parse_if_directive(true));\n }\n else if (lex_css< kwd_else_directive >()) {\n alternative = parse_block(root);\n }\n stack.pop_back();\n return SASS_MEMORY_NEW(If, if_source_position, predicate, block, alternative);\n }\n\n For_Obj Parser::parse_for_directive()\n {\n stack.push_back(Scope::Control);\n ParserState for_source_position = pstate;\n bool root = block_stack.back()->is_root();\n lex_variable();\n std::string var(Util::normalize_underscores(lexed));\n if (!lex< kwd_from >()) error(\"expected 'from' keyword in @for directive\");\n Expression_Obj lower_bound = parse_expression();\n bool inclusive = false;\n if (lex< kwd_through >()) inclusive = true;\n else if (lex< kwd_to >()) inclusive = false;\n else error(\"expected 'through' or 'to' keyword in @for directive\");\n Expression_Obj upper_bound = parse_expression();\n Block_Obj body = parse_block(root);\n stack.pop_back();\n return SASS_MEMORY_NEW(For, for_source_position, var, lower_bound, upper_bound, body, inclusive);\n }\n\n // helper to parse a var token\n Token Parser::lex_variable()\n {\n // peek for dollar sign first\n if (!peek< exactly <'$'> >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected \\\"$\\\", was \");\n }\n // we expect a simple identifier as the call name\n if (!lex< sequence < exactly <'$'>, identifier > >()) {\n lex< exactly <'$'> >(); // move pstate and position up\n css_error(\"Invalid CSS\", \" after \", \": expected identifier, was \");\n }\n // return object\n return token;\n }\n // helper to parse identifier\n Token Parser::lex_identifier()\n {\n // we expect a simple identifier as the call name\n if (!lex< identifier >()) { // ToDo: pstate wrong?\n css_error(\"Invalid CSS\", \" after \", \": expected identifier, was \");\n }\n // return object\n return token;\n }\n\n Each_Obj Parser::parse_each_directive()\n {\n stack.push_back(Scope::Control);\n ParserState each_source_position = pstate;\n bool root = block_stack.back()->is_root();\n std::vector vars;\n lex_variable();\n vars.push_back(Util::normalize_underscores(lexed));\n while (lex< exactly<','> >()) {\n if (!lex< variable >()) error(\"@each directive requires an iteration variable\");\n vars.push_back(Util::normalize_underscores(lexed));\n }\n if (!lex< kwd_in >()) error(\"expected 'in' keyword in @each directive\");\n Expression_Obj list = parse_list();\n Block_Obj body = parse_block(root);\n stack.pop_back();\n return SASS_MEMORY_NEW(Each, each_source_position, vars, list, body);\n }\n\n // called after parsing `kwd_while_directive`\n While_Obj Parser::parse_while_directive()\n {\n stack.push_back(Scope::Control);\n bool root = block_stack.back()->is_root();\n // create the initial while call object\n While_Obj call = SASS_MEMORY_NEW(While, pstate, 0, 0);\n // parse mandatory predicate\n Expression_Obj predicate = parse_list();\n List_Obj l = Cast(predicate);\n if (!predicate || (l && !l->length())) {\n css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \", false);\n }\n call->predicate(predicate);\n // parse mandatory block\n call->block(parse_block(root));\n // return ast node\n stack.pop_back();\n // return ast node\n return call.detach();\n }\n\n // EO parse_while_directive\n Media_Block_Obj Parser::parse_media_block()\n {\n stack.push_back(Scope::Media);\n Media_Block_Obj media_block = SASS_MEMORY_NEW(Media_Block, pstate, 0, 0);\n\n media_block->media_queries(parse_media_queries());\n\n Media_Block_Obj prev_media_block = last_media_block;\n last_media_block = media_block;\n media_block->block(parse_css_block());\n last_media_block = prev_media_block;\n stack.pop_back();\n return media_block.detach();\n }\n\n List_Obj Parser::parse_media_queries()\n {\n advanceToNextToken();\n List_Obj queries = SASS_MEMORY_NEW(List, pstate, 0, SASS_COMMA);\n if (!peek_css < exactly <'{'> >()) queries->append(parse_media_query());\n while (lex_css < exactly <','> >()) queries->append(parse_media_query());\n queries->update_pstate(pstate);\n return queries.detach();\n }\n\n // Expression_Ptr Parser::parse_media_query()\n Media_Query_Obj Parser::parse_media_query()\n {\n advanceToNextToken();\n Media_Query_Obj media_query = SASS_MEMORY_NEW(Media_Query, pstate);\n if (lex < kwd_not >()) { media_query->is_negated(true); lex < css_comments >(false); }\n else if (lex < kwd_only >()) { media_query->is_restricted(true); lex < css_comments >(false); }\n\n if (lex < identifier_schema >()) media_query->media_type(parse_identifier_schema());\n else if (lex < identifier >()) media_query->media_type(parse_interpolated_chunk(lexed));\n else media_query->append(parse_media_expression());\n\n while (lex_css < kwd_and >()) media_query->append(parse_media_expression());\n if (lex < identifier_schema >()) {\n String_Schema_Ptr schema = SASS_MEMORY_NEW(String_Schema, pstate);\n schema->append(media_query->media_type());\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, \" \"));\n schema->append(parse_identifier_schema());\n media_query->media_type(schema);\n }\n while (lex_css < kwd_and >()) media_query->append(parse_media_expression());\n\n media_query->update_pstate(pstate);\n\n return media_query;\n }\n\n Media_Query_Expression_Obj Parser::parse_media_expression()\n {\n if (lex < identifier_schema >()) {\n String_Obj ss = parse_identifier_schema();\n return SASS_MEMORY_NEW(Media_Query_Expression, pstate, ss, 0, true);\n }\n if (!lex_css< exactly<'('> >()) {\n error(\"media query expression must begin with '('\");\n }\n Expression_Obj feature;\n if (peek_css< exactly<')'> >()) {\n error(\"media feature required in media query expression\");\n }\n feature = parse_expression();\n Expression_Obj expression = 0;\n if (lex_css< exactly<':'> >()) {\n expression = parse_list(DELAYED);\n }\n if (!lex_css< exactly<')'> >()) {\n error(\"unclosed parenthesis in media query expression\");\n }\n return SASS_MEMORY_NEW(Media_Query_Expression, feature->pstate(), feature, expression);\n }\n\n // lexed after `kwd_supports_directive`\n // these are very similar to media blocks\n Supports_Block_Obj Parser::parse_supports_directive()\n {\n Supports_Condition_Obj cond = parse_supports_condition();\n if (!cond) {\n css_error(\"Invalid CSS\", \" after \", \": expected @supports condition (e.g. (display: flexbox)), was \", false);\n }\n // create the ast node object for the support queries\n Supports_Block_Obj query = SASS_MEMORY_NEW(Supports_Block, pstate, cond);\n // additional block is mandatory\n // parse inner block\n query->block(parse_block());\n // return ast node\n return query;\n }\n\n // parse one query operation\n // may encounter nested queries\n Supports_Condition_Obj Parser::parse_supports_condition()\n {\n lex < css_whitespace >();\n Supports_Condition_Obj cond;\n if ((cond = parse_supports_negation())) return cond;\n if ((cond = parse_supports_operator())) return cond;\n if ((cond = parse_supports_interpolation())) return cond;\n return cond;\n }\n\n Supports_Condition_Obj Parser::parse_supports_negation()\n {\n if (!lex < kwd_not >()) return 0;\n Supports_Condition_Obj cond = parse_supports_condition_in_parens();\n return SASS_MEMORY_NEW(Supports_Negation, pstate, cond);\n }\n\n Supports_Condition_Obj Parser::parse_supports_operator()\n {\n Supports_Condition_Obj cond = parse_supports_condition_in_parens();\n if (cond.isNull()) return 0;\n\n while (true) {\n Supports_Operator::Operand op = Supports_Operator::OR;\n if (lex < kwd_and >()) { op = Supports_Operator::AND; }\n else if(!lex < kwd_or >()) { break; }\n\n lex < css_whitespace >();\n Supports_Condition_Obj right = parse_supports_condition_in_parens();\n\n // Supports_Condition_Ptr cc = SASS_MEMORY_NEW(Supports_Condition, *static_cast(cond));\n cond = SASS_MEMORY_NEW(Supports_Operator, pstate, cond, right, op);\n }\n return cond;\n }\n\n Supports_Condition_Obj Parser::parse_supports_interpolation()\n {\n if (!lex < interpolant >()) return 0;\n\n String_Obj interp = parse_interpolated_chunk(lexed);\n if (!interp) return 0;\n\n return SASS_MEMORY_NEW(Supports_Interpolation, pstate, interp);\n }\n\n // TODO: This needs some major work. Although feature conditions\n // look like declarations their semantics differ significantly\n Supports_Condition_Obj Parser::parse_supports_declaration()\n {\n Supports_Condition_Ptr cond;\n // parse something declaration like\n Expression_Obj feature = parse_expression();\n Expression_Obj expression = 0;\n if (lex_css< exactly<':'> >()) {\n expression = parse_list(DELAYED);\n }\n if (!feature || !expression) error(\"@supports condition expected declaration\");\n cond = SASS_MEMORY_NEW(Supports_Declaration,\n feature->pstate(),\n feature,\n expression);\n // ToDo: maybe we need an additional error condition?\n return cond;\n }\n\n Supports_Condition_Obj Parser::parse_supports_condition_in_parens()\n {\n Supports_Condition_Obj interp = parse_supports_interpolation();\n if (interp != 0) return interp;\n\n if (!lex < exactly <'('> >()) return 0;\n lex < css_whitespace >();\n\n Supports_Condition_Obj cond = parse_supports_condition();\n if (cond != 0) {\n if (!lex < exactly <')'> >()) error(\"unclosed parenthesis in @supports declaration\");\n } else {\n cond = parse_supports_declaration();\n if (!lex < exactly <')'> >()) error(\"unclosed parenthesis in @supports declaration\");\n }\n lex < css_whitespace >();\n return cond;\n }\n\n At_Root_Block_Obj Parser::parse_at_root_block()\n {\n stack.push_back(Scope::AtRoot);\n ParserState at_source_position = pstate;\n Block_Obj body = 0;\n At_Root_Query_Obj expr;\n Lookahead lookahead_result;\n if (lex_css< exactly<'('> >()) {\n expr = parse_at_root_query();\n }\n if (peek_css < exactly<'{'> >()) {\n lex ();\n body = parse_block(true);\n }\n else if ((lookahead_result = lookahead_for_selector(position)).found) {\n Ruleset_Obj r = parse_ruleset(lookahead_result);\n body = SASS_MEMORY_NEW(Block, r->pstate(), 1, true);\n body->append(r);\n }\n At_Root_Block_Obj at_root = SASS_MEMORY_NEW(At_Root_Block, at_source_position, body);\n if (!expr.isNull()) at_root->expression(expr);\n stack.pop_back();\n return at_root;\n }\n\n At_Root_Query_Obj Parser::parse_at_root_query()\n {\n if (peek< exactly<')'> >()) error(\"at-root feature required in at-root expression\");\n\n if (!peek< alternatives< kwd_with_directive, kwd_without_directive > >()) {\n css_error(\"Invalid CSS\", \" after \", \": expected \\\"with\\\" or \\\"without\\\", was \");\n }\n\n Expression_Obj feature = parse_list();\n if (!lex_css< exactly<':'> >()) error(\"style declaration must contain a value\");\n Expression_Obj expression = parse_list();\n List_Obj value = SASS_MEMORY_NEW(List, feature->pstate(), 1);\n\n if (expression->concrete_type() == Expression::LIST) {\n value = Cast(expression);\n }\n else value->append(expression);\n\n At_Root_Query_Obj cond = SASS_MEMORY_NEW(At_Root_Query,\n value->pstate(),\n feature,\n value);\n if (!lex_css< exactly<')'> >()) error(\"unclosed parenthesis in @at-root expression\");\n return cond;\n }\n\n Directive_Obj Parser::parse_special_directive()\n {\n std::string kwd(lexed);\n\n if (lexed == \"@else\") error(\"Invalid CSS: @else must come after @if\");\n\n // this whole branch is never hit via spec tests\n\n Directive_Ptr at_rule = SASS_MEMORY_NEW(Directive, pstate, kwd);\n Lookahead lookahead = lookahead_for_include(position);\n if (lookahead.found && !lookahead.has_interpolants) {\n at_rule->selector(parse_selector_list(false));\n }\n\n lex < css_comments >(false);\n\n if (lex < static_property >()) {\n at_rule->value(parse_interpolated_chunk(Token(lexed)));\n } else if (!(peek < alternatives < exactly<'{'>, exactly<'}'>, exactly<';'> > >())) {\n at_rule->value(parse_list());\n }\n\n lex < css_comments >(false);\n\n if (peek< exactly<'{'> >()) {\n at_rule->block(parse_block());\n }\n\n return at_rule;\n }\n\n // this whole branch is never hit via spec tests\n Directive_Obj Parser::parse_prefixed_directive()\n {\n std::string kwd(lexed);\n\n if (lexed == \"@else\") error(\"Invalid CSS: @else must come after @if\");\n\n Directive_Obj at_rule = SASS_MEMORY_NEW(Directive, pstate, kwd);\n Lookahead lookahead = lookahead_for_include(position);\n if (lookahead.found && !lookahead.has_interpolants) {\n at_rule->selector(parse_selector_list(false));\n }\n\n lex < css_comments >(false);\n\n if (lex < static_property >()) {\n at_rule->value(parse_interpolated_chunk(Token(lexed)));\n } else if (!(peek < alternatives < exactly<'{'>, exactly<'}'>, exactly<';'> > >())) {\n at_rule->value(parse_list());\n }\n\n lex < css_comments >(false);\n\n if (peek< exactly<'{'> >()) {\n at_rule->block(parse_block());\n }\n\n return at_rule;\n }\n\n\n Directive_Obj Parser::parse_directive()\n {\n Directive_Obj directive = SASS_MEMORY_NEW(Directive, pstate, lexed);\n String_Schema_Obj val = parse_almost_any_value();\n // strip left and right if they are of type string\n directive->value(val);\n if (peek< exactly<'{'> >()) {\n directive->block(parse_block());\n }\n return directive;\n }\n\n Expression_Obj Parser::lex_interpolation()\n {\n if (lex < interpolant >(true) != NULL) {\n return parse_interpolated_chunk(lexed, true);\n }\n return 0;\n }\n\n Expression_Obj Parser::lex_interp_uri()\n {\n // create a string schema by lexing optional interpolations\n return lex_interp< re_string_uri_open, re_string_uri_close >();\n }\n\n Expression_Obj Parser::lex_interp_string()\n {\n Expression_Obj rv;\n if ((rv = lex_interp< re_string_double_open, re_string_double_close >())) return rv;\n if ((rv = lex_interp< re_string_single_open, re_string_single_close >())) return rv;\n return rv;\n }\n\n Expression_Obj Parser::lex_almost_any_value_chars()\n {\n const char* match =\n lex <\n one_plus <\n alternatives <\n sequence <\n exactly <'\\\\'>,\n any_char\n >,\n sequence <\n negate <\n sequence <\n exactly < url_kwd >,\n exactly <'('>\n >\n >,\n neg_class_char <\n almost_any_value_class\n >\n >,\n sequence <\n exactly <'/'>,\n negate <\n alternatives <\n exactly <'/'>,\n exactly <'*'>\n >\n >\n >,\n sequence <\n exactly <'\\\\'>,\n exactly <'#'>,\n negate <\n exactly <'{'>\n >\n >,\n sequence <\n exactly <'!'>,\n negate <\n alpha\n >\n >\n >\n >\n >(false);\n if (match) {\n return SASS_MEMORY_NEW(String_Constant, pstate, lexed);\n }\n return NULL;\n }\n\n Expression_Obj Parser::lex_almost_any_value_token()\n {\n Expression_Obj rv;\n if (*position == 0) return 0;\n if ((rv = lex_almost_any_value_chars())) return rv;\n // if ((rv = lex_block_comment())) return rv;\n // if ((rv = lex_single_line_comment())) return rv;\n if ((rv = lex_interp_string())) return rv;\n if ((rv = lex_interp_uri())) return rv;\n if ((rv = lex_interpolation())) return rv;\n if (lex< alternatives< hex, hex0 > >())\n { return lexed_hex_color(lexed); }\n return rv;\n }\n\n String_Schema_Obj Parser::parse_almost_any_value()\n {\n\n String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate);\n if (*position == 0) return 0;\n lex < spaces >(false);\n Expression_Obj token = lex_almost_any_value_token();\n if (!token) return 0;\n schema->append(token);\n if (*position == 0) {\n schema->rtrim();\n return schema.detach();\n }\n\n while ((token = lex_almost_any_value_token())) {\n schema->append(token);\n }\n\n lex < css_whitespace >();\n\n schema->rtrim();\n\n return schema.detach();\n }\n\n Warning_Obj Parser::parse_warning()\n {\n if (stack.back() != Scope::Root &&\n stack.back() != Scope::Function &&\n stack.back() != Scope::Mixin &&\n stack.back() != Scope::Control &&\n stack.back() != Scope::Rules) {\n error(\"Illegal nesting: Only properties may be nested beneath properties.\");\n }\n return SASS_MEMORY_NEW(Warning, pstate, parse_list(DELAYED));\n }\n\n Error_Obj Parser::parse_error()\n {\n if (stack.back() != Scope::Root &&\n stack.back() != Scope::Function &&\n stack.back() != Scope::Mixin &&\n stack.back() != Scope::Control &&\n stack.back() != Scope::Rules) {\n error(\"Illegal nesting: Only properties may be nested beneath properties.\");\n }\n return SASS_MEMORY_NEW(Error, pstate, parse_list(DELAYED));\n }\n\n Debug_Obj Parser::parse_debug()\n {\n if (stack.back() != Scope::Root &&\n stack.back() != Scope::Function &&\n stack.back() != Scope::Mixin &&\n stack.back() != Scope::Control &&\n stack.back() != Scope::Rules) {\n error(\"Illegal nesting: Only properties may be nested beneath properties.\");\n }\n return SASS_MEMORY_NEW(Debug, pstate, parse_list(DELAYED));\n }\n\n Return_Obj Parser::parse_return_directive()\n {\n // check that we do not have an empty list (ToDo: check if we got all cases)\n if (peek_css < alternatives < exactly < ';' >, exactly < '}' >, end_of_file > >())\n { css_error(\"Invalid CSS\", \" after \", \": expected expression (e.g. 1px, bold), was \"); }\n return SASS_MEMORY_NEW(Return, pstate, parse_list());\n }\n\n Lookahead Parser::lookahead_for_selector(const char* start)\n {\n // init result struct\n Lookahead rv = Lookahead();\n // get start position\n const char* p = start ? start : position;\n // match in one big \"regex\"\n rv.error = p;\n if (const char* q =\n peek <\n re_selector_list\n >(p)\n ) {\n bool could_be_property = peek< sequence< exactly<'-'>, exactly<'-'> > >(p) != 0;\n bool could_be_escaped = false;\n while (p < q) {\n // did we have interpolations?\n if (*p == '#' && *(p+1) == '{') {\n rv.has_interpolants = true;\n p = q; break;\n }\n // A property that's ambiguous with a nested selector is interpreted as a\n // custom property.\n if (*p == ':' && !could_be_escaped) {\n rv.is_custom_property = could_be_property || p+1 == q || peek< space >(p+1);\n }\n could_be_escaped = *p == '\\\\';\n ++ p;\n }\n // store anyway }\n\n\n // ToDo: remove\n rv.error = q;\n rv.position = q;\n // check expected opening bracket\n // only after successfull matching\n if (peek < exactly<'{'> >(q)) rv.found = q;\n // else if (peek < end_of_file >(q)) rv.found = q;\n else if (peek < exactly<'('> >(q)) rv.found = q;\n // else if (peek < exactly<';'> >(q)) rv.found = q;\n // else if (peek < exactly<'}'> >(q)) rv.found = q;\n if (rv.found || *p == 0) rv.error = 0;\n }\n\n rv.parsable = ! rv.has_interpolants;\n\n // return result\n return rv;\n\n }\n // EO lookahead_for_selector\n\n // used in parse_block_nodes and parse_special_directive\n // ToDo: actual usage is still not really clear to me?\n Lookahead Parser::lookahead_for_include(const char* start)\n {\n // we actually just lookahead for a selector\n Lookahead rv = lookahead_for_selector(start);\n // but the \"found\" rules are different\n if (const char* p = rv.position) {\n // check for additional abort condition\n if (peek < exactly<';'> >(p)) rv.found = p;\n else if (peek < exactly<'}'> >(p)) rv.found = p;\n }\n // return result\n return rv;\n }\n // EO lookahead_for_include\n\n // look ahead for a token with interpolation in it\n // we mostly use the result if there is an interpolation\n // everything that passes here gets parsed as one schema\n // meaning it will not be parsed as a space separated list\n Lookahead Parser::lookahead_for_value(const char* start)\n {\n // init result struct\n Lookahead rv = Lookahead();\n // get start position\n const char* p = start ? start : position;\n // match in one big \"regex\"\n if (const char* q =\n peek <\n non_greedy <\n alternatives <\n // consume whitespace\n block_comment, // spaces,\n // main tokens\n sequence <\n interpolant,\n optional <\n quoted_string\n >\n >,\n identifier,\n variable,\n // issue #442\n sequence <\n parenthese_scope,\n interpolant,\n optional <\n quoted_string\n >\n >\n >,\n sequence <\n // optional_spaces,\n alternatives <\n // end_of_file,\n exactly<'{'>,\n exactly<'}'>,\n exactly<';'>\n >\n >\n >\n >(p)\n ) {\n if (p == q) return rv;\n while (p < q) {\n // did we have interpolations?\n if (*p == '#' && *(p+1) == '{') {\n rv.has_interpolants = true;\n p = q; break;\n }\n ++ p;\n }\n // store anyway\n // ToDo: remove\n rv.position = q;\n // check expected opening bracket\n // only after successful matching\n if (peek < exactly<'{'> >(q)) rv.found = q;\n else if (peek < exactly<';'> >(q)) rv.found = q;\n else if (peek < exactly<'}'> >(q)) rv.found = q;\n }\n\n // return result\n return rv;\n }\n // EO lookahead_for_value\n\n void Parser::read_bom()\n {\n size_t skip = 0;\n std::string encoding;\n bool utf_8 = false;\n switch ((unsigned char) source[0]) {\n case 0xEF:\n skip = check_bom_chars(source, end, utf_8_bom, 3);\n encoding = \"UTF-8\";\n utf_8 = true;\n break;\n case 0xFE:\n skip = check_bom_chars(source, end, utf_16_bom_be, 2);\n encoding = \"UTF-16 (big endian)\";\n break;\n case 0xFF:\n skip = check_bom_chars(source, end, utf_16_bom_le, 2);\n skip += (skip ? check_bom_chars(source, end, utf_32_bom_le, 4) : 0);\n encoding = (skip == 2 ? \"UTF-16 (little endian)\" : \"UTF-32 (little endian)\");\n break;\n case 0x00:\n skip = check_bom_chars(source, end, utf_32_bom_be, 4);\n encoding = \"UTF-32 (big endian)\";\n break;\n case 0x2B:\n skip = check_bom_chars(source, end, utf_7_bom_1, 4)\n | check_bom_chars(source, end, utf_7_bom_2, 4)\n | check_bom_chars(source, end, utf_7_bom_3, 4)\n | check_bom_chars(source, end, utf_7_bom_4, 4)\n | check_bom_chars(source, end, utf_7_bom_5, 5);\n encoding = \"UTF-7\";\n break;\n case 0xF7:\n skip = check_bom_chars(source, end, utf_1_bom, 3);\n encoding = \"UTF-1\";\n break;\n case 0xDD:\n skip = check_bom_chars(source, end, utf_ebcdic_bom, 4);\n encoding = \"UTF-EBCDIC\";\n break;\n case 0x0E:\n skip = check_bom_chars(source, end, scsu_bom, 3);\n encoding = \"SCSU\";\n break;\n case 0xFB:\n skip = check_bom_chars(source, end, bocu_1_bom, 3);\n encoding = \"BOCU-1\";\n break;\n case 0x84:\n skip = check_bom_chars(source, end, gb_18030_bom, 4);\n encoding = \"GB-18030\";\n break;\n default: break;\n }\n if (skip > 0 && !utf_8) error(\"only UTF-8 documents are currently supported; your document appears to be \" + encoding);\n position += skip;\n }\n\n size_t check_bom_chars(const char* src, const char *end, const unsigned char* bom, size_t len)\n {\n size_t skip = 0;\n if (src + len > end) return 0;\n for (size_t i = 0; i < len; ++i, ++skip) {\n if ((unsigned char) src[i] != bom[i]) return 0;\n }\n return skip;\n }\n\n\n Expression_Obj Parser::fold_operands(Expression_Obj base, std::vector& operands, Operand op)\n {\n for (size_t i = 0, S = operands.size(); i < S; ++i) {\n base = SASS_MEMORY_NEW(Binary_Expression, base->pstate(), op, base, operands[i]);\n }\n return base;\n }\n\n Expression_Obj Parser::fold_operands(Expression_Obj base, std::vector& operands, std::vector& ops, size_t i)\n {\n if (String_Schema_Ptr schema = Cast(base)) {\n // return schema;\n if (schema->has_interpolants()) {\n if (i + 1 < operands.size() && (\n (ops[0].operand == Sass_OP::EQ)\n || (ops[0].operand == Sass_OP::ADD)\n || (ops[0].operand == Sass_OP::DIV)\n || (ops[0].operand == Sass_OP::MUL)\n || (ops[0].operand == Sass_OP::NEQ)\n || (ops[0].operand == Sass_OP::LT)\n || (ops[0].operand == Sass_OP::GT)\n || (ops[0].operand == Sass_OP::LTE)\n || (ops[0].operand == Sass_OP::GTE)\n )) {\n Expression_Obj rhs = fold_operands(operands[i], operands, ops, i + 1);\n rhs = SASS_MEMORY_NEW(Binary_Expression, base->pstate(), ops[0], schema, rhs);\n return rhs;\n }\n // return schema;\n }\n }\n\n for (size_t S = operands.size(); i < S; ++i) {\n if (String_Schema_Ptr schema = Cast(operands[i])) {\n if (schema->has_interpolants()) {\n if (i + 1 < S) {\n // this whole branch is never hit via spec tests\n Expression_Obj rhs = fold_operands(operands[i+1], operands, ops, i + 2);\n rhs = SASS_MEMORY_NEW(Binary_Expression, base->pstate(), ops[i], schema, rhs);\n base = SASS_MEMORY_NEW(Binary_Expression, base->pstate(), ops[i], base, rhs);\n return base;\n }\n base = SASS_MEMORY_NEW(Binary_Expression, base->pstate(), ops[i], base, operands[i]);\n return base;\n } else {\n base = SASS_MEMORY_NEW(Binary_Expression, base->pstate(), ops[i], base, operands[i]);\n }\n } else {\n base = SASS_MEMORY_NEW(Binary_Expression, base->pstate(), ops[i], base, operands[i]);\n }\n Binary_Expression_Ptr b = Cast(base.ptr());\n if (b && ops[i].operand == Sass_OP::DIV && b->left()->is_delayed() && b->right()->is_delayed()) {\n base->is_delayed(true);\n }\n }\n // nested binary expression are never to be delayed\n if (Binary_Expression_Ptr b = Cast(base)) {\n if (Cast(b->left())) base->set_delayed(false);\n if (Cast(b->right())) base->set_delayed(false);\n }\n return base;\n }\n\n void Parser::error(std::string msg, Position pos)\n {\n Position p(pos.line ? pos : before_token);\n ParserState pstate(path, source, p, Offset(0, 0));\n traces.push_back(Backtrace(pstate));\n throw Exception::InvalidSass(pstate, traces, msg);\n }\n\n void Parser::error(std::string msg)\n {\n error(msg, pstate);\n }\n\n // print a css parsing error with actual context information from parsed source\n void Parser::css_error(const std::string& msg, const std::string& prefix, const std::string& middle, const bool trim)\n {\n int max_len = 18;\n const char* end = this->end;\n while (*end != 0) ++ end;\n const char* pos = peek < optional_spaces >();\n if (!pos) pos = position;\n\n const char* last_pos(pos);\n if (last_pos > source) {\n utf8::prior(last_pos, source);\n }\n // backup position to last significant char\n while (trim && last_pos > source && last_pos < end) {\n if (!Prelexer::is_space(*last_pos)) break;\n utf8::prior(last_pos, source);\n }\n\n bool ellipsis_left = false;\n const char* pos_left(last_pos);\n const char* end_left(last_pos);\n\n if (*pos_left) utf8::next(pos_left, end);\n if (*end_left) utf8::next(end_left, end);\n while (pos_left > source) {\n if (utf8::distance(pos_left, end_left) >= max_len) {\n utf8::prior(pos_left, source);\n ellipsis_left = *(pos_left) != '\\n' &&\n *(pos_left) != '\\r';\n utf8::next(pos_left, end);\n break;\n }\n\n const char* prev = pos_left;\n utf8::prior(prev, source);\n if (*prev == '\\r') break;\n if (*prev == '\\n') break;\n pos_left = prev;\n }\n if (pos_left < source) {\n pos_left = source;\n }\n\n bool ellipsis_right = false;\n const char* end_right(pos);\n const char* pos_right(pos);\n while (end_right < end) {\n if (utf8::distance(pos_right, end_right) > max_len) {\n ellipsis_left = *(pos_right) != '\\n' &&\n *(pos_right) != '\\r';\n break;\n }\n if (*end_right == '\\r') break;\n if (*end_right == '\\n') break;\n utf8::next(end_right, end);\n }\n // if (*end_right == 0) end_right ++;\n\n std::string left(pos_left, end_left);\n std::string right(pos_right, end_right);\n size_t left_subpos = left.size() > 15 ? left.size() - 15 : 0;\n size_t right_subpos = right.size() > 15 ? right.size() - 15 : 0;\n if (left_subpos && ellipsis_left) left = ellipsis + left.substr(left_subpos);\n if (right_subpos && ellipsis_right) right = right.substr(right_subpos) + ellipsis;\n // Hotfix when source is null, probably due to interpolation parsing!?\n if (source == NULL || *source == 0) source = pstate.src;\n // now pass new message to the more generic error function\n error(msg + prefix + quote(left) + middle + quote(right));\n }\n\n}\n" }, { "path": "libsass-build/parser.hpp", "content": "#ifndef SASS_PARSER_H\n#define SASS_PARSER_H\n\n#include \n#include \n\n#include \"ast.hpp\"\n#include \"position.hpp\"\n#include \"context.hpp\"\n#include \"position.hpp\"\n#include \"prelexer.hpp\"\n\n#ifndef MAX_NESTING\n// Note that this limit is not an exact science\n// it depends on various factors, which some are\n// not under our control (compile time or even OS\n// dependent settings on the available stack size)\n// It should fix most common segfault cases though.\n#define MAX_NESTING 512\n#endif\n\nstruct Lookahead {\n const char* found;\n const char* error;\n const char* position;\n bool parsable;\n bool has_interpolants;\n bool is_custom_property;\n};\n\nnamespace Sass {\n\n class Parser : public ParserState {\n public:\n\n enum Scope { Root, Mixin, Function, Media, Control, Properties, Rules, AtRoot };\n\n Context& ctx;\n std::vector block_stack;\n std::vector stack;\n Media_Block_Ptr last_media_block;\n const char* source;\n const char* position;\n const char* end;\n Position before_token;\n Position after_token;\n ParserState pstate;\n Backtraces traces;\n size_t indentation;\n size_t nestings;\n\n Token lexed;\n\n Parser(Context& ctx, const ParserState& pstate, Backtraces traces)\n : ParserState(pstate), ctx(ctx), block_stack(), stack(0), last_media_block(),\n source(0), position(0), end(0), before_token(pstate), after_token(pstate),\n pstate(pstate), traces(traces), indentation(0), nestings(0)\n { \n stack.push_back(Scope::Root);\n }\n\n // static Parser from_string(const std::string& src, Context& ctx, ParserState pstate = ParserState(\"[STRING]\"));\n static Parser from_c_str(const char* src, Context& ctx, Backtraces, ParserState pstate = ParserState(\"[CSTRING]\"), const char* source = 0);\n static Parser from_c_str(const char* beg, const char* end, Context& ctx, Backtraces, ParserState pstate = ParserState(\"[CSTRING]\"), const char* source = 0);\n static Parser from_token(Token t, Context& ctx, Backtraces, ParserState pstate = ParserState(\"[TOKEN]\"), const char* source = 0);\n // special static parsers to convert strings into certain selectors\n static Selector_List_Obj parse_selector(const char* src, Context& ctx, Backtraces, ParserState pstate = ParserState(\"[SELECTOR]\"), const char* source = 0);\n\n#ifdef __clang__\n\n // lex and peak uses the template parameter to branch on the action, which\n // triggers clangs tautological comparison on the single-comparison\n // branches. This is not a bug, just a merging of behaviour into\n // one function\n\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wtautological-compare\"\n\n#endif\n\n\n // skip current token and next whitespace\n // moves ParserState right before next token\n void advanceToNextToken();\n\n bool peek_newline(const char* start = 0);\n\n // skip over spaces, tabs and line comments\n template \n const char* sneak(const char* start = 0)\n {\n using namespace Prelexer;\n\n // maybe use optional start position from arguments?\n const char* it_position = start ? start : position;\n\n // skip white-space?\n if (mx == spaces ||\n mx == no_spaces ||\n mx == css_comments ||\n mx == css_whitespace ||\n mx == optional_spaces ||\n mx == optional_css_comments ||\n mx == optional_css_whitespace\n ) {\n return it_position;\n }\n\n // skip over spaces, tabs and sass line comments\n const char* pos = optional_css_whitespace(it_position);\n // always return a valid position\n return pos ? pos : it_position;\n\n }\n\n // match will not skip over space, tabs and line comment\n // return the position where the lexer match will occur\n template \n const char* match(const char* start = 0)\n {\n // match the given prelexer\n return mx(position);\n }\n\n // peek will only skip over space, tabs and line comment\n // return the position where the lexer match will occur\n template \n const char* peek(const char* start = 0)\n {\n\n // sneak up to the actual token we want to lex\n // this should skip over white-space if desired\n const char* it_before_token = sneak < mx >(start);\n\n // match the given prelexer\n const char* match = mx(it_before_token);\n\n // check if match is in valid range\n return match <= end ? match : 0;\n\n }\n\n // white-space handling is built into the lexer\n // this way you do not need to parse it yourself\n // some matchers don't accept certain white-space\n // we do not support start arg, since we manipulate\n // sourcemap offset and we modify the position pointer!\n // lex will only skip over space, tabs and line comment\n template \n const char* lex(bool lazy = true, bool force = false)\n {\n\n if (*position == 0) return 0;\n\n // position considered before lexed token\n // we can skip whitespace or comments for\n // lazy developers (but we need control)\n const char* it_before_token = position;\n\n // sneak up to the actual token we want to lex\n // this should skip over white-space if desired\n if (lazy) it_before_token = sneak < mx >(position);\n\n // now call matcher to get position after token\n const char* it_after_token = mx(it_before_token);\n\n // check if match is in valid range\n if (it_after_token > end) return 0;\n\n // maybe we want to update the parser state anyway?\n if (force == false) {\n // assertion that we got a valid match\n if (it_after_token == 0) return 0;\n // assertion that we actually lexed something\n if (it_after_token == it_before_token) return 0;\n }\n\n // create new lexed token object (holds the parse results)\n lexed = Token(position, it_before_token, it_after_token);\n\n // advance position (add whitespace before current token)\n before_token = after_token.add(position, it_before_token);\n\n // update after_token position for current token\n after_token.add(it_before_token, it_after_token);\n\n // ToDo: could probably do this incremetal on original object (API wants offset?)\n pstate = ParserState(path, source, lexed, before_token, after_token - before_token);\n\n // advance internal char iterator\n return position = it_after_token;\n\n }\n\n // lex_css skips over space, tabs, line and block comment\n // all block comments will be consumed and thrown away\n // source-map position will point to token after the comment\n template \n const char* lex_css()\n {\n // copy old token\n Token prev = lexed;\n // store previous pointer\n const char* oldpos = position;\n Position bt = before_token;\n Position at = after_token;\n ParserState op = pstate;\n // throw away comments\n // update srcmap position\n lex < Prelexer::css_comments >();\n // now lex a new token\n const char* pos = lex< mx >();\n // maybe restore prev state\n if (pos == 0) {\n pstate = op;\n lexed = prev;\n position = oldpos;\n after_token = at;\n before_token = bt;\n }\n // return match\n return pos;\n }\n\n // all block comments will be skipped and thrown away\n template \n const char* peek_css(const char* start = 0)\n {\n // now peek a token (skip comments first)\n return peek< mx >(peek < Prelexer::css_comments >(start));\n }\n\n#ifdef __clang__\n\n#pragma clang diagnostic pop\n\n#endif\n\n void error(std::string msg);\n void error(std::string msg, Position pos);\n // generate message with given and expected sample\n // text before and in the middle are configurable\n void css_error(const std::string& msg,\n const std::string& prefix = \" after \",\n const std::string& middle = \", was: \",\n const bool trim = true);\n void read_bom();\n\n Block_Obj parse();\n Import_Obj parse_import();\n Definition_Obj parse_definition(Definition::Type which_type);\n Parameters_Obj parse_parameters();\n Parameter_Obj parse_parameter();\n Mixin_Call_Obj parse_include_directive();\n Arguments_Obj parse_arguments();\n Argument_Obj parse_argument();\n Assignment_Obj parse_assignment();\n Ruleset_Obj parse_ruleset(Lookahead lookahead);\n Selector_List_Obj parse_selector_list(bool chroot);\n Complex_Selector_Obj parse_complex_selector(bool chroot);\n Selector_Schema_Obj parse_selector_schema(const char* end_of_selector, bool chroot);\n Compound_Selector_Obj parse_compound_selector();\n Simple_Selector_Obj parse_simple_selector();\n Wrapped_Selector_Obj parse_negated_selector();\n Simple_Selector_Obj parse_pseudo_selector();\n Attribute_Selector_Obj parse_attribute_selector();\n Block_Obj parse_block(bool is_root = false);\n Block_Obj parse_css_block(bool is_root = false);\n bool parse_block_nodes(bool is_root = false);\n bool parse_block_node(bool is_root = false);\n\n bool parse_number_prefix();\n Declaration_Obj parse_declaration();\n Expression_Obj parse_map();\n Expression_Obj parse_bracket_list();\n Expression_Obj parse_list(bool delayed = false);\n Expression_Obj parse_comma_list(bool delayed = false);\n Expression_Obj parse_space_list();\n Expression_Obj parse_disjunction();\n Expression_Obj parse_conjunction();\n Expression_Obj parse_relation();\n Expression_Obj parse_expression();\n Expression_Obj parse_operators();\n Expression_Obj parse_factor();\n Expression_Obj parse_value();\n Function_Call_Obj parse_calc_function();\n Function_Call_Obj parse_function_call();\n Function_Call_Schema_Obj parse_function_call_schema();\n String_Obj parse_url_function_string();\n String_Obj parse_url_function_argument();\n String_Obj parse_interpolated_chunk(Token, bool constant = false, bool css = true);\n String_Obj parse_string();\n Value_Obj parse_static_value();\n String_Schema_Obj parse_css_variable_value(bool top_level = true);\n String_Schema_Obj parse_css_variable_value_token(bool top_level = true);\n String_Obj parse_ie_property();\n String_Obj parse_ie_keyword_arg();\n String_Schema_Obj parse_value_schema(const char* stop);\n String_Obj parse_identifier_schema();\n If_Obj parse_if_directive(bool else_if = false);\n For_Obj parse_for_directive();\n Each_Obj parse_each_directive();\n While_Obj parse_while_directive();\n Return_Obj parse_return_directive();\n Content_Obj parse_content_directive();\n void parse_charset_directive();\n Media_Block_Obj parse_media_block();\n List_Obj parse_media_queries();\n Media_Query_Obj parse_media_query();\n Media_Query_Expression_Obj parse_media_expression();\n Supports_Block_Obj parse_supports_directive();\n Supports_Condition_Obj parse_supports_condition();\n Supports_Condition_Obj parse_supports_negation();\n Supports_Condition_Obj parse_supports_operator();\n Supports_Condition_Obj parse_supports_interpolation();\n Supports_Condition_Obj parse_supports_declaration();\n Supports_Condition_Obj parse_supports_condition_in_parens();\n At_Root_Block_Obj parse_at_root_block();\n At_Root_Query_Obj parse_at_root_query();\n String_Schema_Obj parse_almost_any_value();\n Directive_Obj parse_special_directive();\n Directive_Obj parse_prefixed_directive();\n Directive_Obj parse_directive();\n Warning_Obj parse_warning();\n Error_Obj parse_error();\n Debug_Obj parse_debug();\n\n Value_Ptr color_or_string(const std::string& lexed) const;\n\n // be more like ruby sass\n Expression_Obj lex_almost_any_value_token();\n Expression_Obj lex_almost_any_value_chars();\n Expression_Obj lex_interp_string();\n Expression_Obj lex_interp_uri();\n Expression_Obj lex_interpolation();\n\n // these will throw errors\n Token lex_variable();\n Token lex_identifier();\n\n void parse_block_comments();\n\n Lookahead lookahead_for_value(const char* start = 0);\n Lookahead lookahead_for_selector(const char* start = 0);\n Lookahead lookahead_for_include(const char* start = 0);\n\n Expression_Obj fold_operands(Expression_Obj base, std::vector& operands, Operand op);\n Expression_Obj fold_operands(Expression_Obj base, std::vector& operands, std::vector& ops, size_t i = 0);\n\n void throw_syntax_error(std::string message, size_t ln = 0);\n void throw_read_error(std::string message, size_t ln = 0);\n\n\n template \n Expression_Obj lex_interp()\n {\n if (lex < open >(false)) {\n String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate);\n // std::cerr << \"LEX [[\" << std::string(lexed) << \"]]\\n\";\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));\n if (position[0] == '#' && position[1] == '{') {\n Expression_Obj itpl = lex_interpolation();\n if (!itpl.isNull()) schema->append(itpl);\n while (lex < close >(false)) {\n // std::cerr << \"LEX [[\" << std::string(lexed) << \"]]\\n\";\n schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));\n if (position[0] == '#' && position[1] == '{') {\n Expression_Obj itpl = lex_interpolation();\n if (!itpl.isNull()) schema->append(itpl);\n } else {\n return schema;\n }\n }\n } else {\n return SASS_MEMORY_NEW(String_Constant, pstate, lexed);\n }\n }\n return 0;\n }\n\n public:\n static Number_Ptr lexed_number(const ParserState& pstate, const std::string& parsed);\n static Number_Ptr lexed_dimension(const ParserState& pstate, const std::string& parsed);\n static Number_Ptr lexed_percentage(const ParserState& pstate, const std::string& parsed);\n static Value_Ptr lexed_hex_color(const ParserState& pstate, const std::string& parsed);\n private:\n Number_Ptr lexed_number(const std::string& parsed) { return lexed_number(pstate, parsed); };\n Number_Ptr lexed_dimension(const std::string& parsed) { return lexed_dimension(pstate, parsed); };\n Number_Ptr lexed_percentage(const std::string& parsed) { return lexed_percentage(pstate, parsed); };\n Value_Ptr lexed_hex_color(const std::string& parsed) { return lexed_hex_color(pstate, parsed); };\n\n static const char* re_attr_sensitive_close(const char* src);\n static const char* re_attr_insensitive_close(const char* src);\n\n };\n\n size_t check_bom_chars(const char* src, const char *end, const unsigned char* bom, size_t len);\n}\n\n#endif\n" }, { "path": "libsass-build/paths.hpp", "content": "#ifndef SASS_PATHS_H\n#define SASS_PATHS_H\n\n#include \n#include \n#include \n\n\ntemplate\nstd::string vector_to_string(std::vector v)\n{\n std::stringstream buffer;\n buffer << \"[\";\n\n if (!v.empty())\n { buffer << v[0]; }\n else\n { buffer << \"]\"; }\n\n if (v.size() == 1)\n { buffer << \"]\"; }\n else\n {\n for (size_t i = 1, S = v.size(); i < S; ++i) buffer << \", \" << v[i];\n buffer << \"]\";\n }\n\n return buffer.str();\n}\n\nnamespace Sass {\n\n\n template\n std::vector > paths(std::vector > strata, size_t from_end = 0)\n {\n if (strata.empty()) {\n return std::vector >();\n }\n\n size_t end = strata.size() - from_end;\n if (end <= 1) {\n std::vector > starting_points;\n starting_points.reserve(strata[0].size());\n for (size_t i = 0, S = strata[0].size(); i < S; ++i) {\n std::vector starting_point;\n starting_point.push_back(strata[0][i]);\n starting_points.push_back(starting_point);\n }\n return starting_points;\n }\n\n std::vector > up_to_here = paths(strata, from_end + 1);\n std::vector here = strata[end-1];\n\n std::vector > branches;\n branches.reserve(up_to_here.size() * here.size());\n for (size_t i = 0, S1 = up_to_here.size(); i < S1; ++i) {\n for (size_t j = 0, S2 = here.size(); j < S2; ++j) {\n std::vector branch = up_to_here[i];\n branch.push_back(here[j]);\n branches.push_back(branch);\n }\n }\n\n return branches;\n }\n\n}\n\n#endif\n" }, { "path": "libsass-build/plugins.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \"output.hpp\"\n#include \"plugins.hpp\"\n\n#ifdef _WIN32\n#include \n#else\n#include \n#include \n#include \n#include \n#endif\n\nnamespace Sass {\n\n Plugins::Plugins(void) { }\n Plugins::~Plugins(void)\n {\n for (auto function : functions) {\n sass_delete_function(function);\n }\n for (auto importer : importers) {\n sass_delete_importer(importer);\n }\n for (auto header : headers) {\n sass_delete_importer(header);\n }\n }\n\n // check if plugin is compatible with this version\n // plugins may be linked static against libsass\n // we try to be compatible between major versions\n inline bool compatibility(const char* their_version)\n {\n// const char* their_version = \"3.1.2\";\n // first check if anyone has an unknown version\n const char* our_version = libsass_version();\n if (!strcmp(their_version, \"[na]\")) return false;\n if (!strcmp(our_version, \"[na]\")) return false;\n\n // find the position of the second dot\n size_t pos = std::string(our_version).find('.', 0);\n if (pos != std::string::npos) pos = std::string(our_version).find('.', pos + 1);\n\n // if we do not have two dots we fallback to compare complete string\n if (pos == std::string::npos) { return strcmp(their_version, our_version) ? 0 : 1; }\n // otherwise only compare up to the second dot (major versions)\n else { return strncmp(their_version, our_version, pos) ? 0 : 1; }\n\n }\n\n // load one specific plugin\n bool Plugins::load_plugin (const std::string& path)\n {\n\n typedef const char* (*__plugin_version__)(void);\n typedef Sass_Function_List (*__plugin_load_fns__)(void);\n typedef Sass_Importer_List (*__plugin_load_imps__)(void);\n\n if (LOAD_LIB(plugin, path))\n {\n // try to load initial function to query libsass version suppor\n if (LOAD_LIB_FN(__plugin_version__, plugin_version, \"libsass_get_version\"))\n {\n // get the libsass version of the plugin\n if (!compatibility(plugin_version())) return false;\n // try to get import address for \"libsass_load_functions\"\n if (LOAD_LIB_FN(__plugin_load_fns__, plugin_load_functions, \"libsass_load_functions\"))\n {\n Sass_Function_List fns = plugin_load_functions(), _p = fns;\n while (fns && *fns) { functions.push_back(*fns); ++ fns; }\n sass_free_memory(_p); // only delete the container, items not yet\n }\n // try to get import address for \"libsass_load_importers\"\n if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_importers, \"libsass_load_importers\"))\n {\n Sass_Importer_List imps = plugin_load_importers(), _p = imps;\n while (imps && *imps) { importers.push_back(*imps); ++ imps; }\n sass_free_memory(_p); // only delete the container, items not yet\n }\n // try to get import address for \"libsass_load_headers\"\n if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_headers, \"libsass_load_headers\"))\n {\n Sass_Importer_List imps = plugin_load_headers(), _p = imps;\n while (imps && *imps) { headers.push_back(*imps); ++ imps; }\n sass_free_memory(_p); // only delete the container, items not yet\n }\n // success\n return true;\n }\n else\n {\n // print debug message to stderr (should not happen)\n std::cerr << \"failed loading 'libsass_support' in <\" << path << \">\" << std::endl;\n if (const char* dlsym_error = dlerror()) std::cerr << dlsym_error << std::endl;\n CLOSE_LIB(plugin);\n }\n }\n else\n {\n // print debug message to stderr (should not happen)\n std::cerr << \"failed loading plugin <\" << path << \">\" << std::endl;\n if (const char* dlopen_error = dlerror()) std::cerr << dlopen_error << std::endl;\n }\n\n return false;\n\n }\n\n size_t Plugins::load_plugins(const std::string& path)\n {\n\n // count plugins\n size_t loaded = 0;\n\n #ifdef _WIN32\n\n try\n {\n\n // use wchar (utf16)\n WIN32_FIND_DATAW data;\n // trailing slash is guaranteed\n std::string globsrch(path + \"*.dll\");\n // convert to wide chars (utf16) for system call\n std::wstring wglobsrch(UTF_8::convert_to_utf16(globsrch));\n HANDLE hFile = FindFirstFileW(wglobsrch.c_str(), &data);\n // check if system called returned a result\n // ToDo: maybe we should print a debug message\n if (hFile == INVALID_HANDLE_VALUE) return -1;\n\n // read directory\n while (true)\n {\n try\n {\n // the system will report the filenames with wide chars (utf16)\n std::string entry = UTF_8::convert_from_utf16(data.cFileName);\n // check if file ending matches exactly\n if (!ends_with(entry, \".dll\")) continue;\n // load the plugin and increase counter\n if (load_plugin(path + entry)) ++ loaded;\n // check if there should be more entries\n if (GetLastError() == ERROR_NO_MORE_FILES) break;\n // load next entry (check for return type)\n if (!FindNextFileW(hFile, &data)) break;\n }\n catch (...)\n {\n // report the error to the console (should not happen)\n // seems like we got strange data from the system call?\n std::cerr << \"filename in plugin path has invalid utf8?\" << std::endl;\n }\n }\n }\n catch (utf8::invalid_utf8)\n {\n // report the error to the console (should not happen)\n // implementors should make sure to provide valid utf8\n std::cerr << \"plugin path contains invalid utf8\" << std::endl;\n }\n\n #else\n\n DIR *dp;\n struct dirent *dirp;\n if((dp = opendir(path.c_str())) == NULL) return -1;\n while ((dirp = readdir(dp)) != NULL) {\n #if __APPLE__\n if (!ends_with(dirp->d_name, \".dylib\")) continue;\n #else\n if (!ends_with(dirp->d_name, \".so\")) continue;\n #endif\n if (load_plugin(path + dirp->d_name)) ++ loaded;\n }\n closedir(dp);\n\n #endif\n return loaded;\n\n }\n\n}\n" }, { "path": "libsass-build/plugins.hpp", "content": "#ifndef SASS_PLUGINS_H\n#define SASS_PLUGINS_H\n\n#include \n#include \n#include \"utf8_string.hpp\"\n#include \"sass/functions.h\"\n\n#ifdef _WIN32\n\n #define LOAD_LIB(var, path) HMODULE var = LoadLibraryW(UTF_8::convert_to_utf16(path).c_str())\n #define LOAD_LIB_WCHR(var, path_wide_str) HMODULE var = LoadLibraryW(path_wide_str.c_str())\n #define LOAD_LIB_FN(type, var, name) type var = (type) GetProcAddress(plugin, name)\n #define CLOSE_LIB(var) FreeLibrary(var)\n\n #ifndef dlerror\n #define dlerror() 0\n #endif\n\n#else\n\n #define LOAD_LIB(var, path) void* var = dlopen(path.c_str(), RTLD_LAZY)\n #define LOAD_LIB_FN(type, var, name) type var = (type) dlsym(plugin, name)\n #define CLOSE_LIB(var) dlclose(var)\n\n#endif\n\nnamespace Sass {\n\n\n class Plugins {\n\n public: // c-tor\n Plugins(void);\n ~Plugins(void);\n\n public: // methods\n // load one specific plugin\n bool load_plugin(const std::string& path);\n // load all plugins from a directory\n size_t load_plugins(const std::string& path);\n\n public: // public accessors\n const std::vector get_headers(void) { return headers; }\n const std::vector get_importers(void) { return importers; }\n const std::vector get_functions(void) { return functions; }\n\n private: // private vars\n std::vector headers;\n std::vector importers;\n std::vector functions;\n\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/position.cpp", "content": "#include \"sass.hpp\"\n#include \"position.hpp\"\n\nnamespace Sass {\n\n\n Offset::Offset(const char chr)\n : line(chr == '\\n' ? 1 : 0),\n column(chr == '\\n' ? 0 : 1)\n {}\n\n Offset::Offset(const char* string)\n : line(0), column(0)\n {\n *this = inc(string, string + strlen(string));\n }\n\n Offset::Offset(const std::string& text)\n : line(0), column(0)\n {\n *this = inc(text.c_str(), text.c_str() + text.size());\n }\n\n Offset::Offset(const size_t line, const size_t column)\n : line(line), column(column) { }\n\n // init/create instance from const char substring\n Offset Offset::init(const char* beg, const char* end)\n {\n Offset offset(0, 0);\n if (end == 0) {\n end += strlen(beg);\n }\n offset.add(beg, end);\n return offset;\n }\n\n // increase offset by given string (mostly called by lexer)\n // increase line counter and count columns on the last line\n Offset Offset::add(const char* begin, const char* end)\n {\n if (end == 0) return *this;\n while (begin < end && *begin) {\n if (*begin == '\\n') {\n ++ line;\n // start new line\n column = 0;\n } else {\n // do not count any utf8 continuation bytes\n // https://stackoverflow.com/a/9356203/1550314\n // https://en.wikipedia.org/wiki/UTF-8#Description\n unsigned char chr = *begin;\n // skip over 10xxxxxx\n // is 1st bit not set\n if ((chr & 128) == 0) {\n // regular ascii char\n column += 1;\n }\n // is 2nd bit not set\n else if ((chr & 64) == 0) {\n // first utf8 byte\n column += 1;\n }\n }\n ++ begin;\n }\n return *this;\n }\n\n // increase offset by given string (mostly called by lexer)\n // increase line counter and count columns on the last line\n Offset Offset::inc(const char* begin, const char* end) const\n {\n Offset offset(line, column);\n offset.add(begin, end);\n return offset;\n }\n\n bool Offset::operator== (const Offset &pos) const\n {\n return line == pos.line && column == pos.column;\n }\n\n bool Offset::operator!= (const Offset &pos) const\n {\n return line != pos.line || column != pos.column;\n }\n\n void Offset::operator+= (const Offset &off)\n {\n *this = Offset(line + off.line, off.line > 0 ? off.column : column + off.column);\n }\n\n Offset Offset::operator+ (const Offset &off) const\n {\n return Offset(line + off.line, off.line > 0 ? off.column : column + off.column);\n }\n\n Offset Offset::operator- (const Offset &off) const\n {\n return Offset(line - off.line, off.line == line ? column - off.column : column);\n }\n\n Position::Position(const size_t file)\n : Offset(0, 0), file(file) { }\n\n Position::Position(const size_t file, const Offset& offset)\n : Offset(offset), file(file) { }\n\n Position::Position(const size_t line, const size_t column)\n : Offset(line, column), file(-1) { }\n\n Position::Position(const size_t file, const size_t line, const size_t column)\n : Offset(line, column), file(file) { }\n\n\n ParserState::ParserState(const char* path, const char* src, const size_t file)\n : Position(file, 0, 0), path(path), src(src), offset(0, 0), token() { }\n\n ParserState::ParserState(const char* path, const char* src, const Position& position, Offset offset)\n : Position(position), path(path), src(src), offset(offset), token() { }\n\n ParserState::ParserState(const char* path, const char* src, const Token& token, const Position& position, Offset offset)\n : Position(position), path(path), src(src), offset(offset), token(token) { }\n\n Position Position::add(const char* begin, const char* end)\n {\n Offset::add(begin, end);\n return *this;\n }\n\n Position Position::inc(const char* begin, const char* end) const\n {\n Offset offset(line, column);\n offset = offset.inc(begin, end);\n return Position(file, offset);\n }\n\n bool Position::operator== (const Position &pos) const\n {\n return file == pos.file && line == pos.line && column == pos.column;\n }\n\n bool Position::operator!= (const Position &pos) const\n {\n return file == pos.file || line != pos.line || column != pos.column;\n }\n\n void Position::operator+= (const Offset &off)\n {\n *this = Position(file, line + off.line, off.line > 0 ? off.column : column + off.column);\n }\n\n const Position Position::operator+ (const Offset &off) const\n {\n return Position(file, line + off.line, off.line > 0 ? off.column : column + off.column);\n }\n\n const Offset Position::operator- (const Offset &off) const\n {\n return Offset(line - off.line, off.line == line ? column - off.column : column);\n }\n\n /* not used anymore - remove?\n std::ostream& operator<<(std::ostream& strm, const Offset& off)\n {\n if (off.line == string::npos) strm << \"-1:\"; else strm << off.line << \":\";\n if (off.column == string::npos) strm << \"-1\"; else strm << off.column;\n return strm;\n } */\n\n /* not used anymore - remove?\n std::ostream& operator<<(std::ostream& strm, const Position& pos)\n {\n if (pos.file != string::npos) strm << pos.file << \":\";\n if (pos.line == string::npos) strm << \"-1:\"; else strm << pos.line << \":\";\n if (pos.column == string::npos) strm << \"-1\"; else strm << pos.column;\n return strm;\n } */\n\n}\n" }, { "path": "libsass-build/position.hpp", "content": "#ifndef SASS_POSITION_H\n#define SASS_POSITION_H\n\n#include \n#include \n// #include \n\nnamespace Sass {\n\n\n class Offset {\n\n public: // c-tor\n Offset(const char chr);\n Offset(const char* string);\n Offset(const std::string& text);\n Offset(const size_t line, const size_t column);\n\n // return new position, incremented by the given string\n Offset add(const char* begin, const char* end);\n Offset inc(const char* begin, const char* end) const;\n\n // init/create instance from const char substring\n static Offset init(const char* beg, const char* end);\n\n public: // overload operators for position\n void operator+= (const Offset &pos);\n bool operator== (const Offset &pos) const;\n bool operator!= (const Offset &pos) const;\n Offset operator+ (const Offset &off) const;\n Offset operator- (const Offset &off) const;\n\n public: // overload output stream operator\n // friend std::ostream& operator<<(std::ostream& strm, const Offset& off);\n\n public:\n Offset off() { return *this; }\n\n public:\n size_t line;\n size_t column;\n\n };\n\n class Position : public Offset {\n\n public: // c-tor\n Position(const size_t file); // line(0), column(0)\n Position(const size_t file, const Offset& offset);\n Position(const size_t line, const size_t column); // file(-1)\n Position(const size_t file, const size_t line, const size_t column);\n\n public: // overload operators for position\n void operator+= (const Offset &off);\n bool operator== (const Position &pos) const;\n bool operator!= (const Position &pos) const;\n const Position operator+ (const Offset &off) const;\n const Offset operator- (const Offset &off) const;\n // return new position, incremented by the given string\n Position add(const char* begin, const char* end);\n Position inc(const char* begin, const char* end) const;\n\n public: // overload output stream operator\n // friend std::ostream& operator<<(std::ostream& strm, const Position& pos);\n\n public:\n size_t file;\n\n };\n\n // Token type for representing lexed chunks of text\n class Token {\n public:\n const char* prefix;\n const char* begin;\n const char* end;\n\n Token()\n : prefix(0), begin(0), end(0) { }\n Token(const char* b, const char* e)\n : prefix(b), begin(b), end(e) { }\n Token(const char* str)\n : prefix(str), begin(str), end(str + strlen(str)) { }\n Token(const char* p, const char* b, const char* e)\n : prefix(p), begin(b), end(e) { }\n\n size_t length() const { return end - begin; }\n std::string ws_before() const { return std::string(prefix, begin); }\n const std::string to_string() const { return std::string(begin, end); }\n std::string time_wspace() const {\n std::string str(to_string());\n std::string whitespaces(\" \\t\\f\\v\\n\\r\");\n return str.erase(str.find_last_not_of(whitespaces)+1);\n }\n\n operator bool() { return begin && end && begin >= end; }\n operator std::string() { return to_string(); }\n\n bool operator==(Token t) { return to_string() == t.to_string(); }\n };\n\n class ParserState : public Position {\n\n public: // c-tor\n ParserState(const char* path, const char* src = 0, const size_t file = std::string::npos);\n ParserState(const char* path, const char* src, const Position& position, Offset offset = Offset(0, 0));\n ParserState(const char* path, const char* src, const Token& token, const Position& position, Offset offset = Offset(0, 0));\n\n public: // down casts\n Offset off() { return *this; }\n Position pos() { return *this; }\n ParserState pstate() { return *this; }\n\n public:\n const char* path;\n const char* src;\n Offset offset;\n Token token;\n\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/prelexer.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n#include \n#include \"util.hpp\"\n#include \"position.hpp\"\n#include \"prelexer.hpp\"\n#include \"constants.hpp\"\n\n\nnamespace Sass {\n // using namespace Lexer;\n using namespace Constants;\n\n namespace Prelexer {\n\n\n /*\n\n def string_re(open, close)\n /#{open}((?:\\\\.|\\#(?!\\{)|[^#{close}\\\\#])*)(#{close}|#\\{)/m\n end\n end\n\n # A hash of regular expressions that are used for tokenizing strings.\n #\n # The key is a `[Symbol, Boolean]` pair.\n # The symbol represents which style of quotation to use,\n # while the boolean represents whether or not the string\n # is following an interpolated segment.\n STRING_REGULAR_EXPRESSIONS = {\n :double => {\n /#{open}((?:\\\\.|\\#(?!\\{)|[^#{close}\\\\#])*)(#{close}|#\\{)/m\n false => string_re('\"', '\"'),\n true => string_re('', '\"')\n },\n :single => {\n false => string_re(\"'\", \"'\"),\n true => string_re('', \"'\")\n },\n :uri => {\n false => /url\\(#{W}(#{URLCHAR}*?)(#{W}\\)|#\\{)/,\n true => /(#{URLCHAR}*?)(#{W}\\)|#\\{)/\n },\n # Defined in https://developer.mozilla.org/en/CSS/@-moz-document as a\n # non-standard version of http://www.w3.org/TR/css3-conditional/\n :url_prefix => {\n false => /url-prefix\\(#{W}(#{URLCHAR}*?)(#{W}\\)|#\\{)/,\n true => /(#{URLCHAR}*?)(#{W}\\)|#\\{)/\n },\n :domain => {\n false => /domain\\(#{W}(#{URLCHAR}*?)(#{W}\\)|#\\{)/,\n true => /(#{URLCHAR}*?)(#{W}\\)|#\\{)/\n }\n }\n */\n\n /*\n /#{open}\n (\n \\\\.\n |\n \\# (?!\\{)\n |\n [^#{close}\\\\#]\n )*\n (#{close}|#\\{)\n /m\n false => string_re('\"', '\"'),\n true => string_re('', '\"')\n */\n extern const char string_double_negates[] = \"\\\"\\\\#\";\n const char* re_string_double_close(const char* src)\n {\n return sequence <\n // valid chars\n zero_plus <\n alternatives <\n // escaped char\n sequence <\n exactly <'\\\\'>,\n any_char\n >,\n // non interpolate hash\n sequence <\n exactly <'#'>,\n negate <\n exactly <'{'>\n >\n >,\n // other valid chars\n neg_class_char <\n string_double_negates\n >\n >\n >,\n // quoted string closer\n // or interpolate opening\n alternatives <\n exactly <'\"'>,\n lookahead < exactly< hash_lbrace > >\n >\n >(src);\n }\n\n const char* re_string_double_open(const char* src)\n {\n return sequence <\n // quoted string opener\n exactly <'\"'>,\n // valid chars\n zero_plus <\n alternatives <\n // escaped char\n sequence <\n exactly <'\\\\'>,\n any_char\n >,\n // non interpolate hash\n sequence <\n exactly <'#'>,\n negate <\n exactly <'{'>\n >\n >,\n // other valid chars\n neg_class_char <\n string_double_negates\n >\n >\n >,\n // quoted string closer\n // or interpolate opening\n alternatives <\n exactly <'\"'>,\n lookahead < exactly< hash_lbrace > >\n >\n >(src);\n }\n\n extern const char string_single_negates[] = \"'\\\\#\";\n const char* re_string_single_close(const char* src)\n {\n return sequence <\n // valid chars\n zero_plus <\n alternatives <\n // escaped char\n sequence <\n exactly <'\\\\'>,\n any_char\n >,\n // non interpolate hash\n sequence <\n exactly <'#'>,\n negate <\n exactly <'{'>\n >\n >,\n // other valid chars\n neg_class_char <\n string_single_negates\n >\n >\n >,\n // quoted string closer\n // or interpolate opening\n alternatives <\n exactly <'\\''>,\n lookahead < exactly< hash_lbrace > >\n >\n >(src);\n }\n\n const char* re_string_single_open(const char* src)\n {\n return sequence <\n // quoted string opener\n exactly <'\\''>,\n // valid chars\n zero_plus <\n alternatives <\n // escaped char\n sequence <\n exactly <'\\\\'>,\n any_char\n >,\n // non interpolate hash\n sequence <\n exactly <'#'>,\n negate <\n exactly <'{'>\n >\n >,\n // other valid chars\n neg_class_char <\n string_single_negates\n >\n >\n >,\n // quoted string closer\n // or interpolate opening\n alternatives <\n exactly <'\\''>,\n lookahead < exactly< hash_lbrace > >\n >\n >(src);\n }\n\n /*\n :uri => {\n false => /url\\(#{W}(#{URLCHAR}*?)(#{W}\\)|#\\{)/,\n true => /(#{URLCHAR}*?)(#{W}\\)|#\\{)/\n },\n */\n const char* re_string_uri_close(const char* src)\n {\n return sequence <\n non_greedy<\n alternatives<\n class_char< real_uri_chars >,\n uri_character,\n NONASCII,\n ESCAPE\n >,\n alternatives<\n sequence < optional < W >, exactly <')'> >,\n lookahead < exactly< hash_lbrace > >\n >\n >,\n optional <\n sequence < optional < W >, exactly <')'> >\n >\n >(src);\n }\n\n const char* re_string_uri_open(const char* src)\n {\n return sequence <\n exactly <'u'>,\n exactly <'r'>,\n exactly <'l'>,\n exactly <'('>,\n W,\n alternatives<\n quoted_string,\n non_greedy<\n alternatives<\n class_char< real_uri_chars >,\n uri_character,\n NONASCII,\n ESCAPE\n >,\n alternatives<\n sequence < W, exactly <')'> >,\n exactly< hash_lbrace >\n >\n >\n >\n >(src);\n }\n\n // Match a line comment (/.*?(?=\\n|\\r\\n?|\\Z)/.\n const char* line_comment(const char* src)\n {\n return sequence<\n exactly <\n slash_slash\n >,\n non_greedy<\n any_char,\n end_of_line\n >\n >(src);\n }\n\n // Match a block comment.\n const char* block_comment(const char* src)\n {\n return sequence<\n delimited_by<\n slash_star,\n star_slash,\n false\n >\n >(src);\n }\n /* not use anymore - remove?\n const char* block_comment_prefix(const char* src) {\n return exactly(src);\n }\n // Match either comment.\n const char* comment(const char* src) {\n return line_comment(src);\n }\n */\n\n // Match zero plus white-space or line_comments\n const char* optional_css_whitespace(const char* src) {\n return zero_plus< alternatives >(src);\n }\n const char* css_whitespace(const char* src) {\n return one_plus< alternatives >(src);\n }\n // Match optional_css_whitepace plus block_comments\n const char* optional_css_comments(const char* src) {\n return zero_plus< alternatives >(src);\n }\n const char* css_comments(const char* src) {\n return one_plus< alternatives >(src);\n }\n\n // Match one backslash escaped char /\\\\./\n const char* escape_seq(const char* src)\n {\n return sequence<\n exactly<'\\\\'>,\n alternatives <\n minmax_range<\n 1, 3, xdigit\n >,\n any_char\n >,\n optional <\n exactly <' '>\n >\n >(src);\n }\n\n // Match identifier start\n const char* identifier_alpha(const char* src)\n {\n return alternatives<\n unicode_seq,\n alpha,\n unicode,\n exactly<'-'>,\n exactly<'_'>,\n NONASCII,\n ESCAPE,\n escape_seq\n >(src);\n }\n\n // Match identifier after start\n const char* identifier_alnum(const char* src)\n {\n return alternatives<\n unicode_seq,\n alnum,\n unicode,\n exactly<'-'>,\n exactly<'_'>,\n NONASCII,\n ESCAPE,\n escape_seq\n >(src);\n }\n\n // Match CSS identifiers.\n const char* strict_identifier(const char* src)\n {\n return sequence<\n one_plus < strict_identifier_alpha >,\n zero_plus < strict_identifier_alnum >\n // word_boundary not needed\n >(src);\n }\n\n // Match CSS identifiers.\n const char* identifier(const char* src)\n {\n return sequence<\n zero_plus< exactly<'-'> >,\n one_plus < identifier_alpha >,\n zero_plus < identifier_alnum >\n // word_boundary not needed\n >(src);\n }\n\n const char* strict_identifier_alpha(const char* src)\n {\n return alternatives <\n alpha,\n unicode,\n escape_seq,\n exactly<'_'>\n >(src);\n }\n\n const char* strict_identifier_alnum(const char* src)\n {\n return alternatives <\n alnum,\n unicode,\n escape_seq,\n exactly<'_'>\n >(src);\n }\n\n // Match a single CSS unit\n const char* one_unit(const char* src)\n {\n return sequence <\n optional < exactly <'-'> >,\n strict_identifier_alpha,\n zero_plus < alternatives<\n strict_identifier_alnum,\n sequence <\n one_plus < exactly<'-'> >,\n strict_identifier_alpha\n >\n > >\n >(src);\n }\n\n // Match numerator/denominator CSS units\n const char* multiple_units(const char* src)\n {\n return\n sequence <\n one_unit,\n zero_plus <\n sequence <\n exactly <'*'>,\n one_unit\n >\n >\n >(src);\n }\n\n // Match complex CSS unit identifiers\n const char* unit_identifier(const char* src)\n {\n return sequence <\n multiple_units,\n optional <\n sequence <\n exactly <'/'>,\n negate < sequence <\n exactly < calc_fn_kwd >,\n exactly < '(' >\n > >,\n multiple_units\n > >\n >(src);\n }\n\n const char* identifier_alnums(const char* src)\n {\n return one_plus< identifier_alnum >(src);\n }\n\n // Match number prefix ([\\+\\-]+)\n const char* number_prefix(const char* src) {\n return alternatives <\n exactly < '+' >,\n sequence <\n exactly < '-' >,\n optional_css_whitespace,\n exactly< '-' >\n >\n >(src);\n }\n\n // Match interpolant schemas\n const char* identifier_schema(const char* src) {\n\n return sequence <\n one_plus <\n sequence <\n zero_plus <\n alternatives <\n sequence <\n optional <\n exactly <'$'>\n >,\n identifier\n >,\n exactly <'-'>\n >\n >,\n interpolant,\n zero_plus <\n alternatives <\n digits,\n sequence <\n optional <\n exactly <'$'>\n >,\n identifier\n >,\n quoted_string,\n exactly<'-'>\n >\n >\n >\n >,\n negate <\n exactly<'%'>\n >\n > (src);\n }\n\n // interpolants can be recursive/nested\n const char* interpolant(const char* src) {\n return recursive_scopes< exactly, exactly >(src);\n }\n\n // $re_squote = /'(?:$re_itplnt|\\\\.|[^'])*'/\n const char* single_quoted_string(const char* src) {\n // match a single quoted string, while skipping interpolants\n return sequence <\n exactly <'\\''>,\n zero_plus <\n alternatives <\n // skip escapes\n sequence <\n exactly < '\\\\' >,\n re_linebreak\n >,\n escape_seq,\n unicode_seq,\n // skip interpolants\n interpolant,\n // skip non delimiters\n any_char_but < '\\'' >\n >\n >,\n exactly <'\\''>\n >(src);\n }\n\n // $re_dquote = /\"(?:$re_itp|\\\\.|[^\"])*\"/\n const char* double_quoted_string(const char* src) {\n // match a single quoted string, while skipping interpolants\n return sequence <\n exactly <'\"'>,\n zero_plus <\n alternatives <\n // skip escapes\n sequence <\n exactly < '\\\\' >,\n re_linebreak\n >,\n escape_seq,\n unicode_seq,\n // skip interpolants\n interpolant,\n // skip non delimiters\n any_char_but < '\"' >\n >\n >,\n exactly <'\"'>\n >(src);\n }\n\n // $re_quoted = /(?:$re_squote|$re_dquote)/\n const char* quoted_string(const char* src) {\n // match a quoted string, while skipping interpolants\n return alternatives<\n single_quoted_string,\n double_quoted_string\n >(src);\n }\n\n const char* sass_value(const char* src) {\n return alternatives <\n quoted_string,\n identifier,\n percentage,\n hex,\n dimension,\n number\n >(src);\n }\n\n // this is basically `one_plus < sass_value >`\n // takes care to not parse invalid combinations\n const char* value_combinations(const char* src) {\n // `2px-2px` is invalid combo\n bool was_number = false;\n const char* pos;\n while (src) {\n if ((pos = alternatives < quoted_string, identifier, percentage, hex >(src))) {\n was_number = false;\n src = pos;\n } else if (!was_number && !exactly<'+'>(src) && (pos = alternatives < dimension, number >(src))) {\n was_number = true;\n src = pos;\n } else {\n break;\n }\n }\n return src;\n }\n\n // must be at least one interpolant\n // can be surrounded by sass values\n // make sure to never parse (dim)(dim)\n // since this wrongly consumes `2px-1px`\n // `2px1px` is valid number (unit `px1px`)\n const char* value_schema(const char* src)\n {\n return sequence <\n one_plus <\n sequence <\n optional < value_combinations >,\n interpolant,\n optional < value_combinations >\n >\n >\n >(src);\n }\n\n // Match CSS '@' keywords.\n const char* at_keyword(const char* src) {\n return sequence, identifier>(src);\n }\n\n /*\n tok(%r{\n (\n \\\\.\n |\n (?!url\\()\n [^\"'/\\#!;\\{\\}] # \"\n |\n /(?![\\*\\/])\n |\n \\#(?!\\{)\n |\n !(?![a-z]) # TODO: never consume \"!\" when issue 1126 is fixed.\n )+\n }xi) || tok(COMMENT) || tok(SINGLE_LINE_COMMENT) || interp_string || interp_uri ||\n interpolation(:warn_for_color)\n */\n const char* re_almost_any_value_token(const char* src) {\n\n return alternatives <\n one_plus <\n alternatives <\n sequence <\n exactly <'\\\\'>,\n any_char\n >,\n sequence <\n negate <\n uri_prefix\n >,\n neg_class_char <\n almost_any_value_class\n >\n >,\n sequence <\n exactly <'/'>,\n negate <\n alternatives <\n exactly <'/'>,\n exactly <'*'>\n >\n >\n >,\n sequence <\n exactly <'\\\\'>,\n exactly <'#'>,\n negate <\n exactly <'{'>\n >\n >,\n sequence <\n exactly <'!'>,\n negate <\n alpha\n >\n >\n >\n >,\n block_comment,\n line_comment,\n interpolant,\n space,\n sequence <\n exactly<'u'>,\n exactly<'r'>,\n exactly<'l'>,\n exactly<'('>,\n zero_plus <\n alternatives <\n class_char< real_uri_chars >,\n uri_character,\n NONASCII,\n ESCAPE\n >\n >,\n // false => /url\\(#{W}(#{URLCHAR}*?)(#{W}\\)|#\\{)/,\n // true => /(#{URLCHAR}*?)(#{W}\\)|#\\{)/\n exactly<')'>\n >\n >(src);\n }\n\n /*\n DIRECTIVES = Set[:mixin, :include, :function, :return, :debug, :warn, :for,\n :each, :while, :if, :else, :extend, :import, :media, :charset, :content,\n :_moz_document, :at_root, :error]\n */\n const char* re_special_directive(const char* src) {\n return alternatives <\n word < mixin_kwd >,\n word < include_kwd >,\n word < function_kwd >,\n word < return_kwd >,\n word < debug_kwd >,\n word < warn_kwd >,\n word < for_kwd >,\n word < each_kwd >,\n word < while_kwd >,\n word < if_kwd >,\n word < else_kwd >,\n word < extend_kwd >,\n word < import_kwd >,\n word < media_kwd >,\n word < charset_kwd >,\n word < content_kwd >,\n // exactly < moz_document_kwd >,\n word < at_root_kwd >,\n word < error_kwd >\n >(src);\n }\n\n const char* re_prefixed_directive(const char* src) {\n return sequence <\n optional <\n sequence <\n exactly <'-'>,\n one_plus < alnum >,\n exactly <'-'>\n >\n >,\n exactly < supports_kwd >\n >(src);\n }\n\n const char* re_reference_combinator(const char* src) {\n return sequence <\n optional <\n sequence <\n zero_plus <\n exactly <'-'>\n >,\n identifier,\n exactly <'|'>\n >\n >,\n zero_plus <\n exactly <'-'>\n >,\n identifier\n >(src);\n }\n\n const char* static_reference_combinator(const char* src) {\n return sequence <\n exactly <'/'>,\n re_reference_combinator,\n exactly <'/'>\n >(src);\n }\n\n const char* schema_reference_combinator(const char* src) {\n return sequence <\n exactly <'/'>,\n optional <\n sequence <\n css_ip_identifier,\n exactly <'|'>\n >\n >,\n css_ip_identifier,\n exactly <'/'>\n > (src);\n }\n\n const char* kwd_import(const char* src) {\n return word(src);\n }\n\n const char* kwd_at_root(const char* src) {\n return word(src);\n }\n\n const char* kwd_with_directive(const char* src) {\n return word(src);\n }\n\n const char* kwd_without_directive(const char* src) {\n return word(src);\n }\n\n const char* kwd_media(const char* src) {\n return word(src);\n }\n\n const char* kwd_supports_directive(const char* src) {\n return word(src);\n }\n\n const char* kwd_mixin(const char* src) {\n return word(src);\n }\n\n const char* kwd_function(const char* src) {\n return word(src);\n }\n\n const char* kwd_return_directive(const char* src) {\n return word(src);\n }\n\n const char* kwd_include_directive(const char* src) {\n return word(src);\n }\n\n const char* kwd_content_directive(const char* src) {\n return word(src);\n }\n\n const char* kwd_charset_directive(const char* src) {\n return word(src);\n }\n\n const char* kwd_extend(const char* src) {\n return word(src);\n }\n\n\n const char* kwd_if_directive(const char* src) {\n return word(src);\n }\n\n const char* kwd_else_directive(const char* src) {\n return word(src);\n }\n const char* elseif_directive(const char* src) {\n return sequence< exactly< else_kwd >,\n optional_css_comments,\n word< if_after_else_kwd > >(src);\n }\n\n const char* kwd_for_directive(const char* src) {\n return word(src);\n }\n\n const char* kwd_from(const char* src) {\n return word(src);\n }\n\n const char* kwd_to(const char* src) {\n return word(src);\n }\n\n const char* kwd_through(const char* src) {\n return word(src);\n }\n\n const char* kwd_each_directive(const char* src) {\n return word(src);\n }\n\n const char* kwd_in(const char* src) {\n return word(src);\n }\n\n const char* kwd_while_directive(const char* src) {\n return word(src);\n }\n\n const char* name(const char* src) {\n return one_plus< alternatives< alnum,\n exactly<'-'>,\n exactly<'_'>,\n escape_seq > >(src);\n }\n\n const char* kwd_warn(const char* src) {\n return word(src);\n }\n\n const char* kwd_err(const char* src) {\n return word(src);\n }\n\n const char* kwd_dbg(const char* src) {\n return word(src);\n }\n\n /* not used anymore - remove?\n const char* directive(const char* src) {\n return sequence< exactly<'@'>, identifier >(src);\n } */\n\n const char* kwd_null(const char* src) {\n return word(src);\n }\n\n const char* css_identifier(const char* src) {\n return sequence <\n zero_plus <\n exactly <'-'>\n >,\n identifier\n >(src);\n }\n\n const char* css_ip_identifier(const char* src) {\n return sequence <\n zero_plus <\n exactly <'-'>\n >,\n alternatives <\n identifier,\n interpolant\n >\n >(src);\n }\n\n // Match CSS type selectors\n const char* namespace_prefix(const char* src) {\n return sequence <\n optional <\n alternatives <\n exactly <'*'>,\n css_identifier\n >\n >,\n exactly <'|'>,\n negate <\n exactly <'='>\n >\n >(src);\n }\n\n // Match CSS type selectors\n const char* namespace_schema(const char* src) {\n return sequence <\n optional <\n alternatives <\n exactly <'*'>,\n css_ip_identifier\n >\n >,\n exactly<'|'>,\n negate <\n exactly <'='>\n >\n >(src);\n }\n\n const char* hyphens_and_identifier(const char* src) {\n return sequence< zero_plus< exactly< '-' > >, identifier_alnums >(src);\n }\n const char* hyphens_and_name(const char* src) {\n return sequence< zero_plus< exactly< '-' > >, name >(src);\n }\n const char* universal(const char* src) {\n return sequence< optional, exactly<'*'> >(src);\n }\n // Match CSS id names.\n const char* id_name(const char* src) {\n return sequence, identifier_alnums >(src);\n }\n // Match CSS class names.\n const char* class_name(const char* src) {\n return sequence, identifier >(src);\n }\n // Attribute name in an attribute selector.\n const char* attribute_name(const char* src) {\n return alternatives< sequence< optional, identifier>,\n identifier >(src);\n }\n // match placeholder selectors\n const char* placeholder(const char* src) {\n return sequence, identifier_alnums >(src);\n }\n // Match CSS numeric constants.\n\n const char* op(const char* src) {\n return class_char(src);\n }\n const char* sign(const char* src) {\n return class_char(src);\n }\n const char* unsigned_number(const char* src) {\n return alternatives,\n exactly<'.'>,\n one_plus >,\n digits>(src);\n }\n const char* number(const char* src) {\n return sequence<\n optional,\n unsigned_number,\n optional<\n sequence<\n exactly<'e'>,\n optional,\n unsigned_number\n >\n >\n >(src);\n }\n const char* coefficient(const char* src) {\n return alternatives< sequence< optional, digits >,\n sign >(src);\n }\n const char* binomial(const char* src) {\n return sequence <\n optional < sign >,\n optional < digits >,\n exactly <'n'>,\n zero_plus < sequence <\n optional_css_whitespace, sign,\n optional_css_whitespace, digits\n > >\n >(src);\n }\n const char* percentage(const char* src) {\n return sequence< number, exactly<'%'> >(src);\n }\n const char* ampersand(const char* src) {\n return exactly<'&'>(src);\n }\n\n /* not used anymore - remove?\n const char* em(const char* src) {\n return sequence< number, exactly >(src);\n } */\n const char* dimension(const char* src) {\n return sequence(src);\n }\n const char* hex(const char* src) {\n const char* p = sequence< exactly<'#'>, one_plus >(src);\n ptrdiff_t len = p - src;\n return (len != 4 && len != 7) ? 0 : p;\n }\n const char* hexa(const char* src) {\n const char* p = sequence< exactly<'#'>, one_plus >(src);\n ptrdiff_t len = p - src;\n return (len != 5 && len != 9) ? 0 : p;\n }\n const char* hex0(const char* src) {\n const char* p = sequence< exactly<'0'>, exactly<'x'>, one_plus >(src);\n ptrdiff_t len = p - src;\n return (len != 5 && len != 8) ? 0 : p;\n }\n\n /* no longer used - remove?\n const char* rgb_prefix(const char* src) {\n return word(src);\n }*/\n // Match CSS uri specifiers.\n\n const char* uri_prefix(const char* src) {\n return sequence <\n exactly <\n url_kwd\n >,\n zero_plus <\n sequence <\n exactly <'-'>,\n one_plus <\n alpha\n >\n >\n >,\n exactly <'('>\n >(src);\n }\n\n // TODO: rename the following two functions\n /* no longer used - remove?\n const char* uri(const char* src) {\n return sequence< exactly,\n optional,\n quoted_string,\n optional,\n exactly<')'> >(src);\n }*/\n /* no longer used - remove?\n const char* url_value(const char* src) {\n return sequence< optional< sequence< identifier, exactly<':'> > >, // optional protocol\n one_plus< sequence< zero_plus< exactly<'/'> >, filename > >, // one or more folders and/or trailing filename\n optional< exactly<'/'> > >(src);\n }*/\n /* no longer used - remove?\n const char* url_schema(const char* src) {\n return sequence< optional< sequence< identifier, exactly<':'> > >, // optional protocol\n filename_schema >(src); // optional trailing slash\n }*/\n // Match CSS \"!important\" keyword.\n const char* kwd_important(const char* src) {\n return sequence< exactly<'!'>,\n optional_css_whitespace,\n word >(src);\n }\n // Match CSS \"!optional\" keyword.\n const char* kwd_optional(const char* src) {\n return sequence< exactly<'!'>,\n optional_css_whitespace,\n word >(src);\n }\n // Match Sass \"!default\" keyword.\n const char* default_flag(const char* src) {\n return sequence< exactly<'!'>,\n optional_css_whitespace,\n word >(src);\n }\n // Match Sass \"!global\" keyword.\n const char* global_flag(const char* src) {\n return sequence< exactly<'!'>,\n optional_css_whitespace,\n word >(src);\n }\n // Match CSS pseudo-class/element prefixes.\n const char* pseudo_prefix(const char* src) {\n return sequence< exactly<':'>, optional< exactly<':'> > >(src);\n }\n // Match CSS function call openers.\n const char* functional_schema(const char* src) {\n return sequence <\n one_plus <\n sequence <\n zero_plus <\n alternatives <\n identifier,\n exactly <'-'>\n >\n >,\n one_plus <\n sequence <\n interpolant,\n alternatives <\n digits,\n identifier,\n exactly<'+'>,\n exactly<'-'>\n >\n >\n >\n >\n >,\n negate <\n exactly <'%'>\n >,\n lookahead <\n exactly <'('>\n >\n > (src);\n }\n\n const char* re_nothing(const char* src) {\n return src;\n }\n\n const char* re_functional(const char* src) {\n return sequence< identifier, optional < block_comment >, exactly<'('> >(src);\n }\n const char* re_pseudo_selector(const char* src) {\n return sequence< identifier, optional < block_comment >, exactly<'('> >(src);\n }\n // Match the CSS negation pseudo-class.\n const char* pseudo_not(const char* src) {\n return word< pseudo_not_fn_kwd >(src);\n }\n // Match CSS 'odd' and 'even' keywords for functional pseudo-classes.\n const char* even(const char* src) {\n return word(src);\n }\n const char* odd(const char* src) {\n return word(src);\n }\n // Match CSS attribute-matching operators.\n const char* exact_match(const char* src) { return exactly<'='>(src); }\n const char* class_match(const char* src) { return exactly(src); }\n const char* dash_match(const char* src) { return exactly(src); }\n const char* prefix_match(const char* src) { return exactly(src); }\n const char* suffix_match(const char* src) { return exactly(src); }\n const char* substring_match(const char* src) { return exactly(src); }\n // Match CSS combinators.\n /* not used anymore - remove?\n const char* adjacent_to(const char* src) {\n return sequence< optional_spaces, exactly<'+'> >(src);\n }\n const char* precedes(const char* src) {\n return sequence< optional_spaces, exactly<'~'> >(src);\n }\n const char* parent_of(const char* src) {\n return sequence< optional_spaces, exactly<'>'> >(src);\n }\n const char* ancestor_of(const char* src) {\n return sequence< spaces, negate< exactly<'{'> > >(src);\n }*/\n\n // Match SCSS variable names.\n const char* variable(const char* src) {\n return sequence, identifier>(src);\n }\n\n // parse `calc`, `-a-calc` and `--b-c-calc`\n // but do not parse `foocalc` or `foo-calc`\n const char* calc_fn_call(const char* src) {\n return sequence <\n optional < sequence <\n hyphens,\n one_plus < sequence <\n strict_identifier,\n hyphens\n > >\n > >,\n exactly < calc_fn_kwd >,\n word_boundary\n >(src);\n }\n\n // Match Sass boolean keywords.\n const char* kwd_true(const char* src) {\n return word(src);\n }\n const char* kwd_false(const char* src) {\n return word(src);\n }\n const char* kwd_only(const char* src) {\n return keyword < only_kwd >(src);\n }\n const char* kwd_and(const char* src) {\n return keyword < and_kwd >(src);\n }\n const char* kwd_or(const char* src) {\n return keyword < or_kwd >(src);\n }\n const char* kwd_not(const char* src) {\n return keyword < not_kwd >(src);\n }\n const char* kwd_eq(const char* src) {\n return exactly(src);\n }\n const char* kwd_neq(const char* src) {\n return exactly(src);\n }\n const char* kwd_gt(const char* src) {\n return exactly(src);\n }\n const char* kwd_gte(const char* src) {\n return exactly(src);\n }\n const char* kwd_lt(const char* src) {\n return exactly(src);\n }\n const char* kwd_lte(const char* src) {\n return exactly(src);\n }\n\n // match specific IE syntax\n const char* ie_progid(const char* src) {\n return sequence <\n word,\n exactly<':'>,\n alternatives< identifier_schema, identifier >,\n zero_plus< sequence<\n exactly<'.'>,\n alternatives< identifier_schema, identifier >\n > >,\n zero_plus < sequence<\n exactly<'('>,\n optional_css_whitespace,\n optional < sequence<\n alternatives< variable, identifier_schema, identifier >,\n optional_css_whitespace,\n exactly<'='>,\n optional_css_whitespace,\n alternatives< variable, identifier_schema, identifier, quoted_string, number, hex, hexa >,\n zero_plus< sequence<\n optional_css_whitespace,\n exactly<','>,\n optional_css_whitespace,\n sequence<\n alternatives< variable, identifier_schema, identifier >,\n optional_css_whitespace,\n exactly<'='>,\n optional_css_whitespace,\n alternatives< variable, identifier_schema, identifier, quoted_string, number, hex, hexa >\n >\n > >\n > >,\n optional_css_whitespace,\n exactly<')'>\n > >\n >(src);\n }\n const char* ie_expression(const char* src) {\n return sequence < word, exactly<'('>, skip_over_scopes< exactly<'('>, exactly<')'> > >(src);\n }\n const char* ie_property(const char* src) {\n return alternatives < ie_expression, ie_progid >(src);\n }\n\n // const char* ie_args(const char* src) {\n // return sequence< alternatives< ie_keyword_arg, value_schema, quoted_string, interpolant, number, identifier, delimited_by< '(', ')', true> >,\n // zero_plus< sequence< optional_css_whitespace, exactly<','>, optional_css_whitespace, alternatives< ie_keyword_arg, value_schema, quoted_string, interpolant, number, identifier, delimited_by<'(', ')', true> > > > >(src);\n // }\n\n const char* ie_keyword_arg_property(const char* src) {\n return alternatives <\n variable,\n identifier_schema,\n identifier\n >(src);\n }\n const char* ie_keyword_arg_value(const char* src) {\n return alternatives <\n variable,\n identifier_schema,\n identifier,\n quoted_string,\n number,\n hex,\n hexa,\n sequence <\n exactly < '(' >,\n skip_over_scopes <\n exactly < '(' >,\n exactly < ')' >\n >\n >\n >(src);\n }\n\n const char* ie_keyword_arg(const char* src) {\n return sequence <\n ie_keyword_arg_property,\n optional_css_whitespace,\n exactly<'='>,\n optional_css_whitespace,\n ie_keyword_arg_value\n >(src);\n }\n\n // Path matching functions.\n /* not used anymore - remove?\n const char* folder(const char* src) {\n return sequence< zero_plus< any_char_except<'/'> >,\n exactly<'/'> >(src);\n }\n const char* folders(const char* src) {\n return zero_plus< folder >(src);\n }*/\n /* not used anymore - remove?\n const char* chunk(const char* src) {\n char inside_str = 0;\n const char* p = src;\n size_t depth = 0;\n while (true) {\n if (!*p) {\n return 0;\n }\n else if (!inside_str && (*p == '\"' || *p == '\\'')) {\n inside_str = *p;\n }\n else if (*p == inside_str && *(p-1) != '\\\\') {\n inside_str = 0;\n }\n else if (*p == '(' && !inside_str) {\n ++depth;\n }\n else if (*p == ')' && !inside_str) {\n if (depth == 0) return p;\n else --depth;\n }\n ++p;\n }\n // unreachable\n return 0;\n }\n */\n\n // follow the CSS spec more closely and see if this helps us scan URLs correctly\n /* not used anymore - remove?\n const char* NL(const char* src) {\n return alternatives< exactly<'\\n'>,\n sequence< exactly<'\\r'>, exactly<'\\n'> >,\n exactly<'\\r'>,\n exactly<'\\f'> >(src);\n }*/\n\n const char* H(const char* src) {\n return std::isxdigit(*src) ? src+1 : 0;\n }\n\n const char* W(const char* src) {\n return zero_plus< alternatives<\n space,\n exactly< '\\t' >,\n exactly< '\\r' >,\n exactly< '\\n' >,\n exactly< '\\f' >\n > >(src);\n }\n\n const char* UUNICODE(const char* src) {\n return sequence< exactly<'\\\\'>,\n between,\n optional< W >\n >(src);\n }\n\n const char* NONASCII(const char* src) {\n return nonascii(src);\n }\n\n const char* ESCAPE(const char* src) {\n return alternatives<\n UUNICODE,\n sequence<\n exactly<'\\\\'>,\n alternatives<\n NONASCII,\n escapable_character\n >\n >\n >(src);\n }\n\n const char* list_terminator(const char* src) {\n return alternatives <\n exactly<';'>,\n exactly<'}'>,\n exactly<'{'>,\n exactly<')'>,\n exactly<']'>,\n exactly<':'>,\n end_of_file,\n exactly,\n default_flag,\n global_flag\n >(src);\n };\n\n const char* space_list_terminator(const char* src) {\n return alternatives <\n exactly<','>,\n list_terminator\n >(src);\n };\n\n\n // const char* real_uri_prefix(const char* src) {\n // return alternatives<\n // exactly< url_kwd >,\n // exactly< url_prefix_kwd >\n // >(src);\n // }\n\n const char* real_uri(const char* src) {\n return sequence<\n exactly< url_kwd >,\n exactly< '(' >,\n W,\n real_uri_value,\n exactly< ')' >\n >(src);\n }\n\n const char* real_uri_suffix(const char* src) {\n return sequence< W, exactly< ')' > >(src);\n }\n\n const char* real_uri_value(const char* src) {\n return\n sequence<\n non_greedy<\n alternatives<\n class_char< real_uri_chars >,\n uri_character,\n NONASCII,\n ESCAPE\n >,\n alternatives<\n real_uri_suffix,\n exactly< hash_lbrace >\n >\n >\n >\n (src);\n }\n\n const char* static_string(const char* src) {\n const char* pos = src;\n const char * s = quoted_string(pos);\n Token t(pos, s);\n const unsigned int p = count_interval< interpolant >(t.begin, t.end);\n return (p == 0) ? t.end : 0;\n }\n\n const char* unicode_seq(const char* src) {\n return sequence <\n alternatives <\n exactly< 'U' >,\n exactly< 'u' >\n >,\n exactly< '+' >,\n padded_token <\n 6, xdigit,\n exactly < '?' >\n >\n >(src);\n }\n\n const char* static_component(const char* src) {\n return alternatives< identifier,\n static_string,\n percentage,\n hex,\n hexa,\n exactly<'|'>,\n // exactly<'+'>,\n sequence < number, unit_identifier >,\n number,\n sequence< exactly<'!'>, word >\n >(src);\n }\n\n const char* static_property(const char* src) {\n return\n sequence <\n zero_plus<\n sequence <\n optional_css_comments,\n alternatives <\n exactly<','>,\n exactly<'('>,\n exactly<')'>,\n kwd_optional,\n quoted_string,\n interpolant,\n identifier,\n percentage,\n dimension,\n variable,\n alnum,\n sequence <\n exactly <'\\\\'>,\n any_char\n >\n >\n >\n >,\n lookahead <\n sequence <\n optional_css_comments,\n alternatives <\n exactly <';'>,\n exactly <'}'>,\n end_of_file\n >\n >\n >\n >(src);\n }\n\n const char* static_value(const char* src) {\n return sequence< sequence<\n static_component,\n zero_plus< identifier >\n >,\n zero_plus < sequence<\n alternatives<\n sequence< optional_spaces, alternatives<\n exactly < '/' >,\n exactly < ',' >,\n exactly < ' ' >\n >, optional_spaces >,\n spaces\n >,\n static_component\n > >,\n zero_plus < spaces >,\n alternatives< exactly<';'>, exactly<'}'> >\n >(src);\n }\n\n extern const char css_variable_url_negates[] = \"()[]{}\\\"'#/\";\n const char* css_variable_value(const char* src) {\n return sequence<\n alternatives<\n sequence<\n negate< exactly< url_fn_kwd > >,\n one_plus< neg_class_char< css_variable_url_negates > >\n >,\n sequence< exactly<'#'>, negate< exactly<'{'> > >,\n sequence< exactly<'/'>, negate< exactly<'*'> > >,\n static_string,\n real_uri,\n block_comment\n >\n >(src);\n }\n\n extern const char css_variable_url_top_level_negates[] = \"()[]{}\\\"'#/;\";\n const char* css_variable_top_level_value(const char* src) {\n return sequence<\n alternatives<\n sequence<\n negate< exactly< url_fn_kwd > >,\n one_plus< neg_class_char< css_variable_url_top_level_negates > >\n >,\n sequence< exactly<'#'>, negate< exactly<'{'> > >,\n sequence< exactly<'/'>, negate< exactly<'*'> > >,\n static_string,\n real_uri,\n block_comment\n >\n >(src);\n }\n\n const char* parenthese_scope(const char* src) {\n return sequence <\n exactly < '(' >,\n skip_over_scopes <\n exactly < '(' >,\n exactly < ')' >\n >\n >(src);\n }\n\n const char* re_selector_list(const char* src) {\n return alternatives <\n // partial bem selector\n sequence <\n ampersand,\n one_plus <\n exactly < '-' >\n >,\n word_boundary,\n optional_spaces\n >,\n // main selector matching\n one_plus <\n alternatives <\n // consume whitespace and comments\n spaces, block_comment, line_comment,\n // match `/deep/` selector (pass-trough)\n // there is no functionality for it yet\n schema_reference_combinator,\n // match selector ops /[*&%,\\[\\]]/\n class_char < selector_lookahead_ops >,\n // match selector combinators /[>+~]/\n class_char < selector_combinator_ops >,\n // match pseudo selectors\n sequence <\n exactly <'('>,\n optional_spaces,\n optional ,\n optional_spaces,\n exactly <')'>\n >,\n // match attribute compare operators\n alternatives <\n exact_match, class_match, dash_match,\n prefix_match, suffix_match, substring_match\n >,\n // main selector match\n sequence <\n // allow namespace prefix\n optional < namespace_schema >,\n // modifiers prefixes\n alternatives <\n sequence <\n exactly <'#'>,\n // not for interpolation\n negate < exactly <'{'> >\n >,\n // class match\n exactly <'.'>,\n // single or double colon\n sequence <\n optional < pseudo_prefix >,\n // fix libsass issue 2376\n negate < uri_prefix >\n >\n >,\n // accept hypens in token\n one_plus < sequence <\n // can start with hyphens\n zero_plus <\n sequence <\n exactly <'-'>,\n optional_spaces\n >\n >,\n // now the main token\n alternatives <\n kwd_optional,\n exactly <'*'>,\n quoted_string,\n interpolant,\n identifier,\n variable,\n percentage,\n binomial,\n dimension,\n alnum\n >\n > >,\n // can also end with hyphens\n zero_plus < exactly<'-'> >\n >\n >\n >\n >(src);\n }\n\n const char* type_selector(const char* src) {\n return sequence< optional, identifier>(src);\n }\n const char* re_type_selector(const char* src) {\n return alternatives< type_selector, universal, dimension, percentage, number, identifier_alnums >(src);\n }\n const char* re_static_expression(const char* src) {\n return sequence< number, optional_spaces, exactly<'/'>, optional_spaces, number >(src);\n }\n\n // lexer special_fn: these functions cannot be overloaded\n // (/((-[\\w-]+-)?(calc|element)|expression|progid:[a-z\\.]*)\\(/i)\n const char* re_special_fun(const char* src) {\n\n // match this first as we test prefix hyphens\n if (const char* calc = calc_fn_call(src)) {\n return calc;\n }\n\n return sequence <\n optional <\n sequence <\n exactly <'-'>,\n one_plus <\n alternatives <\n alpha,\n exactly <'+'>,\n exactly <'-'>\n >\n >\n >\n >,\n alternatives <\n word < expression_kwd >,\n sequence <\n sequence <\n exactly < progid_kwd >,\n exactly <':'>\n >,\n zero_plus <\n alternatives <\n char_range <'a', 'z'>,\n exactly <'.'>\n >\n >\n >\n >\n >(src);\n }\n\n }\n}\n" }, { "path": "libsass-build/prelexer.hpp", "content": "#ifndef SASS_PRELEXER_H\n#define SASS_PRELEXER_H\n\n#include \n#include \"lexer.hpp\"\n\nnamespace Sass {\n // using namespace Lexer;\n namespace Prelexer {\n\n //####################################\n // KEYWORD \"REGEX\" MATCHERS\n //####################################\n\n // Match Sass boolean keywords.\n const char* kwd_true(const char* src);\n const char* kwd_false(const char* src);\n const char* kwd_only(const char* src);\n const char* kwd_and(const char* src);\n const char* kwd_or(const char* src);\n const char* kwd_not(const char* src);\n const char* kwd_eq(const char* src);\n const char* kwd_neq(const char* src);\n const char* kwd_gt(const char* src);\n const char* kwd_gte(const char* src);\n const char* kwd_lt(const char* src);\n const char* kwd_lte(const char* src);\n\n // Match standard control chars\n const char* kwd_at(const char* src);\n const char* kwd_dot(const char* src);\n const char* kwd_comma(const char* src);\n const char* kwd_colon(const char* src);\n const char* kwd_slash(const char* src);\n const char* kwd_star(const char* src);\n const char* kwd_plus(const char* src);\n const char* kwd_minus(const char* src);\n\n //####################################\n // SPECIAL \"REGEX\" CONSTRUCTS\n //####################################\n\n // Match a sequence of characters delimited by the supplied chars.\n template \n const char* delimited_by(const char* src) {\n src = exactly(src);\n if (!src) return 0;\n const char* stop;\n while (true) {\n if (!*src) return 0;\n stop = exactly(src);\n if (stop && (!esc || *(src - 1) != '\\\\')) return stop;\n src = stop ? stop : src + 1;\n }\n }\n\n // skip to delimiter (mx) inside given range\n // this will savely skip over all quoted strings\n // recursive skip stuff delimited by start/stop\n // first start/opener must be consumed already!\n template\n const char* skip_over_scopes(const char* src, const char* end) {\n\n size_t level = 0;\n bool in_squote = false;\n bool in_dquote = false;\n // bool in_braces = false;\n\n while (*src) {\n\n // check for abort condition\n if (end && src >= end) break;\n\n // has escaped sequence?\n if (*src == '\\\\') {\n ++ src; // skip this (and next)\n }\n else if (*src == '\"') {\n in_dquote = ! in_dquote;\n }\n else if (*src == '\\'') {\n in_squote = ! in_squote;\n }\n else if (in_dquote || in_squote) {\n // take everything literally\n }\n\n // find another opener inside?\n else if (const char* pos = start(src)) {\n ++ level; // increase counter\n src = pos - 1; // advance position\n }\n\n // look for the closer (maybe final, maybe not)\n else if (const char* final = stop(src)) {\n // only close one level?\n if (level > 0) -- level;\n // return position at end of stop\n // delimiter may be multiple chars\n else return final;\n // advance position\n src = final - 1;\n }\n\n // next\n ++ src;\n }\n\n return 0;\n }\n\n // skip to a skip delimited by parentheses\n // uses smart `skip_over_scopes` internally\n const char* parenthese_scope(const char* src);\n\n // skip to delimiter (mx) inside given range\n // this will savely skip over all quoted strings\n // recursive skip stuff delimited by start/stop\n // first start/opener must be consumed already!\n template\n const char* skip_over_scopes(const char* src) {\n return skip_over_scopes(src, 0);\n }\n\n // Match a sequence of characters delimited by the supplied chars.\n template \n const char* recursive_scopes(const char* src) {\n // parse opener\n src = start(src);\n // abort if not found\n if (!src) return 0;\n // parse the rest until final closer\n return skip_over_scopes(src);\n }\n\n // Match a sequence of characters delimited by the supplied strings.\n template \n const char* delimited_by(const char* src) {\n src = exactly(src);\n if (!src) return 0;\n const char* stop;\n while (true) {\n if (!*src) return 0;\n stop = exactly(src);\n if (stop && (!esc || *(src - 1) != '\\\\')) return stop;\n src = stop ? stop : src + 1;\n }\n }\n\n // Tries to match a certain number of times (between the supplied interval).\n template\n const char* between(const char* src) {\n for (size_t i = 0; i < lo; ++i) {\n src = mx(src);\n if (!src) return 0;\n }\n for (size_t i = lo; i <= hi; ++i) {\n const char* new_src = mx(src);\n if (!new_src) return src;\n src = new_src;\n }\n return src;\n }\n\n // equivalent of STRING_REGULAR_EXPRESSIONS\n const char* re_string_double_open(const char* src);\n const char* re_string_double_close(const char* src);\n const char* re_string_single_open(const char* src);\n const char* re_string_single_close(const char* src);\n const char* re_string_uri_open(const char* src);\n const char* re_string_uri_close(const char* src);\n\n // Match a line comment.\n const char* line_comment(const char* src);\n\n // Match a block comment.\n const char* block_comment(const char* src);\n // Match either.\n const char* comment(const char* src);\n // Match double- and single-quoted strings.\n const char* double_quoted_string(const char* src);\n const char* single_quoted_string(const char* src);\n const char* quoted_string(const char* src);\n // Match interpolants.\n const char* interpolant(const char* src);\n // Match number prefix ([\\+\\-]+)\n const char* number_prefix(const char* src);\n\n // Match zero plus white-space or line_comments\n const char* optional_css_whitespace(const char* src);\n const char* css_whitespace(const char* src);\n // Match optional_css_whitepace plus block_comments\n const char* optional_css_comments(const char* src);\n const char* css_comments(const char* src);\n\n // Match one backslash escaped char\n const char* escape_seq(const char* src);\n\n // Match CSS css variables.\n const char* custom_property_name(const char* src);\n // Match a CSS identifier.\n const char* identifier(const char* src);\n const char* identifier_alpha(const char* src);\n const char* identifier_alnum(const char* src);\n const char* strict_identifier(const char* src);\n const char* strict_identifier_alpha(const char* src);\n const char* strict_identifier_alnum(const char* src);\n // Match a CSS unit identifier.\n const char* one_unit(const char* src);\n const char* multiple_units(const char* src);\n const char* unit_identifier(const char* src);\n // const char* strict_identifier_alnums(const char* src);\n // Match reference selector.\n const char* re_reference_combinator(const char* src);\n const char* static_reference_combinator(const char* src);\n const char* schema_reference_combinator(const char* src);\n\n // Match interpolant schemas\n const char* identifier_schema(const char* src);\n const char* value_schema(const char* src);\n const char* sass_value(const char* src);\n // const char* filename(const char* src);\n // const char* filename_schema(const char* src);\n // const char* url_schema(const char* src);\n // const char* url_value(const char* src);\n const char* vendor_prefix(const char* src);\n\n const char* re_special_directive(const char* src);\n const char* re_prefixed_directive(const char* src);\n const char* re_almost_any_value_token(const char* src);\n\n // Match CSS '@' keywords.\n const char* at_keyword(const char* src);\n const char* kwd_import(const char* src);\n const char* kwd_at_root(const char* src);\n const char* kwd_with_directive(const char* src);\n const char* kwd_without_directive(const char* src);\n const char* kwd_media(const char* src);\n const char* kwd_supports_directive(const char* src);\n // const char* keyframes(const char* src);\n // const char* keyf(const char* src);\n const char* kwd_mixin(const char* src);\n const char* kwd_function(const char* src);\n const char* kwd_return_directive(const char* src);\n const char* kwd_include_directive(const char* src);\n const char* kwd_content_directive(const char* src);\n const char* kwd_charset_directive(const char* src);\n const char* kwd_extend(const char* src);\n\n const char* unicode_seq(const char* src);\n\n const char* kwd_if_directive(const char* src);\n const char* kwd_else_directive(const char* src);\n const char* elseif_directive(const char* src);\n\n const char* kwd_for_directive(const char* src);\n const char* kwd_from(const char* src);\n const char* kwd_to(const char* src);\n const char* kwd_through(const char* src);\n\n const char* kwd_each_directive(const char* src);\n const char* kwd_in(const char* src);\n\n const char* kwd_while_directive(const char* src);\n\n const char* re_nothing(const char* src);\n\n const char* re_special_fun(const char* src);\n\n const char* kwd_warn(const char* src);\n const char* kwd_err(const char* src);\n const char* kwd_dbg(const char* src);\n\n const char* kwd_null(const char* src);\n\n const char* re_selector_list(const char* src);\n const char* re_type_selector(const char* src);\n const char* re_static_expression(const char* src);\n\n // identifier that can start with hyphens\n const char* css_identifier(const char* src);\n const char* css_ip_identifier(const char* src);\n\n // Match CSS type selectors\n const char* namespace_schema(const char* src);\n const char* namespace_prefix(const char* src);\n const char* type_selector(const char* src);\n const char* hyphens_and_identifier(const char* src);\n const char* hyphens_and_name(const char* src);\n const char* universal(const char* src);\n // Match CSS id names.\n const char* id_name(const char* src);\n // Match CSS class names.\n const char* class_name(const char* src);\n // Attribute name in an attribute selector\n const char* attribute_name(const char* src);\n // Match placeholder selectors.\n const char* placeholder(const char* src);\n // Match CSS numeric constants.\n const char* op(const char* src);\n const char* sign(const char* src);\n const char* unsigned_number(const char* src);\n const char* number(const char* src);\n const char* coefficient(const char* src);\n const char* binomial(const char* src);\n const char* percentage(const char* src);\n const char* ampersand(const char* src);\n const char* dimension(const char* src);\n const char* hex(const char* src);\n const char* hexa(const char* src);\n const char* hex0(const char* src);\n // const char* rgb_prefix(const char* src);\n // Match CSS uri specifiers.\n const char* uri_prefix(const char* src);\n // Match CSS \"!important\" keyword.\n const char* kwd_important(const char* src);\n // Match CSS \"!optional\" keyword.\n const char* kwd_optional(const char* src);\n // Match Sass \"!default\" keyword.\n const char* default_flag(const char* src);\n const char* global_flag(const char* src);\n // Match CSS pseudo-class/element prefixes\n const char* pseudo_prefix(const char* src);\n // Match CSS function call openers.\n const char* re_functional(const char* src);\n const char* re_pseudo_selector(const char* src);\n const char* functional_schema(const char* src);\n const char* pseudo_not(const char* src);\n // Match CSS 'odd' and 'even' keywords for functional pseudo-classes.\n const char* even(const char* src);\n const char* odd(const char* src);\n // Match CSS attribute-matching operators.\n const char* exact_match(const char* src);\n const char* class_match(const char* src);\n const char* dash_match(const char* src);\n const char* prefix_match(const char* src);\n const char* suffix_match(const char* src);\n const char* substring_match(const char* src);\n // Match CSS combinators.\n // const char* adjacent_to(const char* src);\n // const char* precedes(const char* src);\n // const char* parent_of(const char* src);\n // const char* ancestor_of(const char* src);\n\n // Match SCSS variable names.\n const char* variable(const char* src);\n const char* calc_fn_call(const char* src);\n\n // IE stuff\n const char* ie_progid(const char* src);\n const char* ie_expression(const char* src);\n const char* ie_property(const char* src);\n const char* ie_keyword_arg(const char* src);\n const char* ie_keyword_arg_value(const char* src);\n const char* ie_keyword_arg_property(const char* src);\n\n // characters that terminate parsing of a list\n const char* list_terminator(const char* src);\n const char* space_list_terminator(const char* src);\n\n // match url()\n const char* H(const char* src);\n const char* W(const char* src);\n // `UNICODE` makes VS sad\n const char* UUNICODE(const char* src);\n const char* NONASCII(const char* src);\n const char* ESCAPE(const char* src);\n const char* real_uri(const char* src);\n const char* real_uri_suffix(const char* src);\n // const char* real_uri_prefix(const char* src);\n const char* real_uri_value(const char* src);\n\n // Path matching functions.\n // const char* folder(const char* src);\n // const char* folders(const char* src);\n\n\n const char* static_string(const char* src);\n const char* static_component(const char* src);\n const char* static_property(const char* src);\n const char* static_value(const char* src);\n\n const char* css_variable_value(const char* src);\n const char* css_variable_top_level_value(const char* src);\n\n // Utility functions for finding and counting characters in a string.\n template\n const char* find_first(const char* src) {\n while (*src && *src != c) ++src;\n return *src ? src : 0;\n }\n template\n const char* find_first(const char* src) {\n while (*src && !mx(src)) ++src;\n return *src ? src : 0;\n }\n template\n const char* find_first_in_interval(const char* beg, const char* end) {\n bool esc = false;\n while ((beg < end) && *beg) {\n if (esc) esc = false;\n else if (*beg == '\\\\') esc = true;\n else if (mx(beg)) return beg;\n ++beg;\n }\n return 0;\n }\n template\n const char* find_first_in_interval(const char* beg, const char* end) {\n bool esc = false;\n while ((beg < end) && *beg) {\n if (esc) esc = false;\n else if (*beg == '\\\\') esc = true;\n else if (const char* pos = skip(beg)) beg = pos;\n else if (mx(beg)) return beg;\n ++beg;\n }\n return 0;\n }\n template \n unsigned int count_interval(const char* beg, const char* end) {\n unsigned int counter = 0;\n bool esc = false;\n while (beg < end && *beg) {\n const char* p;\n if (esc) {\n esc = false;\n ++beg;\n } else if (*beg == '\\\\') {\n esc = true;\n ++beg;\n } else if ((p = mx(beg))) {\n ++counter;\n beg = p;\n }\n else {\n ++beg;\n }\n }\n return counter;\n }\n\n template \n const char* padded_token(const char* src)\n {\n size_t got = 0;\n const char* pos = src;\n while (got < size) {\n if (!mx(pos)) break;\n ++ pos; ++ got;\n }\n while (got < size) {\n if (!pad(pos)) break;\n ++ pos; ++ got;\n }\n return got ? pos : 0;\n }\n\n template \n const char* minmax_range(const char* src)\n {\n size_t got = 0;\n const char* pos = src;\n while (got < max) {\n if (!mx(pos)) break;\n ++ pos; ++ got;\n }\n if (got < min) return 0;\n if (got > max) return 0;\n return pos;\n }\n\n template \n const char* char_range(const char* src)\n {\n if (*src < min) return 0;\n if (*src > max) return 0;\n return src + 1;\n }\n\n }\n}\n\n#endif\n" }, { "path": "libsass-build/remove_placeholders.cpp", "content": "#include \"sass.hpp\"\n#include \"remove_placeholders.hpp\"\n#include \"context.hpp\"\n#include \"inspect.hpp\"\n#include \n\nnamespace Sass {\n\n Remove_Placeholders::Remove_Placeholders()\n { }\n\n void Remove_Placeholders::operator()(Block_Ptr b) {\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Ptr st = b->at(i);\n st->perform(this);\n }\n }\n\n Selector_List_Ptr Remove_Placeholders::remove_placeholders(Selector_List_Ptr sl)\n {\n Selector_List_Ptr new_sl = SASS_MEMORY_NEW(Selector_List, sl->pstate());\n\n for (size_t i = 0, L = sl->length(); i < L; ++i) {\n if (!sl->at(i)->contains_placeholder()) {\n new_sl->append(sl->at(i));\n }\n }\n\n return new_sl;\n\n }\n\n\n void Remove_Placeholders::operator()(Ruleset_Ptr r) {\n // Create a new selector group without placeholders\n Selector_List_Obj sl = Cast(r->selector());\n\n if (sl) {\n // Set the new placeholder selector list\n r->selector(remove_placeholders(sl));\n // Remove placeholders in wrapped selectors\n for (Complex_Selector_Obj cs : sl->elements()) {\n while (cs) {\n if (cs->head()) {\n for (Simple_Selector_Obj& ss : cs->head()->elements()) {\n if (Wrapped_Selector_Ptr ws = Cast(ss)) {\n if (Selector_List_Ptr wsl = Cast(ws->selector())) {\n Selector_List_Ptr clean = remove_placeholders(wsl);\n // also clean superflous parent selectors\n // probably not really the correct place\n clean->remove_parent_selectors();\n ws->selector(clean);\n }\n }\n }\n }\n cs = cs->tail();\n }\n }\n }\n\n // Iterate into child blocks\n Block_Obj b = r->block();\n\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n if (b->at(i)) {\n Statement_Obj st = b->at(i);\n st->perform(this);\n }\n }\n }\n\n void Remove_Placeholders::operator()(Media_Block_Ptr m) {\n operator()(m->block());\n }\n void Remove_Placeholders::operator()(Supports_Block_Ptr m) {\n operator()(m->block());\n }\n\n void Remove_Placeholders::operator()(Directive_Ptr a) {\n if (a->block()) a->block()->perform(this);\n }\n\n}\n" }, { "path": "libsass-build/remove_placeholders.hpp", "content": "#ifndef SASS_REMOVE_PLACEHOLDERS_H\n#define SASS_REMOVE_PLACEHOLDERS_H\n\n#pragma once\n\n#include \"ast.hpp\"\n#include \"operation.hpp\"\n\nnamespace Sass {\n\n\n class Remove_Placeholders : public Operation_CRTP {\n\n void fallback_impl(AST_Node_Ptr n) {}\n\n public:\n Selector_List_Ptr remove_placeholders(Selector_List_Ptr);\n\n public:\n Remove_Placeholders();\n ~Remove_Placeholders() { }\n\n void operator()(Block_Ptr);\n void operator()(Ruleset_Ptr);\n void operator()(Media_Block_Ptr);\n void operator()(Supports_Block_Ptr);\n void operator()(Directive_Ptr);\n\n template \n void fallback(U x) { return fallback_impl(x); }\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/sass.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n#include \n#include \n\n#include \"sass.h\"\n#include \"file.hpp\"\n#include \"util.hpp\"\n#include \"sass_context.hpp\"\n#include \"sass_functions.hpp\"\n\nnamespace Sass {\n\n // helper to convert string list to vector\n std::vector list2vec(struct string_list* cur)\n {\n std::vector list;\n while (cur) {\n list.push_back(cur->string);\n cur = cur->next;\n }\n return list;\n }\n\n}\n\nextern \"C\" {\n using namespace Sass;\n\n // Allocate libsass heap memory\n // Don't forget string termination!\n void* ADDCALL sass_alloc_memory(size_t size)\n {\n void* ptr = malloc(size);\n if (ptr == NULL) {\n std::cerr << \"Out of memory.\\n\";\n exit(EXIT_FAILURE);\n }\n return ptr;\n }\n\n char* ADDCALL sass_copy_c_string(const char* str)\n {\n size_t len = strlen(str) + 1;\n char* cpy = (char*) sass_alloc_memory(len);\n std::memcpy(cpy, str, len);\n return cpy;\n }\n\n // Deallocate libsass heap memory\n void ADDCALL sass_free_memory(void* ptr)\n {\n if (ptr) free (ptr);\n }\n\n // caller must free the returned memory\n char* ADDCALL sass_string_quote (const char *str, const char quote_mark)\n {\n std::string quoted = quote(str, quote_mark);\n return sass_copy_c_string(quoted.c_str());\n }\n\n // caller must free the returned memory\n char* ADDCALL sass_string_unquote (const char *str)\n {\n std::string unquoted = unquote(str);\n return sass_copy_c_string(unquoted.c_str());\n }\n\n char* ADDCALL sass_compiler_find_include (const char* file, struct Sass_Compiler* compiler)\n {\n // get the last import entry to get current base directory\n Sass_Import_Entry import = sass_compiler_get_last_import(compiler);\n const std::vector& incs = compiler->cpp_ctx->include_paths;\n // create the vector with paths to lookup\n std::vector paths(1 + incs.size());\n paths.push_back(File::dir_name(import->abs_path));\n paths.insert( paths.end(), incs.begin(), incs.end() );\n // now resolve the file path relative to lookup paths\n std::string resolved(File::find_include(file, paths));\n return sass_copy_c_string(resolved.c_str());\n }\n\n char* ADDCALL sass_compiler_find_file (const char* file, struct Sass_Compiler* compiler)\n {\n // get the last import entry to get current base directory\n Sass_Import_Entry import = sass_compiler_get_last_import(compiler);\n const std::vector& incs = compiler->cpp_ctx->include_paths;\n // create the vector with paths to lookup\n std::vector paths(1 + incs.size());\n paths.push_back(File::dir_name(import->abs_path));\n paths.insert( paths.end(), incs.begin(), incs.end() );\n // now resolve the file path relative to lookup paths\n std::string resolved(File::find_file(file, paths));\n return sass_copy_c_string(resolved.c_str());\n }\n\n // Make sure to free the returned value!\n // Incs array has to be null terminated!\n // this has the original resolve logic for sass include\n char* ADDCALL sass_find_include (const char* file, struct Sass_Options* opt)\n {\n std::vector vec(list2vec(opt->include_paths));\n std::string resolved(File::find_include(file, vec));\n return sass_copy_c_string(resolved.c_str());\n }\n\n // Make sure to free the returned value!\n // Incs array has to be null terminated!\n char* ADDCALL sass_find_file (const char* file, struct Sass_Options* opt)\n {\n std::vector vec(list2vec(opt->include_paths));\n std::string resolved(File::find_file(file, vec));\n return sass_copy_c_string(resolved.c_str());\n }\n\n // Get compiled libsass version\n const char* ADDCALL libsass_version(void)\n {\n return LIBSASS_VERSION;\n }\n\n // Get compiled libsass version\n const char* ADDCALL libsass_language_version(void)\n {\n return LIBSASS_LANGUAGE_VERSION;\n }\n\n}\n\nnamespace Sass {\n\n // helper to aid dreaded MSVC debug mode\n char* sass_copy_string(std::string str)\n {\n // In MSVC the following can lead to segfault:\n // sass_copy_c_string(stream.str().c_str());\n // Reason is that the string returned by str() is disposed before\n // sass_copy_c_string is invoked. The string is actually a stack\n // object, so indeed nobody is holding on to it. So it seems\n // perfectly fair to release it right away. So the const char*\n // by c_str will point to invalid memory. I'm not sure if this is\n // the behavior for all compiler, but I'm pretty sure we would\n // have gotten more issues reported if that would be the case.\n // Wrapping it in a functions seems the cleanest approach as the\n // function must hold on to the stack variable until it's done.\n return sass_copy_c_string(str.c_str());\n }\n\n}" }, { "path": "libsass-build/sass.hpp", "content": "// must be the first include in all compile units\n#ifndef SASS_SASS_H\n#define SASS_SASS_H\n\n// undefine extensions macro to tell sys includes\n// that we do not want any macros to be exported\n// mainly fixes an issue on SmartOS (SEC macro)\n#undef __EXTENSIONS__\n\n#ifdef _MSC_VER\n#pragma warning(disable : 4005)\n#endif\n\n// aplies to MSVC and MinGW\n#ifdef _WIN32\n// we do not want the ERROR macro\n# define NOGDI\n// we do not want the min/max macro\n# define NOMINMAX\n// we do not want the IN/OUT macro\n# define _NO_W32_PSEUDO_MODIFIERS\n#endif\n\n\n// should we be case insensitive\n// when dealing with files or paths\n#ifndef FS_CASE_SENSITIVE\n# ifdef _WIN32\n# define FS_CASE_SENSITIVE 0\n# else\n# define FS_CASE_SENSITIVE 1\n# endif\n#endif\n\n// path separation char\n#ifndef PATH_SEP\n# ifdef _WIN32\n# define PATH_SEP ';'\n# else\n# define PATH_SEP ':'\n# endif\n#endif\n\n\n// include C-API header\n#include \"sass/base.h\"\n\n// For C++ helper\n#include \n\n// output behaviours\nnamespace Sass {\n\n // create some C++ aliases for the most used options\n const static Sass_Output_Style NESTED = SASS_STYLE_NESTED;\n const static Sass_Output_Style COMPACT = SASS_STYLE_COMPACT;\n const static Sass_Output_Style EXPANDED = SASS_STYLE_EXPANDED;\n const static Sass_Output_Style COMPRESSED = SASS_STYLE_COMPRESSED;\n // only used internal to trigger ruby inspect behavior\n const static Sass_Output_Style INSPECT = SASS_STYLE_INSPECT;\n const static Sass_Output_Style TO_SASS = SASS_STYLE_TO_SASS;\n\n // helper to aid dreaded MSVC debug mode\n // see implementation for more details\n char* sass_copy_string(std::string str);\n\n}\n\n// input behaviours\nenum Sass_Input_Style {\n SASS_CONTEXT_NULL,\n SASS_CONTEXT_FILE,\n SASS_CONTEXT_DATA,\n SASS_CONTEXT_FOLDER\n};\n\n// simple linked list\nstruct string_list {\n string_list* next;\n char* string;\n};\n\n// sass config options structure\nstruct Sass_Inspect_Options {\n\n // Output style for the generated css code\n // A value from above SASS_STYLE_* constants\n enum Sass_Output_Style output_style;\n\n // Precision for fractional numbers\n int precision;\n\n // Do not compress colors in selectors\n bool in_selector;\n\n // initialization list (constructor with defaults)\n Sass_Inspect_Options(Sass_Output_Style style = Sass::NESTED,\n int precision = 5, bool in_selector = false)\n : output_style(style), precision(precision), in_selector(in_selector)\n { }\n\n};\n\n// sass config options structure\nstruct Sass_Output_Options : Sass_Inspect_Options {\n\n // String to be used for indentation\n const char* indent;\n // String to be used to for line feeds\n const char* linefeed;\n\n // Emit comments in the generated CSS indicating\n // the corresponding source line.\n bool source_comments;\n\n // initialization list (constructor with defaults)\n Sass_Output_Options(struct Sass_Inspect_Options opt,\n const char* indent = \" \",\n const char* linefeed = \"\\n\",\n bool source_comments = false)\n : Sass_Inspect_Options(opt),\n indent(indent), linefeed(linefeed),\n source_comments(source_comments)\n { }\n\n // initialization list (constructor with defaults)\n Sass_Output_Options(Sass_Output_Style style = Sass::NESTED,\n int precision = 5,\n const char* indent = \" \",\n const char* linefeed = \"\\n\",\n bool source_comments = false)\n : Sass_Inspect_Options(style, precision),\n indent(indent), linefeed(linefeed),\n source_comments(source_comments)\n { }\n\n};\n\n#endif\n" }, { "path": "libsass-build/sass2scss.cpp", "content": "/**\n * sass2scss\n * Licensed under the MIT License\n * Copyright (c) Marcel Greter\n */\n\n#ifdef _MSC_VER\n#define _CRT_SECURE_NO_WARNINGS\n#define _CRT_NONSTDC_NO_DEPRECATE\n#endif\n\n// include library\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n///*\n//\n// src comments: comments in sass syntax (staring with //)\n// css comments: multiline comments in css syntax (starting with /*)\n//\n// KEEP_COMMENT: keep src comments in the resulting css code\n// STRIP_COMMENT: strip out all comments (either src or css)\n// CONVERT_COMMENT: convert all src comments to css comments\n//\n//*/\n\n// our own header\n#include \"sass2scss.h\"\n\n// add namespace for c++\nnamespace Sass\n{\n\n\t// return the actual prettify value from options\n\t#define PRETTIFY(converter) (converter.options - (converter.options & 248))\n\t// query the options integer to check if the option is enables\n\t#define KEEP_COMMENT(converter) ((converter.options & SASS2SCSS_KEEP_COMMENT) == SASS2SCSS_KEEP_COMMENT)\n\t#define STRIP_COMMENT(converter) ((converter.options & SASS2SCSS_STRIP_COMMENT) == SASS2SCSS_STRIP_COMMENT)\n\t#define CONVERT_COMMENT(converter) ((converter.options & SASS2SCSS_CONVERT_COMMENT) == SASS2SCSS_CONVERT_COMMENT)\n\n\t// some makros to access the indentation stack\n\t#define INDENT(converter) (converter.indents.top())\n\n\t// some makros to query comment parser status\n\t#define IS_PARSING(converter) (converter.comment == \"\")\n\t#define IS_COMMENT(converter) (converter.comment != \"\")\n\t#define IS_SRC_COMMENT(converter) (converter.comment == \"//\" && ! CONVERT_COMMENT(converter))\n\t#define IS_CSS_COMMENT(converter) (converter.comment == \"/*\" || (converter.comment == \"//\" && CONVERT_COMMENT(converter)))\n\n\t// pretty printer helper function\n\tstatic std::string closer (const converter& converter)\n\t{\n\t\treturn PRETTIFY(converter) == 0 ? \" }\" :\n\t\t PRETTIFY(converter) <= 1 ? \" }\" :\n\t\t \"\\n\" + INDENT(converter) + \"}\";\n\t}\n\n\t// pretty printer helper function\n\tstatic std::string opener (const converter& converter)\n\t{\n\t\treturn PRETTIFY(converter) == 0 ? \" { \" :\n\t\t PRETTIFY(converter) <= 2 ? \" {\" :\n\t\t \"\\n\" + INDENT(converter) + \"{\";\n\t}\n\n\t// check if the given string is a pseudo selector\n\t// needed to differentiate from sass property syntax\n\tstatic bool isPseudoSelector (std::string& sel)\n\t{\n\n\t\tsize_t len = sel.length();\n\t\tif (len < 1) return false;\n\t\tsize_t pos = sel.find_first_not_of(\"abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ\", 1);\n\t\tif (pos != std::string::npos) sel.erase(pos, std::string::npos);\n\t\tsize_t i = sel.length();\n\t\twhile (i -- > 0) { sel.at(i) = tolower(sel.at(i)); }\n\n\t\t// CSS Level 1 - Recommendation\n\t\tif (sel == \":link\") return true;\n\t\tif (sel == \":visited\") return true;\n\t\tif (sel == \":active\") return true;\n\n\t\t// CSS Level 2 (Revision 1) - Recommendation\n\t\tif (sel == \":lang\") return true;\n\t\tif (sel == \":first-child\") return true;\n\t\tif (sel == \":hover\") return true;\n\t\tif (sel == \":focus\") return true;\n\t\t// disabled - also valid properties\n\t\t// if (sel == \":left\") return true;\n\t\t// if (sel == \":right\") return true;\n\t\tif (sel == \":first\") return true;\n\n\t\t// Selectors Level 3 - Recommendation\n\t\tif (sel == \":target\") return true;\n\t\tif (sel == \":root\") return true;\n\t\tif (sel == \":nth-child\") return true;\n\t\tif (sel == \":nth-last-of-child\") return true;\n\t\tif (sel == \":nth-of-type\") return true;\n\t\tif (sel == \":nth-last-of-type\") return true;\n\t\tif (sel == \":last-child\") return true;\n\t\tif (sel == \":first-of-type\") return true;\n\t\tif (sel == \":last-of-type\") return true;\n\t\tif (sel == \":only-child\") return true;\n\t\tif (sel == \":only-of-type\") return true;\n\t\tif (sel == \":empty\") return true;\n\t\tif (sel == \":not\") return true;\n\n\t\t// CSS Basic User Interface Module Level 3 - Working Draft\n\t\tif (sel == \":default\") return true;\n\t\tif (sel == \":valid\") return true;\n\t\tif (sel == \":invalid\") return true;\n\t\tif (sel == \":in-range\") return true;\n\t\tif (sel == \":out-of-range\") return true;\n\t\tif (sel == \":required\") return true;\n\t\tif (sel == \":optional\") return true;\n\t\tif (sel == \":read-only\") return true;\n\t\tif (sel == \":read-write\") return true;\n\t\tif (sel == \":dir\") return true;\n\t\tif (sel == \":enabled\") return true;\n\t\tif (sel == \":disabled\") return true;\n\t\tif (sel == \":checked\") return true;\n\t\tif (sel == \":indeterminate\") return true;\n\t\tif (sel == \":nth-last-child\") return true;\n\n\t\t// Selectors Level 4 - Working Draft\n\t\tif (sel == \":any-link\") return true;\n\t\tif (sel == \":local-link\") return true;\n\t\tif (sel == \":scope\") return true;\n\t\tif (sel == \":active-drop-target\") return true;\n\t\tif (sel == \":valid-drop-target\") return true;\n\t\tif (sel == \":invalid-drop-target\") return true;\n\t\tif (sel == \":current\") return true;\n\t\tif (sel == \":past\") return true;\n\t\tif (sel == \":future\") return true;\n\t\tif (sel == \":placeholder-shown\") return true;\n\t\tif (sel == \":user-error\") return true;\n\t\tif (sel == \":blank\") return true;\n\t\tif (sel == \":nth-match\") return true;\n\t\tif (sel == \":nth-last-match\") return true;\n\t\tif (sel == \":nth-column\") return true;\n\t\tif (sel == \":nth-last-column\") return true;\n\t\tif (sel == \":matches\") return true;\n\n\t\t// Fullscreen API - Living Standard\n\t\tif (sel == \":fullscreen\") return true;\n\n\t\t// not a pseudo selector\n\t\treturn false;\n\n\t}\n\n\t// check if there is some char data\n\t// will ignore everything in comments\n\tstatic bool hasCharData (std::string& sass)\n\t{\n\n\t\tsize_t col_pos = 0;\n\n\t\twhile (true)\n\t\t{\n\n\t\t\t// try to find some meaningfull char\n\t\t\tcol_pos = sass.find_first_not_of(\" \\t\\n\\v\\f\\r\", col_pos);\n\n\t\t\t// there was no meaningfull char found\n\t\t\tif (col_pos == std::string::npos) return false;\n\n\t\t\t// found a multiline comment opener\n\t\t\tif (sass.substr(col_pos, 2) == \"/*\")\n\t\t\t{\n\t\t\t\t// find the multiline comment closer\n\t\t\t\tcol_pos = sass.find(\"*/\", col_pos);\n\t\t\t\t// maybe we did not find the closer here\n\t\t\t\tif (col_pos == std::string::npos) return false;\n\t\t\t\t// skip closer\n\t\t\t\tcol_pos += 2;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\treturn true;\n\t\t\t}\n\n\t\t}\n\n\t}\n\t// EO hasCharData\n\n\t// find src comment opener\n\t// correctly skips quoted strings\n\tstatic size_t findCommentOpener (std::string& sass)\n\t{\n\n\t\tsize_t col_pos = 0;\n\t\tbool apoed = false;\n\t\tbool quoted = false;\n\t\tbool comment = false;\n\t\tsize_t brackets = 0;\n\n\t\twhile (col_pos != std::string::npos)\n\t\t{\n\n\t\t\t// process all interesting chars\n\t\t\tcol_pos = sass.find_first_of(\"\\\"\\'/\\\\*()\", col_pos);\n\n\t\t\t// assertion for valid result\n\t\t\tif (col_pos != std::string::npos)\n\t\t\t{\n\t\t\t\tchar character = sass.at(col_pos);\n\n\t\t\t\tif (character == '(')\n\t\t\t\t{\n\t\t\t\t\tif (!quoted && !apoed) brackets ++;\n\t\t\t\t}\n\t\t\t\telse if (character == ')')\n\t\t\t\t{\n\t\t\t\t\tif (!quoted && !apoed) brackets --;\n\t\t\t\t}\n\t\t\t\telse if (character == '\\\"')\n\t\t\t\t{\n\t\t\t\t\t// invert quote bool\n\t\t\t\t\tif (!apoed && !comment) quoted = !quoted;\n\t\t\t\t}\n\t\t\t\telse if (character == '\\'')\n\t\t\t\t{\n\t\t\t\t\t// invert quote bool\n\t\t\t\t\tif (!quoted && !comment) apoed = !apoed;\n\t\t\t\t}\n\t\t\t\telse if (col_pos > 0 && character == '/')\n\t\t\t\t{\n\t\t\t\t\tif (sass.at(col_pos - 1) == '*')\n\t\t\t\t\t{\n\t\t\t\t\t\tcomment = false;\n\t\t\t\t\t}\n\t\t\t\t\t// next needs to be a slash too\n\t\t\t\t\telse if (sass.at(col_pos - 1) == '/')\n\t\t\t\t\t{\n\t\t\t\t\t\t// only found if not in single or double quote, bracket or comment\n\t\t\t\t\t\tif (!quoted && !apoed && !comment && brackets == 0) return col_pos - 1;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if (character == '\\\\')\n\t\t\t\t{\n\t\t\t\t\t// skip next char if in quote\n\t\t\t\t\tif (quoted || apoed) col_pos ++;\n\t\t\t\t}\n\t\t\t\t// this might be a comment opener\n\t\t\t\telse if (col_pos > 0 && character == '*')\n\t\t\t\t{\n\t\t\t\t\t// opening a multiline comment\n\t\t\t\t\tif (sass.at(col_pos - 1) == '/')\n\t\t\t\t\t{\n\t\t\t\t\t\t// we are now in a comment\n\t\t\t\t\t\tif (!quoted && !apoed) comment = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// skip char\n\t\t\t\tcol_pos ++;\n\n\t\t\t}\n\n\t\t}\n\t\t// EO while\n\n\t\treturn col_pos;\n\n\t}\n\t// EO findCommentOpener\n\n\t// remove multiline comments from sass string\n\t// correctly skips quoted strings\n\tstatic std::string removeMultilineComment (std::string &sass)\n\t{\n\n\t\tstd::string clean = \"\";\n\t\tsize_t col_pos = 0;\n\t\tsize_t open_pos = 0;\n\t\tsize_t close_pos = 0;\n\t\tbool apoed = false;\n\t\tbool quoted = false;\n\t\tbool comment = false;\n\n\t\t// process sass til string end\n\t\twhile (col_pos != std::string::npos)\n\t\t{\n\n\t\t\t// process all interesting chars\n\t\t\tcol_pos = sass.find_first_of(\"\\\"\\'/\\\\*\", col_pos);\n\n\t\t\t// assertion for valid result\n\t\t\tif (col_pos != std::string::npos)\n\t\t\t{\n\t\t\t\tchar character = sass.at(col_pos);\n\n\t\t\t\t// found quoted string delimiter\n\t\t\t\tif (character == '\\\"')\n\t\t\t\t{\n\t\t\t\t\tif (!apoed && !comment) quoted = !quoted;\n\t\t\t\t}\n\t\t\t\telse if (character == '\\'')\n\t\t\t\t{\n\t\t\t\t\tif (!quoted && !comment) apoed = !apoed;\n\t\t\t\t}\n\t\t\t\t// found possible comment closer\n\t\t\t\telse if (character == '/')\n\t\t\t\t{\n\t\t\t\t\t// look back to see if it is actually a closer\n\t\t\t\t\tif (comment && col_pos > 0 && sass.at(col_pos - 1) == '*')\n\t\t\t\t\t{\n\t\t\t\t\t\tclose_pos = col_pos + 1; comment = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if (character == '\\\\')\n\t\t\t\t{\n\t\t\t\t\t// skip escaped char\n\t\t\t\t\tif (quoted || apoed) col_pos ++;\n\t\t\t\t}\n\t\t\t\t// this might be a comment opener\n\t\t\t\telse if (character == '*')\n\t\t\t\t{\n\t\t\t\t\t// look back to see if it is actually an opener\n\t\t\t\t\tif (!quoted && !apoed && col_pos > 0 && sass.at(col_pos - 1) == '/')\n\t\t\t\t\t{\n\t\t\t\t\t\tcomment = true; open_pos = col_pos - 1;\n\t\t\t\t\t\tclean += sass.substr(close_pos, open_pos - close_pos);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// skip char\n\t\t\t\tcol_pos ++;\n\n\t\t\t}\n\n\t\t}\n\t\t// EO while\n\n\t\t// add final parts (add half open comment text)\n\t\tif (comment) clean += sass.substr(open_pos);\n\t\telse clean += sass.substr(close_pos);\n\n\t\t// return string\n\t\treturn clean;\n\n\t}\n\t// EO removeMultilineComment\n\n\t// right trim a given string\n\tstd::string rtrim(const std::string &sass)\n\t{\n\t\tstd::string trimmed = sass;\n\t\tsize_t pos_ws = trimmed.find_last_not_of(\" \\t\\n\\v\\f\\r\");\n\t\tif (pos_ws != std::string::npos)\n\t\t{ trimmed.erase(pos_ws + 1); }\n\t\telse { trimmed.clear(); }\n\t\treturn trimmed;\n\t}\n\t// EO rtrim\n\n\t// flush whitespace and print additional text, but\n\t// only print additional chars and buffer whitespace\n\tstd::string flush (std::string& sass, converter& converter)\n\t{\n\n\t\t// return flushed\n\t\tstd::string scss = \"\";\n\n\t\t// print whitespace buffer\n\t\tscss += PRETTIFY(converter) > 0 ?\n\t\t converter.whitespace : \"\";\n\t\t// reset whitespace buffer\n\t\tconverter.whitespace = \"\";\n\n\t\t// remove possible newlines from string\n\t\tsize_t pos_right = sass.find_last_not_of(\"\\n\\r\");\n\t\tif (pos_right == std::string::npos) return scss;\n\n\t\t// get the linefeeds from the string\n\t\tstd::string lfs = sass.substr(pos_right + 1);\n\t\tsass = sass.substr(0, pos_right + 1);\n\n\t\t// find some source comment opener\n\t\tsize_t comment_pos = findCommentOpener(sass);\n\t\t// check if there was a source comment\n\t\tif (comment_pos != std::string::npos)\n\t\t{\n\t\t\t// convert comment (but only outside other coments)\n\t\t\tif (CONVERT_COMMENT(converter) && !IS_COMMENT(converter))\n\t\t\t{\n\t\t\t\t// convert to multiline comment\n\t\t\t\tsass.at(comment_pos + 1) = '*';\n\t\t\t\t// add comment node to the whitespace\n\t\t\t\tsass += \" */\";\n\t\t\t}\n\t\t\t// not at line start\n\t\t\tif (comment_pos > 0)\n\t\t\t{\n\t\t\t\t// also include whitespace before the actual comment opener\n\t\t\t\tsize_t ws_pos = sass.find_last_not_of(SASS2SCSS_FIND_WHITESPACE, comment_pos - 1);\n\t\t\t\tcomment_pos = ws_pos == std::string::npos ? 0 : ws_pos + 1;\n\t\t\t}\n\t\t\tif (!STRIP_COMMENT(converter))\n\t\t\t{\n\t\t\t\t// add comment node to the whitespace\n\t\t\t\tconverter.whitespace += sass.substr(comment_pos);\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// sass = removeMultilineComments(sass);\n\t\t\t}\n\t\t\t// update the actual sass code\n\t\t\tsass = sass.substr(0, comment_pos);\n\t\t}\n\n\t\t// add newline as getline discharged it\n\t\tconverter.whitespace += lfs + \"\\n\";\n\n\t\t// maybe remove any leading whitespace\n\t\tif (PRETTIFY(converter) == 0)\n\t\t{\n\t\t\t// remove leading whitespace and update string\n\t\t\tsize_t pos_left = sass.find_first_not_of(SASS2SCSS_FIND_WHITESPACE);\n\t\t\tif (pos_left != std::string::npos) sass = sass.substr(pos_left);\n\t\t}\n\n\t\t// add flushed data\n\t\tscss += sass;\n\n\t\t// return string\n\t\treturn scss;\n\n\t}\n\t// EO flush\n\n\t// process a line of the sass text\n\tstd::string process (std::string& sass, converter& converter)\n\t{\n\n\t\t// resulting string\n\t\tstd::string scss = \"\";\n\n\t\t// strip multi line comments\n\t\tif (STRIP_COMMENT(converter))\n\t\t{\n\t\t\tsass = removeMultilineComment(sass);\n\t\t}\n\n\t\t// right trim input\n\t\tsass = rtrim(sass);\n\n\t\t// get postion of first meaningfull character in string\n\t\tsize_t pos_left = sass.find_first_not_of(SASS2SCSS_FIND_WHITESPACE);\n\n\t\t// special case for final run\n\t\tif (converter.end_of_file) pos_left = 0;\n\n\t\t// maybe has only whitespace\n\t\tif (pos_left == std::string::npos)\n\t\t{\n\t\t\t// just add complete whitespace\n\t\t\tconverter.whitespace += sass + \"\\n\";\n\t\t}\n\t\t// have meaningfull first char\n\t\telse\n\t\t{\n\n\t\t\t// extract and store indentation string\n\t\t\tstd::string indent = sass.substr(0, pos_left);\n\n\t\t\t// check if current line starts a comment\n\t\t\tstd::string open = sass.substr(pos_left, 2);\n\n\t\t\t// line has less or same indentation\n\t\t\t// finalize previous open parser context\n\t\t\tif (indent.length() <= INDENT(converter).length())\n\t\t\t{\n\n\t\t\t\t// close multilinie comment\n\t\t\t\tif (IS_CSS_COMMENT(converter))\n\t\t\t\t{\n\t\t\t\t\t// check if comments will be stripped anyway\n\t\t\t\t\tif (!STRIP_COMMENT(converter)) scss += \" */\";\n\t\t\t\t}\n\t\t\t\t// close src comment comment\n\t\t\t\telse if (IS_SRC_COMMENT(converter))\n\t\t\t\t{\n\t\t\t\t\t// add a newline to avoid closer on same line\n\t\t\t\t\t// this would put the bracket in the comment node\n\t\t\t\t\t// no longer needed since we parse them correctly\n\t\t\t\t\t// if (KEEP_COMMENT(converter)) scss += \"\\n\";\n\t\t\t\t}\n\t\t\t\t// close css properties\n\t\t\t\telse if (converter.property)\n\t\t\t\t{\n\t\t\t\t\t// add closer unless in concat mode\n\t\t\t\t\tif (!converter.comma)\n\t\t\t\t\t{\n\t\t\t\t\t\t// if there was no colon we have a selector\n\t\t\t\t\t\t// looks like there were no inner properties\n\t\t\t\t\t\tif (converter.selector) scss += \" {}\";\n\t\t\t\t\t\t// add final semicolon\n\t\t\t\t\t\telse if (!converter.semicolon) scss += \";\";\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// reset comment state\n\t\t\t\tconverter.comment = \"\";\n\n\t\t\t}\n\n\t\t\t// make sure we close every \"higher\" block\n\t\t\twhile (indent.length() < INDENT(converter).length())\n\t\t\t{\n\t\t\t\t// pop stacked context\n\t\t\t\tconverter.indents.pop();\n\t\t\t\t// print close bracket\n\t\t\t\tif (IS_PARSING(converter))\n\t\t\t\t{ scss += closer(converter); }\n\t\t\t\telse { scss += \" */\"; }\n\t\t\t\t// reset comment state\n\t\t\t\tconverter.comment = \"\";\n\t\t\t}\n\n\t\t\t// reset converter state\n\t\t\tconverter.selector = false;\n\n\t\t\t// looks like some undocumented behavior ...\n\t\t\t// https://github.com/mgreter/sass2scss/issues/29\n\t\t\tif (sass.substr(pos_left, 1) == \"\\\\\") {\n\t\t\t\tconverter.selector = true;\n\t\t\t\tsass[pos_left] = ' ';\n\t\t\t}\n\n\t\t\t// check if we have sass property syntax\n\t\t\tif (sass.substr(pos_left, 1) == \":\" && sass.substr(pos_left, 2) != \"::\")\n\t\t\t{\n\n\t\t\t\t// default to a selector\n\t\t\t\t// change back if property found\n\t\t\t\tconverter.selector = true;\n\t\t\t\t// get postion of first whitespace char\n\t\t\t\tsize_t pos_wspace = sass.find_first_of(SASS2SCSS_FIND_WHITESPACE, pos_left);\n\t\t\t\t// assertion check for valid result\n\t\t\t\tif (pos_wspace != std::string::npos)\n\t\t\t\t{\n\t\t\t\t\t// get the possible pseudo selector\n\t\t\t\t\tstd::string pseudo = sass.substr(pos_left, pos_wspace - pos_left);\n\t\t\t\t\t// get position of the first real property value char\n\t\t\t\t\t// pseudo selectors get this far, but have no actual value\n\t\t\t\t\tsize_t pos_value = sass.find_first_not_of(SASS2SCSS_FIND_WHITESPACE, pos_wspace);\n\t\t\t\t\t// assertion check for valid result\n\t\t\t\t\tif (pos_value != std::string::npos)\n\t\t\t\t\t{\n\t\t\t\t\t\t// only process if not (fallowed by a semicolon or is a pseudo selector)\n\t\t\t\t\t\tif (!(sass.at(pos_value) == ':' || isPseudoSelector(pseudo)))\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t// create new string by interchanging the colon sign for property and value\n\t\t\t\t\t\t\tsass = indent + sass.substr(pos_left + 1, pos_wspace - pos_left - 1) + \":\" + sass.substr(pos_wspace);\n\t\t\t\t\t\t\t// try to find a colon in the current line, but only ...\n\t\t\t\t\t\t\tsize_t pos_colon = sass.find_first_not_of(\":\", pos_left);\n\t\t\t\t\t\t\t// assertion for valid result\n\t\t\t\t\t\t\tif (pos_colon != std::string::npos)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t// ... after the first word (skip begining colons)\n\t\t\t\t\t\t\t\tpos_colon = sass.find_first_of(\":\", pos_colon);\n\t\t\t\t\t\t\t\t// it is a selector if there was no colon found\n\t\t\t\t\t\t\t\tconverter.selector = pos_colon == std::string::npos;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// check if we have a BEM property (one colon and no selector)\n\t\t\t\tif (sass.substr(pos_left, 1) == \":\" && converter.selector == true) {\n\t\t\t\t\tsize_t pos_wspace = sass.find_first_of(SASS2SCSS_FIND_WHITESPACE, pos_left);\n\t\t\t\t\tsass = indent + sass.substr(pos_left + 1, pos_wspace) + \":\";\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// terminate some statements immediately\n\t\t\telse if (\n\t\t\t\tsass.substr(pos_left, 5) == \"@warn\" ||\n\t\t\t\tsass.substr(pos_left, 6) == \"@debug\" ||\n\t\t\t\tsass.substr(pos_left, 6) == \"@error\" ||\n\t\t\t\tsass.substr(pos_left, 8) == \"@charset\" ||\n\t\t\t\tsass.substr(pos_left, 10) == \"@namespace\"\n\t\t\t) { sass = indent + sass.substr(pos_left); }\n\t\t\t// replace some specific sass shorthand directives (if not fallowed by a white space character)\n\t\t\telse if (sass.substr(pos_left, 1) == \"=\")\n\t\t\t{ sass = indent + \"@mixin \" + sass.substr(pos_left + 1); }\n\t\t\telse if (sass.substr(pos_left, 1) == \"+\")\n\t\t\t{\n\t\t\t\t// must be followed by a mixin call (no whitespace afterwards or at ending directly)\n\t\t\t\tif (sass[pos_left+1] != 0 && sass[pos_left+1] != ' ' && sass[pos_left+1] != '\\t') {\n\t\t\t\t\tsass = indent + \"@include \" + sass.substr(pos_left + 1);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// add quotes for import if needed\n\t\t\telse if (sass.substr(pos_left, 7) == \"@import\")\n\t\t\t{\n\t\t\t\t// get positions for the actual import url\n\t\t\t\tsize_t pos_import = sass.find_first_of(SASS2SCSS_FIND_WHITESPACE, pos_left + 7);\n\t\t\t\tsize_t pos_quote = sass.find_first_not_of(SASS2SCSS_FIND_WHITESPACE, pos_import);\n\t\t\t\t// leave proper urls untouched\n\t\t\t\tif (sass.substr(pos_quote, 4) != \"url(\")\n\t\t\t\t{\n\t\t\t\t\t// check if the url appears to be already quoted\n\t\t\t\t\tif (sass.substr(pos_quote, 1) != \"\\\"\" && sass.substr(pos_quote, 1) != \"\\'\")\n\t\t\t\t\t{\n\t\t\t\t\t\t// get position of the last char on the line\n\t\t\t\t\t\tsize_t pos_end = sass.find_last_not_of(SASS2SCSS_FIND_WHITESPACE);\n\t\t\t\t\t\t// assertion check for valid result\n\t\t\t\t\t\tif (pos_end != std::string::npos)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t// add quotes around the full line after the import statement\n\t\t\t\t\t\t\tsass = sass.substr(0, pos_quote) + \"\\\"\" + sass.substr(pos_quote, pos_end - pos_quote + 1) + \"\\\"\";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t}\n\t\t\telse if (\n\t\t\t\tsass.substr(pos_left, 7) != \"@return\" &&\n\t\t\t\tsass.substr(pos_left, 7) != \"@extend\" &&\n\t\t\t\tsass.substr(pos_left, 8) != \"@include\" &&\n\t\t\t\tsass.substr(pos_left, 8) != \"@content\"\n\t\t\t) {\n\n\t\t\t\t// probably a selector anyway\n\t\t\t\tconverter.selector = true;\n\t\t\t\t// try to find first colon in the current line\n\t\t\t\tsize_t pos_colon = sass.find_first_of(\":\", pos_left);\n\t\t\t\t// assertion that we have a colon\n\t\t\t\tif (pos_colon != std::string::npos)\n\t\t\t\t{\n\t\t\t\t\t// it is not a selector if we have a space after a colon\n\t\t\t\t\tif (sass[pos_colon+1] == ' ') converter.selector = false;\n\t\t\t\t\tif (sass[pos_colon+1] == '\t') converter.selector = false;\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// current line has more indentation\n\t\t\tif (indent.length() >= INDENT(converter).length())\n\t\t\t{\n\t\t\t\t// not in comment mode\n\t\t\t\tif (IS_PARSING(converter))\n\t\t\t\t{\n\t\t\t\t\t// has meaningfull chars\n\t\t\t\t\tif (hasCharData(sass))\n\t\t\t\t\t{\n\t\t\t\t\t\t// is probably a property\n\t\t\t\t\t\t// also true for selectors\n\t\t\t\t\t\tconverter.property = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\t// current line has more indentation\n\t\t\tif (indent.length() > INDENT(converter).length())\n\t\t\t{\n\t\t\t\t// not in comment mode\n\t\t\t\tif (IS_PARSING(converter))\n\t\t\t\t{\n\t\t\t\t\t// had meaningfull chars\n\t\t\t\t\tif (converter.property)\n\t\t\t\t\t{\n\t\t\t\t\t\t// print block opener\n\t\t\t\t\t\tscss += opener(converter);\n\t\t\t\t\t\t// push new stack context\n\t\t\t\t\t\tconverter.indents.push(\"\");\n\t\t\t\t\t\t// store block indentation\n\t\t\t\t\t\tINDENT(converter) = indent;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// is and will be a src comment\n\t\t\t\telse if (!IS_CSS_COMMENT(converter))\n\t\t\t\t{\n\t\t\t\t\t// scss does not allow multiline src comments\n\t\t\t\t\t// therefore add forward slashes to all lines\n\t\t\t\t\tsass.at(INDENT(converter).length()+0) = '/';\n\t\t\t\t\t// there is an edge case here if indentation\n\t\t\t\t\t// is minimal (will overwrite the fist char)\n\t\t\t\t\tsass.at(INDENT(converter).length()+1) = '/';\n\t\t\t\t\t// could code around that, but I dont' think\n\t\t\t\t\t// this will ever be the cause for any trouble\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// line is opening a new comment\n\t\t\tif (open == \"/*\" || open == \"//\")\n\t\t\t{\n\t\t\t\t// reset the property state\n\t\t\t\tconverter.property = false;\n\t\t\t\t// close previous comment\n\t\t\t\tif (IS_CSS_COMMENT(converter) && open != \"\")\n\t\t\t\t{\n\t\t\t\t\tif (!STRIP_COMMENT(converter) && !CONVERT_COMMENT(converter)) scss += \" */\";\n\t\t\t\t}\n\t\t\t\t// force single line comments\n\t\t\t\t// into a correct css comment\n\t\t\t\tif (CONVERT_COMMENT(converter))\n\t\t\t\t{\n\t\t\t\t\tif (IS_PARSING(converter))\n\t\t\t\t\t{ sass.at(pos_left + 1) = '*'; }\n\t\t\t\t}\n\t\t\t\t// set comment flag\n\t\t\t\tconverter.comment = open;\n\n\t\t\t}\n\n\t\t\t// flush data only under certain conditions\n\t\t\tif (!(\n\t\t\t\t// strip css and src comments if option is set\n\t\t\t\t(IS_COMMENT(converter) && STRIP_COMMENT(converter)) ||\n\t\t\t\t// strip src comment even if strip option is not set\n\t\t\t\t// but only if the keep src comment option is not set\n\t\t\t\t(IS_SRC_COMMENT(converter) && ! KEEP_COMMENT(converter))\n\t\t\t))\n\t\t\t{\n\t\t\t\t// flush data and buffer whitespace\n\t\t\t\tscss += flush(sass, converter);\n\t\t\t}\n\n\t\t\t// get postion of last meaningfull char\n\t\t\tsize_t pos_right = sass.find_last_not_of(SASS2SCSS_FIND_WHITESPACE);\n\n\t\t\t// check for invalid result\n\t\t\tif (pos_right != std::string::npos)\n\t\t\t{\n\n\t\t\t\t// get the last meaningfull char\n\t\t\t\tstd::string close = sass.substr(pos_right, 1);\n\n\t\t\t\t// check if next line should be concatenated (list mode)\n\t\t\t\tconverter.comma = IS_PARSING(converter) && close == \",\";\n\t\t\t\tconverter.semicolon = IS_PARSING(converter) && close == \";\";\n\n\t\t\t\t// check if we have more than\n\t\t\t\t// one meaningfull char\n\t\t\t\tif (pos_right > 0)\n\t\t\t\t{\n\n\t\t\t\t\t// get the last two chars from string\n\t\t\t\t\tstd::string close = sass.substr(pos_right - 1, 2);\n\t\t\t\t\t// update parser status for expicitly closed comment\n\t\t\t\t\tif (close == \"*/\") converter.comment = \"\";\n\n\t\t\t\t}\n\n\t\t\t}\n\t\t\t// EO have meaningfull chars from end\n\n\t\t}\n\t\t// EO have meaningfull chars from start\n\n\t\t// return scss\n\t\treturn scss;\n\n\t}\n\t// EO process\n\n\t// read line with either CR, LF or CR LF format\n\t// http://stackoverflow.com/a/6089413/1550314\n\tstatic std::istream& safeGetline(std::istream& is, std::string& t)\n\t{\n\t\tt.clear();\n\n\t\t// The characters in the stream are read one-by-one using a std::streambuf.\n\t\t// That is faster than reading them one-by-one using the std::istream.\n\t\t// Code that uses streambuf this way must be guarded by a sentry object.\n\t\t// The sentry object performs various tasks,\n\t\t// such as thread synchronization and updating the stream state.\n\n\t\tstd::istream::sentry se(is, true);\n\t\tstd::streambuf* sb = is.rdbuf();\n\n\t\tfor(;;) {\n\t\t\tint c = sb->sbumpc();\n\t\t\tswitch (c) {\n\t\t\t\tcase '\\n':\n\t\t\t\t\treturn is;\n\t\t\t\tcase '\\r':\n\t\t\t\t\tif(sb->sgetc() == '\\n')\n\t\t\t\t\t\tsb->sbumpc();\n\t\t\t\t\treturn is;\n\t\t\t\tcase EOF:\n\t\t\t\t\t// Also handle the case when the last line has no line ending\n\t\t\t\t\tif(t.empty())\n\t\t\t\t\t\tis.setstate(std::ios::eofbit);\n\t\t\t\t\treturn is;\n\t\t\t\tdefault:\n\t\t\t\t\tt += (char)c;\n\t\t\t}\n\t\t}\n\t}\n\n\t// the main converter function for c++\n\tchar* sass2scss (const std::string& sass, const int options)\n\t{\n\n\t\t// local variables\n\t\tstd::string line;\n\t\tstd::string scss = \"\";\n\t\tstd::stringstream stream(sass);\n\n\t\t// create converter variable\n\t\tconverter converter;\n\t\t// initialise all options\n\t\tconverter.comma = false;\n\t\tconverter.property = false;\n\t\tconverter.selector = false;\n\t\tconverter.semicolon = false;\n\t\tconverter.end_of_file = false;\n\t\tconverter.comment = \"\";\n\t\tconverter.whitespace = \"\";\n\t\tconverter.indents.push(\"\");\n\t\tconverter.options = options;\n\n\t\t// read line by line and process them\n\t\twhile(safeGetline(stream, line) && !stream.eof())\n\t\t{ scss += process(line, converter); }\n\n\t\t// create mutable string\n\t\tstd::string closer = \"\";\n\t\t// set the end of file flag\n\t\tconverter.end_of_file = true;\n\t\t// process to close all open blocks\n\t\tscss += process(closer, converter);\n\n\t\t// allocate new memory on the heap\n\t\t// caller has to free it after use\n\t\tchar * cstr = (char*) malloc (scss.length() + 1);\n\t\t// create a copy of the string\n\t\tstrcpy (cstr, scss.c_str());\n\t\t// return pointer\n\t\treturn &cstr[0];\n\n\t}\n\t// EO sass2scss\n\n}\n// EO namespace\n\n// implement for c\nextern \"C\"\n{\n\n\tchar* ADDCALL sass2scss (const char* sass, const int options)\n\t{\n\t\treturn Sass::sass2scss(sass, options);\n\t}\n\n\t// Get compiled sass2scss version\n\tconst char* ADDCALL sass2scss_version(void) {\n\t\treturn SASS2SCSS_VERSION;\n\t}\n\n}\n" }, { "path": "libsass-build/sass_context.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n#include \n#include \n#include \n\n#include \"sass.h\"\n#include \"ast.hpp\"\n#include \"file.hpp\"\n#include \"json.hpp\"\n#include \"util.hpp\"\n#include \"context.hpp\"\n#include \"sass_context.hpp\"\n#include \"sass_functions.hpp\"\n#include \"ast_fwd_decl.hpp\"\n#include \"error_handling.hpp\"\n\n#define LFEED \"\\n\"\n\n// C++ helper\nnamespace Sass {\n // see sass_copy_c_string(std::string str)\n static inline JsonNode* json_mkstream(const std::stringstream& stream)\n {\n // hold on to string on stack!\n std::string str(stream.str());\n return json_mkstring(str.c_str());\n }\n\n static int handle_error(Sass_Context* c_ctx) {\n try {\n throw;\n }\n catch (Exception::Base& e) {\n std::stringstream msg_stream;\n std::string cwd(Sass::File::get_cwd());\n std::string msg_prefix(e.errtype());\n bool got_newline = false;\n msg_stream << msg_prefix << \": \";\n const char* msg = e.what();\n while (msg && *msg) {\n if (*msg == '\\r') {\n got_newline = true;\n }\n else if (*msg == '\\n') {\n got_newline = true;\n }\n else if (got_newline) {\n msg_stream << std::string(msg_prefix.size() + 2, ' ');\n got_newline = false;\n }\n msg_stream << *msg;\n ++msg;\n }\n if (!got_newline) msg_stream << \"\\n\";\n\n if (e.traces.empty()) {\n // we normally should have some traces, still here as a fallback\n std::string rel_path(Sass::File::abs2rel(e.pstate.path, cwd, cwd));\n msg_stream << std::string(msg_prefix.size() + 2, ' ');\n msg_stream << \" on line \" << e.pstate.line + 1 << \" of \" << rel_path << \"\\n\";\n }\n else {\n std::string rel_path(Sass::File::abs2rel(e.pstate.path, cwd, cwd));\n msg_stream << traces_to_string(e.traces, \" \");\n }\n\n // now create the code trace (ToDo: maybe have util functions?)\n if (e.pstate.line != std::string::npos && e.pstate.column != std::string::npos) {\n size_t lines = e.pstate.line;\n const char* line_beg = e.pstate.src;\n // scan through src until target line\n // move line_beg pointer to line start\n while (line_beg && *line_beg && lines != 0) {\n if (*line_beg == '\\n') --lines;\n utf8::unchecked::next(line_beg); \n }\n const char* line_end = line_beg;\n // move line_end before next newline character\n while (line_end && *line_end && *line_end != '\\n') {\n if (*line_end == '\\n') break;\n if (*line_end == '\\r') break;\n utf8::unchecked::next(line_end); \n }\n if (line_end && *line_end != 0) ++ line_end;\n size_t line_len = line_end - line_beg;\n size_t move_in = 0; size_t shorten = 0;\n size_t left_chars = 42; size_t max_chars = 76;\n // reported excerpt should not exceed `max_chars` chars\n if (e.pstate.column > line_len) left_chars = e.pstate.column;\n if (e.pstate.column > left_chars) move_in = e.pstate.column - left_chars;\n if (line_len > max_chars + move_in) shorten = line_len - move_in - max_chars;\n utf8::advance(line_beg, move_in, line_end);\n utf8::retreat(line_end, shorten, line_beg);\n std::string sanitized; std::string marker(e.pstate.column - move_in, '-');\n utf8::replace_invalid(line_beg, line_end, std::back_inserter(sanitized));\n msg_stream << \">> \" << sanitized << \"\\n\";\n msg_stream << \" \" << marker << \"^\\n\";\n }\n\n JsonNode* json_err = json_mkobject();\n json_append_member(json_err, \"status\", json_mknumber(1));\n json_append_member(json_err, \"file\", json_mkstring(e.pstate.path));\n json_append_member(json_err, \"line\", json_mknumber((double)(e.pstate.line + 1)));\n json_append_member(json_err, \"column\", json_mknumber((double)(e.pstate.column + 1)));\n json_append_member(json_err, \"message\", json_mkstring(e.what()));\n json_append_member(json_err, \"formatted\", json_mkstream(msg_stream));\n try { c_ctx->error_json = json_stringify(json_err, \" \"); }\n catch (...) {}\n c_ctx->error_message = sass_copy_string(msg_stream.str());\n c_ctx->error_text = sass_copy_c_string(e.what());\n c_ctx->error_status = 1;\n c_ctx->error_file = sass_copy_c_string(e.pstate.path);\n c_ctx->error_line = e.pstate.line + 1;\n c_ctx->error_column = e.pstate.column + 1;\n c_ctx->error_src = e.pstate.src;\n c_ctx->output_string = 0;\n c_ctx->source_map_string = 0;\n json_delete(json_err);\n }\n catch (std::bad_alloc& ba) {\n std::stringstream msg_stream;\n JsonNode* json_err = json_mkobject();\n msg_stream << \"Unable to allocate memory: \" << ba.what() << std::endl;\n json_append_member(json_err, \"status\", json_mknumber(2));\n json_append_member(json_err, \"message\", json_mkstring(ba.what()));\n json_append_member(json_err, \"formatted\", json_mkstream(msg_stream));\n try { c_ctx->error_json = json_stringify(json_err, \" \"); }\n catch (...) {}\n c_ctx->error_message = sass_copy_string(msg_stream.str());\n c_ctx->error_text = sass_copy_c_string(ba.what());\n c_ctx->error_status = 2;\n c_ctx->output_string = 0;\n c_ctx->source_map_string = 0;\n json_delete(json_err);\n }\n catch (std::exception& e) {\n std::stringstream msg_stream;\n JsonNode* json_err = json_mkobject();\n msg_stream << \"Internal Error: \" << e.what() << std::endl;\n json_append_member(json_err, \"status\", json_mknumber(3));\n json_append_member(json_err, \"message\", json_mkstring(e.what()));\n json_append_member(json_err, \"formatted\", json_mkstream(msg_stream));\n try { c_ctx->error_json = json_stringify(json_err, \" \"); }\n catch (...) {}\n c_ctx->error_message = sass_copy_string(msg_stream.str());\n c_ctx->error_text = sass_copy_c_string(e.what());\n c_ctx->error_status = 3;\n c_ctx->output_string = 0;\n c_ctx->source_map_string = 0;\n json_delete(json_err);\n }\n catch (std::string& e) {\n std::stringstream msg_stream;\n JsonNode* json_err = json_mkobject();\n msg_stream << \"Internal Error: \" << e << std::endl;\n json_append_member(json_err, \"status\", json_mknumber(4));\n json_append_member(json_err, \"message\", json_mkstring(e.c_str()));\n json_append_member(json_err, \"formatted\", json_mkstream(msg_stream));\n try { c_ctx->error_json = json_stringify(json_err, \" \"); }\n catch (...) {}\n c_ctx->error_message = sass_copy_string(msg_stream.str());\n c_ctx->error_text = sass_copy_c_string(e.c_str());\n c_ctx->error_status = 4;\n c_ctx->output_string = 0;\n c_ctx->source_map_string = 0;\n json_delete(json_err);\n }\n catch (const char* e) {\n std::stringstream msg_stream;\n JsonNode* json_err = json_mkobject();\n msg_stream << \"Internal Error: \" << e << std::endl;\n json_append_member(json_err, \"status\", json_mknumber(4));\n json_append_member(json_err, \"message\", json_mkstring(e));\n json_append_member(json_err, \"formatted\", json_mkstream(msg_stream));\n try { c_ctx->error_json = json_stringify(json_err, \" \"); }\n catch (...) {}\n c_ctx->error_message = sass_copy_string(msg_stream.str());\n c_ctx->error_text = sass_copy_c_string(e);\n c_ctx->error_status = 4;\n c_ctx->output_string = 0;\n c_ctx->source_map_string = 0;\n json_delete(json_err);\n }\n catch (...) {\n std::stringstream msg_stream;\n JsonNode* json_err = json_mkobject();\n msg_stream << \"Unknown error occurred\" << std::endl;\n json_append_member(json_err, \"status\", json_mknumber(5));\n json_append_member(json_err, \"message\", json_mkstring(\"unknown\"));\n try { c_ctx->error_json = json_stringify(json_err, \" \"); }\n catch (...) {}\n c_ctx->error_message = sass_copy_string(msg_stream.str());\n c_ctx->error_text = sass_copy_c_string(\"unknown\");\n c_ctx->error_status = 5;\n c_ctx->output_string = 0;\n c_ctx->source_map_string = 0;\n json_delete(json_err);\n }\n return c_ctx->error_status;\n }\n\n // allow one error handler to throw another error\n // this can happen with invalid utf8 and json lib\n static int handle_errors(Sass_Context* c_ctx) {\n try { return handle_error(c_ctx); }\n catch (...) { return handle_error(c_ctx); }\n }\n\n static Block_Obj sass_parse_block(Sass_Compiler* compiler) throw()\n {\n\n // assert valid pointer\n if (compiler == 0) return 0;\n // The cpp context must be set by now\n Context* cpp_ctx = compiler->cpp_ctx;\n Sass_Context* c_ctx = compiler->c_ctx;\n // We will take care to wire up the rest\n compiler->cpp_ctx->c_compiler = compiler;\n compiler->state = SASS_COMPILER_PARSED;\n\n try {\n\n // get input/output path from options\n std::string input_path = safe_str(c_ctx->input_path);\n std::string output_path = safe_str(c_ctx->output_path);\n\n // maybe skip some entries of included files\n // we do not include stdin for data contexts\n bool skip = c_ctx->type == SASS_CONTEXT_DATA;\n\n // dispatch parse call\n Block_Obj root(cpp_ctx->parse());\n // abort on errors\n if (!root) return 0;\n\n // skip all prefixed files? (ToDo: check srcmap)\n // IMO source-maps should point to headers already\n // therefore don't skip it for now. re-enable or\n // remove completely once this is tested\n size_t headers = cpp_ctx->head_imports;\n\n // copy the included files on to the context (dont forget to free later)\n if (copy_strings(cpp_ctx->get_included_files(skip, headers), &c_ctx->included_files) == NULL)\n throw(std::bad_alloc());\n\n // return parsed block\n return root;\n\n }\n // pass errors to generic error handler\n catch (...) { handle_errors(c_ctx); }\n\n // error\n return 0;\n\n }\n\n}\n\nextern \"C\" {\n using namespace Sass;\n\n static void sass_clear_options (struct Sass_Options* options);\n static void sass_reset_options (struct Sass_Options* options);\n static void copy_options(struct Sass_Options* to, struct Sass_Options* from) {\n // do not overwrite ourself\n if (to == from) return;\n // free assigned memory\n sass_clear_options(to);\n // move memory\n *to = *from;\n // Reset pointers on source\n sass_reset_options(from);\n }\n\n #define IMPLEMENT_SASS_OPTION_ACCESSOR(type, option) \\\n type ADDCALL sass_option_get_##option (struct Sass_Options* options) { return options->option; } \\\n void ADDCALL sass_option_set_##option (struct Sass_Options* options, type option) { options->option = option; }\n #define IMPLEMENT_SASS_OPTION_STRING_GETTER(type, option, def) \\\n type ADDCALL sass_option_get_##option (struct Sass_Options* options) { return safe_str(options->option, def); }\n #define IMPLEMENT_SASS_OPTION_STRING_SETTER(type, option, def) \\\n void ADDCALL sass_option_set_##option (struct Sass_Options* options, type option) \\\n { free(options->option); options->option = option || def ? sass_copy_c_string(option ? option : def) : 0; }\n #define IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(type, option, def) \\\n IMPLEMENT_SASS_OPTION_STRING_GETTER(type, option, def) \\\n IMPLEMENT_SASS_OPTION_STRING_SETTER(type, option, def)\n\n #define IMPLEMENT_SASS_CONTEXT_GETTER(type, option) \\\n type ADDCALL sass_context_get_##option (struct Sass_Context* ctx) { return ctx->option; }\n #define IMPLEMENT_SASS_CONTEXT_TAKER(type, option) \\\n type sass_context_take_##option (struct Sass_Context* ctx) \\\n { type foo = ctx->option; ctx->option = 0; return foo; }\n\n\n // generic compilation function (not exported, use file/data compile instead)\n static Sass_Compiler* sass_prepare_context (Sass_Context* c_ctx, Context* cpp_ctx) throw()\n {\n try {\n // register our custom functions\n if (c_ctx->c_functions) {\n auto this_func_data = c_ctx->c_functions;\n while (this_func_data && *this_func_data) {\n cpp_ctx->add_c_function(*this_func_data);\n ++this_func_data;\n }\n }\n\n // register our custom headers\n if (c_ctx->c_headers) {\n auto this_head_data = c_ctx->c_headers;\n while (this_head_data && *this_head_data) {\n cpp_ctx->add_c_header(*this_head_data);\n ++this_head_data;\n }\n }\n\n // register our custom importers\n if (c_ctx->c_importers) {\n auto this_imp_data = c_ctx->c_importers;\n while (this_imp_data && *this_imp_data) {\n cpp_ctx->add_c_importer(*this_imp_data);\n ++this_imp_data;\n }\n }\n\n // reset error status\n c_ctx->error_json = 0;\n c_ctx->error_text = 0;\n c_ctx->error_message = 0;\n c_ctx->error_status = 0;\n // reset error position\n c_ctx->error_src = 0;\n c_ctx->error_file = 0;\n c_ctx->error_line = std::string::npos;\n c_ctx->error_column = std::string::npos;\n\n // allocate a new compiler instance\n void* ctxmem = calloc(1, sizeof(struct Sass_Compiler));\n if (ctxmem == 0) { std::cerr << \"Error allocating memory for context\" << std::endl; return 0; }\n Sass_Compiler* compiler = (struct Sass_Compiler*) ctxmem;\n compiler->state = SASS_COMPILER_CREATED;\n\n // store in sass compiler\n compiler->c_ctx = c_ctx;\n compiler->cpp_ctx = cpp_ctx;\n cpp_ctx->c_compiler = compiler;\n\n // use to parse block\n return compiler;\n\n }\n // pass errors to generic error handler\n catch (...) { handle_errors(c_ctx); }\n\n // error\n return 0;\n\n }\n\n // generic compilation function (not exported, use file/data compile instead)\n static int sass_compile_context (Sass_Context* c_ctx, Context* cpp_ctx)\n {\n\n // prepare sass compiler with context and options\n Sass_Compiler* compiler = sass_prepare_context(c_ctx, cpp_ctx);\n\n try {\n // call each compiler step\n sass_compiler_parse(compiler);\n sass_compiler_execute(compiler);\n }\n // pass errors to generic error handler\n catch (...) { handle_errors(c_ctx); }\n\n sass_delete_compiler(compiler);\n\n return c_ctx->error_status;\n }\n\n inline void init_options (struct Sass_Options* options)\n {\n options->precision = 5;\n options->indent = \" \";\n options->linefeed = LFEED;\n }\n\n Sass_Options* ADDCALL sass_make_options (void)\n {\n struct Sass_Options* options = (struct Sass_Options*) calloc(1, sizeof(struct Sass_Options));\n if (options == 0) { std::cerr << \"Error allocating memory for options\" << std::endl; return 0; }\n init_options(options);\n return options;\n }\n\n Sass_File_Context* ADDCALL sass_make_file_context(const char* input_path)\n {\n SharedObj::setTaint(true); // needed for static colors\n struct Sass_File_Context* ctx = (struct Sass_File_Context*) calloc(1, sizeof(struct Sass_File_Context));\n if (ctx == 0) { std::cerr << \"Error allocating memory for file context\" << std::endl; return 0; }\n ctx->type = SASS_CONTEXT_FILE;\n init_options(ctx);\n try {\n if (input_path == 0) { throw(std::runtime_error(\"File context created without an input path\")); }\n if (*input_path == 0) { throw(std::runtime_error(\"File context created with empty input path\")); }\n sass_option_set_input_path(ctx, input_path);\n } catch (...) {\n handle_errors(ctx);\n }\n return ctx;\n }\n\n Sass_Data_Context* ADDCALL sass_make_data_context(char* source_string)\n {\n struct Sass_Data_Context* ctx = (struct Sass_Data_Context*) calloc(1, sizeof(struct Sass_Data_Context));\n if (ctx == 0) { std::cerr << \"Error allocating memory for data context\" << std::endl; return 0; }\n ctx->type = SASS_CONTEXT_DATA;\n init_options(ctx);\n try {\n if (source_string == 0) { throw(std::runtime_error(\"Data context created without a source string\")); }\n if (*source_string == 0) { throw(std::runtime_error(\"Data context created with empty source string\")); }\n ctx->source_string = source_string;\n } catch (...) {\n handle_errors(ctx);\n }\n return ctx;\n }\n\n struct Sass_Compiler* ADDCALL sass_make_data_compiler (struct Sass_Data_Context* data_ctx)\n {\n if (data_ctx == 0) return 0;\n Context* cpp_ctx = new Data_Context(*data_ctx);\n return sass_prepare_context(data_ctx, cpp_ctx);\n }\n\n struct Sass_Compiler* ADDCALL sass_make_file_compiler (struct Sass_File_Context* file_ctx)\n {\n if (file_ctx == 0) return 0;\n Context* cpp_ctx = new File_Context(*file_ctx);\n return sass_prepare_context(file_ctx, cpp_ctx);\n }\n\n int ADDCALL sass_compile_data_context(Sass_Data_Context* data_ctx)\n {\n if (data_ctx == 0) return 1;\n if (data_ctx->error_status)\n return data_ctx->error_status;\n try {\n if (data_ctx->source_string == 0) { throw(std::runtime_error(\"Data context has no source string\")); }\n // empty source string is a valid case, even if not really usefull (different than with file context)\n // if (*data_ctx->source_string == 0) { throw(std::runtime_error(\"Data context has empty source string\")); }\n }\n catch (...) { return handle_errors(data_ctx) | 1; }\n Context* cpp_ctx = new Data_Context(*data_ctx);\n return sass_compile_context(data_ctx, cpp_ctx);\n }\n\n int ADDCALL sass_compile_file_context(Sass_File_Context* file_ctx)\n {\n if (file_ctx == 0) return 1;\n if (file_ctx->error_status)\n return file_ctx->error_status;\n try {\n if (file_ctx->input_path == 0) { throw(std::runtime_error(\"File context has no input path\")); }\n if (*file_ctx->input_path == 0) { throw(std::runtime_error(\"File context has empty input path\")); }\n }\n catch (...) { return handle_errors(file_ctx) | 1; }\n Context* cpp_ctx = new File_Context(*file_ctx);\n return sass_compile_context(file_ctx, cpp_ctx);\n }\n\n int ADDCALL sass_compiler_parse(struct Sass_Compiler* compiler)\n {\n if (compiler == 0) return 1;\n if (compiler->state == SASS_COMPILER_PARSED) return 0;\n if (compiler->state != SASS_COMPILER_CREATED) return -1;\n if (compiler->c_ctx == NULL) return 1;\n if (compiler->cpp_ctx == NULL) return 1;\n if (compiler->c_ctx->error_status)\n return compiler->c_ctx->error_status;\n // parse the context we have set up (file or data)\n compiler->root = sass_parse_block(compiler);\n // success\n return 0;\n }\n\n int ADDCALL sass_compiler_execute(struct Sass_Compiler* compiler)\n {\n if (compiler == 0) return 1;\n if (compiler->state == SASS_COMPILER_EXECUTED) return 0;\n if (compiler->state != SASS_COMPILER_PARSED) return -1;\n if (compiler->c_ctx == NULL) return 1;\n if (compiler->cpp_ctx == NULL) return 1;\n if (compiler->root.isNull()) return 1;\n if (compiler->c_ctx->error_status)\n return compiler->c_ctx->error_status;\n compiler->state = SASS_COMPILER_EXECUTED;\n Context* cpp_ctx = compiler->cpp_ctx;\n Block_Obj root = compiler->root;\n // compile the parsed root block\n try { compiler->c_ctx->output_string = cpp_ctx->render(root); }\n // pass catched errors to generic error handler\n catch (...) { return handle_errors(compiler->c_ctx) | 1; }\n // generate source map json and store on context\n compiler->c_ctx->source_map_string = cpp_ctx->render_srcmap();\n // success\n return 0;\n }\n\n // helper function, not exported, only accessible locally\n static void sass_reset_options (struct Sass_Options* options)\n {\n // free pointer before\n // or copy/move them\n options->input_path = 0;\n options->output_path = 0;\n options->plugin_path = 0;\n options->include_path = 0;\n options->source_map_file = 0;\n options->source_map_root = 0;\n options->c_functions = 0;\n options->c_importers = 0;\n options->c_headers = 0;\n options->plugin_paths = 0;\n options->include_paths = 0;\n }\n\n // helper function, not exported, only accessible locally\n static void sass_clear_options (struct Sass_Options* options)\n {\n if (options == 0) return;\n // Deallocate custom functions, headers and importes\n sass_delete_function_list(options->c_functions);\n sass_delete_importer_list(options->c_importers);\n sass_delete_importer_list(options->c_headers);\n // Deallocate inc paths\n if (options->plugin_paths) {\n struct string_list* cur;\n struct string_list* next;\n cur = options->plugin_paths;\n while (cur) {\n next = cur->next;\n free(cur->string);\n free(cur);\n cur = next;\n }\n }\n // Deallocate inc paths\n if (options->include_paths) {\n struct string_list* cur;\n struct string_list* next;\n cur = options->include_paths;\n while (cur) {\n next = cur->next;\n free(cur->string);\n free(cur);\n cur = next;\n }\n }\n // Free options strings\n free(options->input_path);\n free(options->output_path);\n free(options->plugin_path);\n free(options->include_path);\n free(options->source_map_file);\n free(options->source_map_root);\n // Reset our pointers\n options->input_path = 0;\n options->output_path = 0;\n options->plugin_path = 0;\n options->include_path = 0;\n options->source_map_file = 0;\n options->source_map_root = 0;\n options->c_functions = 0;\n options->c_importers = 0;\n options->c_headers = 0;\n options->plugin_paths = 0;\n options->include_paths = 0;\n }\n\n // helper function, not exported, only accessible locally\n // sass_free_context is also defined in old sass_interface\n static void sass_clear_context (struct Sass_Context* ctx)\n {\n if (ctx == 0) return;\n // release the allocated memory (mostly via sass_copy_c_string)\n if (ctx->output_string) free(ctx->output_string);\n if (ctx->source_map_string) free(ctx->source_map_string);\n if (ctx->error_message) free(ctx->error_message);\n if (ctx->error_text) free(ctx->error_text);\n if (ctx->error_json) free(ctx->error_json);\n if (ctx->error_file) free(ctx->error_file);\n free_string_array(ctx->included_files);\n // play safe and reset properties\n ctx->output_string = 0;\n ctx->source_map_string = 0;\n ctx->error_message = 0;\n ctx->error_text = 0;\n ctx->error_json = 0;\n ctx->error_file = 0;\n ctx->included_files = 0;\n // debug leaked memory\n #ifdef DEBUG_SHARED_PTR\n SharedObj::dumpMemLeaks();\n #endif\n // now clear the options\n sass_clear_options(ctx);\n }\n\n void ADDCALL sass_delete_compiler (struct Sass_Compiler* compiler)\n {\n if (compiler == 0) {\n return;\n }\n Context* cpp_ctx = compiler->cpp_ctx;\n if (cpp_ctx) delete(cpp_ctx);\n compiler->cpp_ctx = NULL;\n compiler->c_ctx = NULL;\n compiler->root = NULL;\n free(compiler);\n }\n\n void ADDCALL sass_delete_options (struct Sass_Options* options)\n {\n sass_clear_options(options); free(options);\n }\n\n // Deallocate all associated memory with file context\n void ADDCALL sass_delete_file_context (struct Sass_File_Context* ctx)\n {\n // clear the context and free it\n sass_clear_context(ctx); free(ctx);\n }\n // Deallocate all associated memory with data context\n void ADDCALL sass_delete_data_context (struct Sass_Data_Context* ctx)\n {\n // clean the source string if it was not passed\n // we reset this member once we start parsing\n if (ctx->source_string) free(ctx->source_string);\n // clear the context and free it\n sass_clear_context(ctx); free(ctx);\n }\n\n // Getters for sass context from specific implementations\n struct Sass_Context* ADDCALL sass_file_context_get_context(struct Sass_File_Context* ctx) { return ctx; }\n struct Sass_Context* ADDCALL sass_data_context_get_context(struct Sass_Data_Context* ctx) { return ctx; }\n\n // Getters for context options from Sass_Context\n struct Sass_Options* ADDCALL sass_context_get_options(struct Sass_Context* ctx) { return ctx; }\n struct Sass_Options* ADDCALL sass_file_context_get_options(struct Sass_File_Context* ctx) { return ctx; }\n struct Sass_Options* ADDCALL sass_data_context_get_options(struct Sass_Data_Context* ctx) { return ctx; }\n void ADDCALL sass_file_context_set_options (struct Sass_File_Context* ctx, struct Sass_Options* opt) { copy_options(ctx, opt); }\n void ADDCALL sass_data_context_set_options (struct Sass_Data_Context* ctx, struct Sass_Options* opt) { copy_options(ctx, opt); }\n\n // Getters for Sass_Compiler options (get conected sass context)\n enum Sass_Compiler_State ADDCALL sass_compiler_get_state(struct Sass_Compiler* compiler) { return compiler->state; }\n struct Sass_Context* ADDCALL sass_compiler_get_context(struct Sass_Compiler* compiler) { return compiler->c_ctx; }\n struct Sass_Options* ADDCALL sass_compiler_get_options(struct Sass_Compiler* compiler) { return compiler->c_ctx; }\n // Getters for Sass_Compiler options (query import stack)\n size_t ADDCALL sass_compiler_get_import_stack_size(struct Sass_Compiler* compiler) { return compiler->cpp_ctx->import_stack.size(); }\n Sass_Import_Entry ADDCALL sass_compiler_get_last_import(struct Sass_Compiler* compiler) { return compiler->cpp_ctx->import_stack.back(); }\n Sass_Import_Entry ADDCALL sass_compiler_get_import_entry(struct Sass_Compiler* compiler, size_t idx) { return compiler->cpp_ctx->import_stack[idx]; }\n // Getters for Sass_Compiler options (query function stack)\n size_t ADDCALL sass_compiler_get_callee_stack_size(struct Sass_Compiler* compiler) { return compiler->cpp_ctx->callee_stack.size(); }\n Sass_Callee_Entry ADDCALL sass_compiler_get_last_callee(struct Sass_Compiler* compiler) { return &compiler->cpp_ctx->callee_stack.back(); }\n Sass_Callee_Entry ADDCALL sass_compiler_get_callee_entry(struct Sass_Compiler* compiler, size_t idx) { return &compiler->cpp_ctx->callee_stack[idx]; }\n\n // Calculate the size of the stored null terminated array\n size_t ADDCALL sass_context_get_included_files_size (struct Sass_Context* ctx)\n { size_t l = 0; auto i = ctx->included_files; while (i && *i) { ++i; ++l; } return l; }\n\n // Create getter and setters for options\n IMPLEMENT_SASS_OPTION_ACCESSOR(int, precision);\n IMPLEMENT_SASS_OPTION_ACCESSOR(enum Sass_Output_Style, output_style);\n IMPLEMENT_SASS_OPTION_ACCESSOR(bool, source_comments);\n IMPLEMENT_SASS_OPTION_ACCESSOR(bool, source_map_embed);\n IMPLEMENT_SASS_OPTION_ACCESSOR(bool, source_map_contents);\n IMPLEMENT_SASS_OPTION_ACCESSOR(bool, source_map_file_urls);\n IMPLEMENT_SASS_OPTION_ACCESSOR(bool, omit_source_map_url);\n IMPLEMENT_SASS_OPTION_ACCESSOR(bool, is_indented_syntax_src);\n IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_Function_List, c_functions);\n IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_Importer_List, c_importers);\n IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_Importer_List, c_headers);\n IMPLEMENT_SASS_OPTION_ACCESSOR(const char*, indent);\n IMPLEMENT_SASS_OPTION_ACCESSOR(const char*, linefeed);\n IMPLEMENT_SASS_OPTION_STRING_SETTER(const char*, plugin_path, 0);\n IMPLEMENT_SASS_OPTION_STRING_SETTER(const char*, include_path, 0);\n IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, input_path, 0);\n IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, output_path, 0);\n IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, source_map_file, 0);\n IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, source_map_root, 0);\n\n // Create getter and setters for context\n IMPLEMENT_SASS_CONTEXT_GETTER(int, error_status);\n IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_json);\n IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_message);\n IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_text);\n IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_file);\n IMPLEMENT_SASS_CONTEXT_GETTER(size_t, error_line);\n IMPLEMENT_SASS_CONTEXT_GETTER(size_t, error_column);\n IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_src);\n IMPLEMENT_SASS_CONTEXT_GETTER(const char*, output_string);\n IMPLEMENT_SASS_CONTEXT_GETTER(const char*, source_map_string);\n IMPLEMENT_SASS_CONTEXT_GETTER(char**, included_files);\n\n // Take ownership of memory (value on context is set to 0)\n IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_json);\n IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_message);\n IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_text);\n IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_file);\n IMPLEMENT_SASS_CONTEXT_TAKER(char*, output_string);\n IMPLEMENT_SASS_CONTEXT_TAKER(char*, source_map_string);\n IMPLEMENT_SASS_CONTEXT_TAKER(char**, included_files);\n\n // Push function for include paths (no manipulation support for now)\n void ADDCALL sass_option_push_include_path(struct Sass_Options* options, const char* path)\n {\n\n struct string_list* include_path = (struct string_list*) calloc(1, sizeof(struct string_list));\n if (include_path == 0) return;\n include_path->string = path ? sass_copy_c_string(path) : 0;\n struct string_list* last = options->include_paths;\n if (!options->include_paths) {\n options->include_paths = include_path;\n } else {\n while (last->next)\n last = last->next;\n last->next = include_path;\n }\n\n }\n\n // Push function for include paths (no manipulation support for now)\n size_t ADDCALL sass_option_get_include_path_size(struct Sass_Options* options)\n {\n size_t len = 0;\n struct string_list* cur = options->include_paths;\n while (cur) { len ++; cur = cur->next; }\n return len;\n }\n\n // Push function for include paths (no manipulation support for now)\n const char* ADDCALL sass_option_get_include_path(struct Sass_Options* options, size_t i)\n {\n struct string_list* cur = options->include_paths;\n while (i) { i--; cur = cur->next; }\n return cur->string;\n }\n\n // Push function for plugin paths (no manipulation support for now)\n void ADDCALL sass_option_push_plugin_path(struct Sass_Options* options, const char* path)\n {\n\n struct string_list* plugin_path = (struct string_list*) calloc(1, sizeof(struct string_list));\n if (plugin_path == 0) return;\n plugin_path->string = path ? sass_copy_c_string(path) : 0;\n struct string_list* last = options->plugin_paths;\n if (!options->plugin_paths) {\n options->plugin_paths = plugin_path;\n } else {\n while (last->next)\n last = last->next;\n last->next = plugin_path;\n }\n\n }\n\n}\n" }, { "path": "libsass-build/sass_context.hpp", "content": "#ifndef SASS_SASS_CONTEXT_H\n#define SASS_SASS_CONTEXT_H\n\n#include \"sass/base.h\"\n#include \"sass/context.h\"\n#include \"ast_fwd_decl.hpp\"\n\n// sass config options structure\nstruct Sass_Options : Sass_Output_Options {\n\n // embed sourceMappingUrl as data uri\n bool source_map_embed;\n\n // embed include contents in maps\n bool source_map_contents;\n\n // create file urls for sources\n bool source_map_file_urls;\n\n // Disable sourceMappingUrl in css output\n bool omit_source_map_url;\n\n // Treat source_string as sass (as opposed to scss)\n bool is_indented_syntax_src;\n\n // The input path is used for source map\n // generation. It can be used to define\n // something with string compilation or to\n // overload the input file path. It is\n // set to \"stdin\" for data contexts and\n // to the input file on file contexts.\n char* input_path;\n\n // The output path is used for source map\n // generation. LibSass will not write to\n // this file, it is just used to create\n // information in source-maps etc.\n char* output_path;\n\n // Colon-separated list of paths\n // Semicolon-separated on Windows\n // Maybe use array interface instead?\n char* include_path;\n char* plugin_path;\n\n // Include paths (linked string list)\n struct string_list* include_paths;\n // Plugin paths (linked string list)\n struct string_list* plugin_paths;\n\n // Path to source map file\n // Enables source map generation\n // Used to create sourceMappingUrl\n char* source_map_file;\n\n // Directly inserted in source maps\n char* source_map_root;\n\n // Custom functions that can be called from sccs code\n Sass_Function_List c_functions;\n\n // List of custom importers\n Sass_Importer_List c_importers;\n\n // List of custom headers\n Sass_Importer_List c_headers;\n\n};\n\n\n// base for all contexts\nstruct Sass_Context : Sass_Options\n{\n\n // store context type info\n enum Sass_Input_Style type;\n\n // generated output data\n char* output_string;\n\n // generated source map json\n char* source_map_string;\n\n // error status\n int error_status;\n char* error_json;\n char* error_text;\n char* error_message;\n // error position\n char* error_file;\n size_t error_line;\n size_t error_column;\n const char* error_src;\n\n // report imported files\n char** included_files;\n\n};\n\n// struct for file compilation\nstruct Sass_File_Context : Sass_Context {\n\n // no additional fields required\n // input_path is already on options\n\n};\n\n// struct for data compilation\nstruct Sass_Data_Context : Sass_Context {\n\n // provided source string\n char* source_string;\n char* srcmap_string;\n\n};\n\n// link c and cpp context\nstruct Sass_Compiler {\n // progress status\n Sass_Compiler_State state;\n // original c context\n Sass_Context* c_ctx;\n // Sass::Context\n Sass::Context* cpp_ctx;\n // Sass::Block\n Sass::Block_Obj root;\n};\n\n#endif" }, { "path": "libsass-build/sass_functions.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \"util.hpp\"\n#include \"context.hpp\"\n#include \"values.hpp\"\n#include \"sass/functions.h\"\n#include \"sass_functions.hpp\"\n\nextern \"C\" {\n using namespace Sass;\n\n Sass_Function_List ADDCALL sass_make_function_list(size_t length)\n {\n return (Sass_Function_List) calloc(length + 1, sizeof(Sass_Function_Entry));\n }\n\n Sass_Function_Entry ADDCALL sass_make_function(const char* signature, Sass_Function_Fn function, void* cookie)\n {\n Sass_Function_Entry cb = (Sass_Function_Entry) calloc(1, sizeof(Sass_Function));\n if (cb == 0) return 0;\n cb->signature = sass_copy_c_string(signature);\n cb->function = function;\n cb->cookie = cookie;\n return cb;\n }\n\n void ADDCALL sass_delete_function(Sass_Function_Entry entry)\n {\n free(entry->signature);\n free(entry);\n }\n\n // Deallocator for the allocated memory\n void ADDCALL sass_delete_function_list(Sass_Function_List list)\n {\n Sass_Function_List it = list;\n if (list == 0) return;\n while(*list) {\n sass_delete_function(*list);\n ++list;\n }\n free(it);\n }\n\n // Setters and getters for callbacks on function lists\n Sass_Function_Entry ADDCALL sass_function_get_list_entry(Sass_Function_List list, size_t pos) { return list[pos]; }\n void sass_function_set_list_entry(Sass_Function_List list, size_t pos, Sass_Function_Entry cb) { list[pos] = cb; }\n\n const char* ADDCALL sass_function_get_signature(Sass_Function_Entry cb) { return cb->signature; }\n Sass_Function_Fn ADDCALL sass_function_get_function(Sass_Function_Entry cb) { return cb->function; }\n void* ADDCALL sass_function_get_cookie(Sass_Function_Entry cb) { return cb->cookie; }\n\n Sass_Importer_Entry ADDCALL sass_make_importer(Sass_Importer_Fn importer, double priority, void* cookie)\n {\n Sass_Importer_Entry cb = (Sass_Importer_Entry) calloc(1, sizeof(Sass_Importer));\n if (cb == 0) return 0;\n cb->importer = importer;\n cb->priority = priority;\n cb->cookie = cookie;\n return cb;\n }\n\n Sass_Importer_Fn ADDCALL sass_importer_get_function(Sass_Importer_Entry cb) { return cb->importer; }\n double ADDCALL sass_importer_get_priority (Sass_Importer_Entry cb) { return cb->priority; }\n void* ADDCALL sass_importer_get_cookie(Sass_Importer_Entry cb) { return cb->cookie; }\n\n // Just in case we have some stray import structs\n void ADDCALL sass_delete_importer (Sass_Importer_Entry cb)\n {\n free(cb);\n }\n\n // Creator for sass custom importer function list\n Sass_Importer_List ADDCALL sass_make_importer_list(size_t length)\n {\n return (Sass_Importer_List) calloc(length + 1, sizeof(Sass_Importer_Entry));\n }\n\n // Deallocator for the allocated memory\n void ADDCALL sass_delete_importer_list(Sass_Importer_List list)\n {\n Sass_Importer_List it = list;\n if (list == 0) return;\n while(*list) {\n sass_delete_importer(*list);\n ++list;\n }\n free(it);\n }\n\n Sass_Importer_Entry ADDCALL sass_importer_get_list_entry(Sass_Importer_List list, size_t idx) { return list[idx]; }\n void ADDCALL sass_importer_set_list_entry(Sass_Importer_List list, size_t idx, Sass_Importer_Entry cb) { list[idx] = cb; }\n\n // Creator for sass custom importer return argument list\n Sass_Import_List ADDCALL sass_make_import_list(size_t length)\n {\n return (Sass_Import**) calloc(length + 1, sizeof(Sass_Import*));\n }\n\n // Creator for a single import entry returned by the custom importer inside the list\n // We take ownership of the memory for source and srcmap (freed when context is destroyd)\n Sass_Import_Entry ADDCALL sass_make_import(const char* imp_path, const char* abs_path, char* source, char* srcmap)\n {\n Sass_Import* v = (Sass_Import*) calloc(1, sizeof(Sass_Import));\n if (v == 0) return 0;\n v->imp_path = imp_path ? sass_copy_c_string(imp_path) : 0;\n v->abs_path = abs_path ? sass_copy_c_string(abs_path) : 0;\n v->source = source;\n v->srcmap = srcmap;\n v->error = 0;\n v->line = -1;\n v->column = -1;\n return v;\n }\n\n // Older style, but somehow still valid - keep around or deprecate?\n Sass_Import_Entry ADDCALL sass_make_import_entry(const char* path, char* source, char* srcmap)\n {\n return sass_make_import(path, path, source, srcmap);\n }\n\n // Upgrade a normal import entry to throw an error (original path can be re-used by error reporting)\n Sass_Import_Entry ADDCALL sass_import_set_error(Sass_Import_Entry import, const char* error, size_t line, size_t col)\n {\n if (import == 0) return 0;\n if (import->error) free(import->error);\n import->error = error ? sass_copy_c_string(error) : 0;\n import->line = line ? line : -1;\n import->column = col ? col : -1;\n return import;\n }\n\n // Setters and getters for entries on the import list\n void ADDCALL sass_import_set_list_entry(Sass_Import_List list, size_t idx, Sass_Import_Entry entry) { list[idx] = entry; }\n Sass_Import_Entry ADDCALL sass_import_get_list_entry(Sass_Import_List list, size_t idx) { return list[idx]; }\n\n // Deallocator for the allocated memory\n void ADDCALL sass_delete_import_list(Sass_Import_List list)\n {\n Sass_Import_List it = list;\n if (list == 0) return;\n while(*list) {\n sass_delete_import(*list);\n ++list;\n }\n free(it);\n }\n\n // Just in case we have some stray import structs\n void ADDCALL sass_delete_import(Sass_Import_Entry import)\n {\n free(import->imp_path);\n free(import->abs_path);\n free(import->source);\n free(import->srcmap);\n free(import->error);\n free(import);\n }\n\n // Getter for callee entry\n const char* ADDCALL sass_callee_get_name(Sass_Callee_Entry entry) { return entry->name; }\n const char* ADDCALL sass_callee_get_path(Sass_Callee_Entry entry) { return entry->path; }\n size_t ADDCALL sass_callee_get_line(Sass_Callee_Entry entry) { return entry->line; }\n size_t ADDCALL sass_callee_get_column(Sass_Callee_Entry entry) { return entry->column; }\n enum Sass_Callee_Type ADDCALL sass_callee_get_type(Sass_Callee_Entry entry) { return entry->type; }\n Sass_Env_Frame ADDCALL sass_callee_get_env (Sass_Callee_Entry entry) { return &entry->env; }\n\n // Getters and Setters for environments (lexical, local and global)\n union Sass_Value* ADDCALL sass_env_get_lexical (Sass_Env_Frame env, const char* name) {\n Expression_Ptr ex = Cast((*env->frame)[name]);\n return ex != NULL ? ast_node_to_sass_value(ex) : NULL;\n }\n void ADDCALL sass_env_set_lexical (Sass_Env_Frame env, const char* name, union Sass_Value* val) {\n (*env->frame)[name] = sass_value_to_ast_node(val);\n }\n union Sass_Value* ADDCALL sass_env_get_local (Sass_Env_Frame env, const char* name) {\n Expression_Ptr ex = Cast(env->frame->get_local(name));\n return ex != NULL ? ast_node_to_sass_value(ex) : NULL;\n }\n void ADDCALL sass_env_set_local (Sass_Env_Frame env, const char* name, union Sass_Value* val) {\n env->frame->set_local(name, sass_value_to_ast_node(val));\n }\n union Sass_Value* ADDCALL sass_env_get_global (Sass_Env_Frame env, const char* name) {\n Expression_Ptr ex = Cast(env->frame->get_global(name));\n return ex != NULL ? ast_node_to_sass_value(ex) : NULL;\n }\n void ADDCALL sass_env_set_global (Sass_Env_Frame env, const char* name, union Sass_Value* val) {\n env->frame->set_global(name, sass_value_to_ast_node(val));\n }\n\n // Getter for import entry\n const char* ADDCALL sass_import_get_imp_path(Sass_Import_Entry entry) { return entry->imp_path; }\n const char* ADDCALL sass_import_get_abs_path(Sass_Import_Entry entry) { return entry->abs_path; }\n const char* ADDCALL sass_import_get_source(Sass_Import_Entry entry) { return entry->source; }\n const char* ADDCALL sass_import_get_srcmap(Sass_Import_Entry entry) { return entry->srcmap; }\n\n // Getter for import error entry\n size_t ADDCALL sass_import_get_error_line(Sass_Import_Entry entry) { return entry->line; }\n size_t ADDCALL sass_import_get_error_column(Sass_Import_Entry entry) { return entry->column; }\n const char* ADDCALL sass_import_get_error_message(Sass_Import_Entry entry) { return entry->error; }\n\n // Explicit functions to take ownership of the memory\n // Resets our own property since we do not know if it is still alive\n char* ADDCALL sass_import_take_source(Sass_Import_Entry entry) { char* ptr = entry->source; entry->source = 0; return ptr; }\n char* ADDCALL sass_import_take_srcmap(Sass_Import_Entry entry) { char* ptr = entry->srcmap; entry->srcmap = 0; return ptr; }\n\n}\n" }, { "path": "libsass-build/sass_functions.hpp", "content": "#ifndef SASS_SASS_FUNCTIONS_H\n#define SASS_SASS_FUNCTIONS_H\n\n#include \"sass.h\"\n#include \"environment.hpp\"\n#include \"functions.hpp\"\n\n// Struct to hold custom function callback\nstruct Sass_Function {\n char* signature;\n Sass_Function_Fn function;\n void* cookie;\n};\n\n// External import entry\nstruct Sass_Import {\n char* imp_path; // path as found in the import statement\n char *abs_path; // path after importer has resolved it\n char* source;\n char* srcmap;\n // error handling\n char* error;\n size_t line;\n size_t column;\n};\n\n// External environments\nstruct Sass_Env {\n // links to parent frames\n Sass::Env* frame;\n};\n\n// External call entry\nstruct Sass_Callee {\n const char* name;\n const char* path;\n size_t line;\n size_t column;\n enum Sass_Callee_Type type;\n struct Sass_Env env;\n};\n\n// Struct to hold importer callback\nstruct Sass_Importer {\n Sass_Importer_Fn importer;\n double priority;\n void* cookie;\n};\n\n#endif" }, { "path": "libsass-build/sass_util.cpp", "content": "#include \"sass.hpp\"\n#include \"node.hpp\"\n\nnamespace Sass {\n\n\n /*\n # This is the equivalent of ruby's Sass::Util.paths.\n #\n # Return an array of all possible paths through the given arrays.\n #\n # @param arrs [NodeCollection>]\n # @return [NodeCollection>]\n #\n # @example\n # paths([[1, 2], [3, 4], [5]]) #=>\n # # [[1, 3, 5],\n # # [2, 3, 5],\n # # [1, 4, 5],\n # # [2, 4, 5]]\n\n The following is the modified version of the ruby code that was more portable to C++. You\n should be able to drop it into ruby 3.2.19 and get the same results from ruby sass.\n\n def paths(arrs)\n // I changed the inject and maps to an iterative approach to make it easier to implement in C++\n loopStart = [[]]\n\n for arr in arrs do\n permutations = []\n for e in arr do\n for path in loopStart do\n permutations.push(path + [e])\n end\n end\n loopStart = permutations\n end\n end\n */\n Node paths(const Node& arrs) {\n\n Node loopStart = Node::createCollection();\n loopStart.collection()->push_back(Node::createCollection());\n\n for (NodeDeque::iterator arrsIter = arrs.collection()->begin(), arrsEndIter = arrs.collection()->end();\n \tarrsIter != arrsEndIter; ++arrsIter) {\n\n Node& arr = *arrsIter;\n\n Node permutations = Node::createCollection();\n\n for (NodeDeque::iterator arrIter = arr.collection()->begin(), arrIterEnd = arr.collection()->end();\n \tarrIter != arrIterEnd; ++arrIter) {\n\n Node& e = *arrIter;\n\n for (NodeDeque::iterator loopStartIter = loopStart.collection()->begin(), loopStartIterEnd = loopStart.collection()->end();\n loopStartIter != loopStartIterEnd; ++loopStartIter) {\n\n Node& path = *loopStartIter;\n\n Node newPermutation = Node::createCollection();\n newPermutation.got_line_feed = arr.got_line_feed;\n newPermutation.plus(path);\n newPermutation.collection()->push_back(e);\n\n permutations.collection()->push_back(newPermutation);\n }\n }\n\n loopStart = permutations;\n }\n\n return loopStart;\n }\n\n\n /*\n This is the equivalent of ruby sass' Sass::Util.flatten and [].flatten.\n Sass::Util.flatten requires the number of levels to flatten, while\n [].flatten doesn't and will flatten the entire array. This function\n supports both.\n\n # Flattens the first `n` nested arrays. If n == -1, all arrays will be flattened\n #\n # @param arr [NodeCollection] The array to flatten\n # @param n [int] The number of levels to flatten\n # @return [NodeCollection] The flattened array\n\n The following is the modified version of the ruby code that was more portable to C++. You\n should be able to drop it into ruby 3.2.19 and get the same results from ruby sass.\n\n def flatten(arr, n = -1)\n if n != -1 and n == 0 then\n return arr\n end\n\n flattened = []\n\n for e in arr do\n if e.is_a?(Array) then\n flattened.concat(flatten(e, n - 1))\n else\n flattened << e\n end\n end\n\n return flattened\n end\n */\n Node flatten(Node& arr, int n) {\n if (n != -1 && n == 0) {\n return arr;\n }\n\n Node flattened = Node::createCollection();\n if (arr.got_line_feed) flattened.got_line_feed = true;\n\n for (NodeDeque::iterator iter = arr.collection()->begin(), iterEnd = arr.collection()->end();\n \titer != iterEnd; iter++) {\n \tNode& e = *iter;\n\n // e has the lf set\n if (e.isCollection()) {\n\n \t// e.collection().got_line_feed = e.got_line_feed;\n \tNode recurseFlattened = flatten(e, n - 1);\n\n \tif(e.got_line_feed) {\n \t\t flattened.got_line_feed = e.got_line_feed;\n \t recurseFlattened.got_line_feed = e.got_line_feed;\n \t}\n\n \tfor(auto i : (*recurseFlattened.collection())) {\n if (recurseFlattened.got_line_feed) {\n\n i.got_line_feed = true;\n }\n flattened.collection()->push_back(i);\n \t}\n\n } else {\n \tflattened.collection()->push_back(e);\n }\n }\n\n return flattened;\n }\n}\n" }, { "path": "libsass-build/sass_util.hpp", "content": "#ifndef SASS_SASS_UTIL_H\n#define SASS_SASS_UTIL_H\n\n#include \"ast.hpp\"\n#include \"node.hpp\"\n#include \"debug.hpp\"\n\nnamespace Sass {\n\n\n\n\n /*\n This is for ports of functions in the Sass:Util module.\n */\n\n\n /*\n # Return a Node collection of all possible paths through the given Node collection of Node collections.\n #\n # @param arrs [NodeCollection>]\n # @return [NodeCollection>]\n #\n # @example\n # paths([[1, 2], [3, 4], [5]]) #=>\n # # [[1, 3, 5],\n # # [2, 3, 5],\n # # [1, 4, 5],\n # # [2, 4, 5]]\n */\n Node paths(const Node& arrs);\n\n\n /*\n This class is a default implementation of a Node comparator that can be passed to the lcs function below.\n It uses operator== for equality comparision. It then returns one if the Nodes are equal.\n */\n class DefaultLcsComparator {\n public:\n bool operator()(const Node& one, const Node& two, Node& out) const {\n // TODO: Is this the correct C++ interpretation?\n // block ||= proc {|a, b| a == b && a}\n if (one == two) {\n out = one;\n return true;\n }\n\n return false;\n }\n };\n\n\n typedef std::vector > LCSTable;\n\n\n /*\n This is the equivalent of ruby's Sass::Util.lcs_backtrace.\n\n # Computes a single longest common subsequence for arrays x and y.\n # Algorithm from http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Reading_out_an_LCS\n */\n template\n Node lcs_backtrace(const LCSTable& c, const Node& x, const Node& y, int i, int j, const ComparatorType& comparator) {\n DEBUG_PRINTLN(LCS, \"LCSBACK: X=\" << x << \" Y=\" << y << \" I=\" << i << \" J=\" << j)\n\n if (i == 0 || j == 0) {\n DEBUG_PRINTLN(LCS, \"RETURNING EMPTY\")\n return Node::createCollection();\n }\n\n NodeDeque& xChildren = *(x.collection());\n NodeDeque& yChildren = *(y.collection());\n\n Node compareOut = Node::createNil();\n if (comparator(xChildren[i], yChildren[j], compareOut)) {\n DEBUG_PRINTLN(LCS, \"RETURNING AFTER ELEM COMPARE\")\n Node result = lcs_backtrace(c, x, y, i - 1, j - 1, comparator);\n result.collection()->push_back(compareOut);\n return result;\n }\n\n if (c[i][j - 1] > c[i - 1][j]) {\n DEBUG_PRINTLN(LCS, \"RETURNING AFTER TABLE COMPARE\")\n return lcs_backtrace(c, x, y, i, j - 1, comparator);\n }\n\n DEBUG_PRINTLN(LCS, \"FINAL RETURN\")\n return lcs_backtrace(c, x, y, i - 1, j, comparator);\n }\n\n\n /*\n This is the equivalent of ruby's Sass::Util.lcs_table.\n\n # Calculates the memoization table for the Least Common Subsequence algorithm.\n # Algorithm from http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Computing_the_length_of_the_LCS\n */\n template\n void lcs_table(const Node& x, const Node& y, const ComparatorType& comparator, LCSTable& out) {\n DEBUG_PRINTLN(LCS, \"LCSTABLE: X=\" << x << \" Y=\" << y)\n\n NodeDeque& xChildren = *(x.collection());\n NodeDeque& yChildren = *(y.collection());\n\n LCSTable c(xChildren.size(), std::vector(yChildren.size()));\n\n // These shouldn't be necessary since the vector will be initialized to 0 already.\n // x.size.times {|i| c[i][0] = 0}\n // y.size.times {|j| c[0][j] = 0}\n\n for (size_t i = 1; i < xChildren.size(); i++) {\n for (size_t j = 1; j < yChildren.size(); j++) {\n Node compareOut = Node::createNil();\n\n if (comparator(xChildren[i], yChildren[j], compareOut)) {\n c[i][j] = c[i - 1][j - 1] + 1;\n } else {\n c[i][j] = std::max(c[i][j - 1], c[i - 1][j]);\n }\n }\n }\n\n out = c;\n }\n\n\n /*\n This is the equivalent of ruby's Sass::Util.lcs.\n\n # Computes a single longest common subsequence for `x` and `y`.\n # If there are more than one longest common subsequences,\n # the one returned is that which starts first in `x`.\n\n # @param x [NodeCollection]\n # @param y [NodeCollection]\n # @comparator An equality check between elements of `x` and `y`.\n # @return [NodeCollection] The LCS\n\n http://en.wikipedia.org/wiki/Longest_common_subsequence_problem\n */\n template\n Node lcs(Node& x, Node& y, const ComparatorType& comparator) {\n DEBUG_PRINTLN(LCS, \"LCS: X=\" << x << \" Y=\" << y)\n\n Node newX = Node::createCollection();\n newX.collection()->push_back(Node::createNil());\n newX.plus(x);\n\n Node newY = Node::createCollection();\n newY.collection()->push_back(Node::createNil());\n newY.plus(y);\n\n LCSTable table;\n lcs_table(newX, newY, comparator, table);\n\n return lcs_backtrace(table, newX, newY, static_cast(newX.collection()->size()) - 1, static_cast(newY.collection()->size()) - 1, comparator);\n }\n\n\n /*\n This is the equivalent of ruby sass' Sass::Util.flatten and [].flatten.\n Sass::Util.flatten requires the number of levels to flatten, while\n [].flatten doesn't and will flatten the entire array. This function\n supports both.\n\n # Flattens the first `n` nested arrays. If n == -1, all arrays will be flattened\n #\n # @param arr [NodeCollection] The array to flatten\n # @param n [int] The number of levels to flatten\n # @return [NodeCollection] The flattened array\n */\n Node flatten(Node& arr, int n = -1);\n\n\n /*\n This is the equivalent of ruby's Sass::Util.group_by_to_a.\n\n # Performs the equivalent of `enum.group_by.to_a`, but with a guaranteed\n # order. Unlike [#hash_to_a], the resulting order isn't sorted key order;\n # instead, it's the same order as `#group_by` has under Ruby 1.9 (key\n # appearance order).\n #\n # @param enum [Enumerable]\n # @return [Array<[Object, Array]>] An array of pairs.\n\n TODO: update @param and @return once I know what those are.\n\n The following is the modified version of the ruby code that was more portable to C++. You\n should be able to drop it into ruby 3.2.19 and get the same results from ruby sass.\n\n def group_by_to_a(enum, &block)\n order = {}\n\n arr = []\n\n grouped = {}\n\n for e in enum do\n key = block[e]\n unless order.include?(key)\n order[key] = order.size\n end\n\n if not grouped.has_key?(key) then\n grouped[key] = [e]\n else\n grouped[key].push(e)\n end\n end\n\n grouped.each do |key, vals|\n arr[order[key]] = [key, vals]\n end\n\n arr\n end\n\n */\n template\n void group_by_to_a(std::vector& enumeration, KeyFunctorType& keyFunc, std::vector > >& arr /*out*/) {\n\n std::map order;\n\n std::map > grouped;\n\n for (typename std::vector::iterator enumIter = enumeration.begin(), enumIterEnd = enumeration.end(); enumIter != enumIterEnd; enumIter++) {\n EnumType& e = *enumIter;\n\n KeyType key = keyFunc(e);\n\n if (grouped.find(key->hash()) == grouped.end()) {\n order.insert(std::make_pair((unsigned int)order.size(), key));\n\n std::vector newCollection;\n newCollection.push_back(e);\n grouped.insert(std::make_pair(key->hash(), newCollection));\n } else {\n std::vector& collection = grouped.at(key->hash());\n collection.push_back(e);\n }\n }\n\n for (unsigned int index = 0; index < order.size(); index++) {\n KeyType& key = order.at(index);\n std::vector& values = grouped.at(key->hash());\n\n std::pair > grouping = std::make_pair(key, values);\n\n arr.push_back(grouping);\n }\n }\n\n\n}\n\n#endif\n" }, { "path": "libsass-build/sass_values.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n#include \"util.hpp\"\n#include \"eval.hpp\"\n#include \"values.hpp\"\n#include \"operators.hpp\"\n#include \"sass/values.h\"\n#include \"sass_values.hpp\"\n\nextern \"C\" {\n using namespace Sass;\n\n // Return the sass tag for a generic sass value\n enum Sass_Tag ADDCALL sass_value_get_tag(const union Sass_Value* v) { return v->unknown.tag; }\n\n // Check value for specified type\n bool ADDCALL sass_value_is_null(const union Sass_Value* v) { return v->unknown.tag == SASS_NULL; }\n bool ADDCALL sass_value_is_number(const union Sass_Value* v) { return v->unknown.tag == SASS_NUMBER; }\n bool ADDCALL sass_value_is_string(const union Sass_Value* v) { return v->unknown.tag == SASS_STRING; }\n bool ADDCALL sass_value_is_boolean(const union Sass_Value* v) { return v->unknown.tag == SASS_BOOLEAN; }\n bool ADDCALL sass_value_is_color(const union Sass_Value* v) { return v->unknown.tag == SASS_COLOR; }\n bool ADDCALL sass_value_is_list(const union Sass_Value* v) { return v->unknown.tag == SASS_LIST; }\n bool ADDCALL sass_value_is_map(const union Sass_Value* v) { return v->unknown.tag == SASS_MAP; }\n bool ADDCALL sass_value_is_error(const union Sass_Value* v) { return v->unknown.tag == SASS_ERROR; }\n bool ADDCALL sass_value_is_warning(const union Sass_Value* v) { return v->unknown.tag == SASS_WARNING; }\n\n // Getters and setters for Sass_Number\n double ADDCALL sass_number_get_value(const union Sass_Value* v) { return v->number.value; }\n void ADDCALL sass_number_set_value(union Sass_Value* v, double value) { v->number.value = value; }\n const char* ADDCALL sass_number_get_unit(const union Sass_Value* v) { return v->number.unit; }\n void ADDCALL sass_number_set_unit(union Sass_Value* v, char* unit) { v->number.unit = unit; }\n\n // Getters and setters for Sass_String\n const char* ADDCALL sass_string_get_value(const union Sass_Value* v) { return v->string.value; }\n void ADDCALL sass_string_set_value(union Sass_Value* v, char* value) { v->string.value = value; }\n bool ADDCALL sass_string_is_quoted(const union Sass_Value* v) { return v->string.quoted; }\n void ADDCALL sass_string_set_quoted(union Sass_Value* v, bool quoted) { v->string.quoted = quoted; }\n\n // Getters and setters for Sass_Boolean\n bool ADDCALL sass_boolean_get_value(const union Sass_Value* v) { return v->boolean.value; }\n void ADDCALL sass_boolean_set_value(union Sass_Value* v, bool value) { v->boolean.value = value; }\n\n // Getters and setters for Sass_Color\n double ADDCALL sass_color_get_r(const union Sass_Value* v) { return v->color.r; }\n void ADDCALL sass_color_set_r(union Sass_Value* v, double r) { v->color.r = r; }\n double ADDCALL sass_color_get_g(const union Sass_Value* v) { return v->color.g; }\n void ADDCALL sass_color_set_g(union Sass_Value* v, double g) { v->color.g = g; }\n double ADDCALL sass_color_get_b(const union Sass_Value* v) { return v->color.b; }\n void ADDCALL sass_color_set_b(union Sass_Value* v, double b) { v->color.b = b; }\n double ADDCALL sass_color_get_a(const union Sass_Value* v) { return v->color.a; }\n void ADDCALL sass_color_set_a(union Sass_Value* v, double a) { v->color.a = a; }\n\n // Getters and setters for Sass_List\n size_t ADDCALL sass_list_get_length(const union Sass_Value* v) { return v->list.length; }\n enum Sass_Separator ADDCALL sass_list_get_separator(const union Sass_Value* v) { return v->list.separator; }\n void ADDCALL sass_list_set_separator(union Sass_Value* v, enum Sass_Separator separator) { v->list.separator = separator; }\n bool ADDCALL sass_list_get_is_bracketed(const union Sass_Value* v) { return v->list.is_bracketed; }\n void ADDCALL sass_list_set_is_bracketed(union Sass_Value* v, bool is_bracketed) { v->list.is_bracketed = is_bracketed; }\n // Getters and setters for Sass_List values\n union Sass_Value* ADDCALL sass_list_get_value(const union Sass_Value* v, size_t i) { return v->list.values[i]; }\n void ADDCALL sass_list_set_value(union Sass_Value* v, size_t i, union Sass_Value* value) { v->list.values[i] = value; }\n\n // Getters and setters for Sass_Map\n size_t ADDCALL sass_map_get_length(const union Sass_Value* v) { return v->map.length; }\n // Getters and setters for Sass_List keys and values\n union Sass_Value* ADDCALL sass_map_get_key(const union Sass_Value* v, size_t i) { return v->map.pairs[i].key; }\n union Sass_Value* ADDCALL sass_map_get_value(const union Sass_Value* v, size_t i) { return v->map.pairs[i].value; }\n void ADDCALL sass_map_set_key(union Sass_Value* v, size_t i, union Sass_Value* key) { v->map.pairs[i].key = key; }\n void ADDCALL sass_map_set_value(union Sass_Value* v, size_t i, union Sass_Value* val) { v->map.pairs[i].value = val; }\n\n // Getters and setters for Sass_Error\n char* ADDCALL sass_error_get_message(const union Sass_Value* v) { return v->error.message; };\n void ADDCALL sass_error_set_message(union Sass_Value* v, char* msg) { v->error.message = msg; };\n\n // Getters and setters for Sass_Warning\n char* ADDCALL sass_warning_get_message(const union Sass_Value* v) { return v->warning.message; };\n void ADDCALL sass_warning_set_message(union Sass_Value* v, char* msg) { v->warning.message = msg; };\n\n // Creator functions for all value types\n\n union Sass_Value* ADDCALL sass_make_boolean(bool val)\n {\n union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));\n if (v == 0) return 0;\n v->boolean.tag = SASS_BOOLEAN;\n v->boolean.value = val;\n return v;\n }\n\n union Sass_Value* ADDCALL sass_make_number(double val, const char* unit)\n {\n union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));\n if (v == 0) return 0;\n v->number.tag = SASS_NUMBER;\n v->number.value = val;\n v->number.unit = unit ? sass_copy_c_string(unit) : 0;\n if (v->number.unit == 0) { free(v); return 0; }\n return v;\n }\n\n union Sass_Value* ADDCALL sass_make_color(double r, double g, double b, double a)\n {\n union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));\n if (v == 0) return 0;\n v->color.tag = SASS_COLOR;\n v->color.r = r;\n v->color.g = g;\n v->color.b = b;\n v->color.a = a;\n return v;\n }\n\n union Sass_Value* ADDCALL sass_make_string(const char* val)\n {\n union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));\n if (v == 0) return 0;\n v->string.quoted = false;\n v->string.tag = SASS_STRING;\n v->string.value = val ? sass_copy_c_string(val) : 0;\n if (v->string.value == 0) { free(v); return 0; }\n return v;\n }\n\n union Sass_Value* ADDCALL sass_make_qstring(const char* val)\n {\n union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));\n if (v == 0) return 0;\n v->string.quoted = true;\n v->string.tag = SASS_STRING;\n v->string.value = val ? sass_copy_c_string(val) : 0;\n if (v->string.value == 0) { free(v); return 0; }\n return v;\n }\n\n union Sass_Value* ADDCALL sass_make_list(size_t len, enum Sass_Separator sep, bool is_bracketed)\n {\n union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));\n if (v == 0) return 0;\n v->list.tag = SASS_LIST;\n v->list.length = len;\n v->list.separator = sep;\n v->list.is_bracketed = is_bracketed;\n v->list.values = (union Sass_Value**) calloc(len, sizeof(union Sass_Value*));\n if (v->list.values == 0) { free(v); return 0; }\n return v;\n }\n\n union Sass_Value* ADDCALL sass_make_map(size_t len)\n {\n union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));\n if (v == 0) return 0;\n v->map.tag = SASS_MAP;\n v->map.length = len;\n v->map.pairs = (struct Sass_MapPair*) calloc(len, sizeof(struct Sass_MapPair));\n if (v->map.pairs == 0) { free(v); return 0; }\n return v;\n }\n\n union Sass_Value* ADDCALL sass_make_null(void)\n {\n union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));\n if (v == 0) return 0;\n v->null.tag = SASS_NULL;\n return v;\n }\n\n union Sass_Value* ADDCALL sass_make_error(const char* msg)\n {\n union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));\n if (v == 0) return 0;\n v->error.tag = SASS_ERROR;\n v->error.message = msg ? sass_copy_c_string(msg) : 0;\n if (v->error.message == 0) { free(v); return 0; }\n return v;\n }\n\n union Sass_Value* ADDCALL sass_make_warning(const char* msg)\n {\n union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));\n if (v == 0) return 0;\n v->warning.tag = SASS_WARNING;\n v->warning.message = msg ? sass_copy_c_string(msg) : 0;\n if (v->warning.message == 0) { free(v); return 0; }\n return v;\n }\n\n // will free all associated sass values\n void ADDCALL sass_delete_value(union Sass_Value* val) {\n\n size_t i;\n if (val == 0) return;\n switch(val->unknown.tag) {\n case SASS_NULL: {\n } break;\n case SASS_BOOLEAN: {\n } break;\n case SASS_NUMBER: {\n free(val->number.unit);\n } break;\n case SASS_COLOR: {\n } break;\n case SASS_STRING: {\n free(val->string.value);\n } break;\n case SASS_LIST: {\n for (i=0; ilist.length; i++) {\n sass_delete_value(val->list.values[i]);\n }\n free(val->list.values);\n } break;\n case SASS_MAP: {\n for (i=0; imap.length; i++) {\n sass_delete_value(val->map.pairs[i].key);\n sass_delete_value(val->map.pairs[i].value);\n }\n free(val->map.pairs);\n } break;\n case SASS_ERROR: {\n free(val->error.message);\n } break;\n case SASS_WARNING: {\n free(val->error.message);\n } break;\n default: break;\n }\n\n free(val);\n\n }\n\n // Make a deep cloned copy of the given sass value\n union Sass_Value* ADDCALL sass_clone_value (const union Sass_Value* val)\n {\n\n size_t i;\n if (val == 0) return 0;\n switch(val->unknown.tag) {\n case SASS_NULL: {\n return sass_make_null();\n }\n case SASS_BOOLEAN: {\n return sass_make_boolean(val->boolean.value);\n }\n case SASS_NUMBER: {\n return sass_make_number(val->number.value, val->number.unit);\n }\n case SASS_COLOR: {\n return sass_make_color(val->color.r, val->color.g, val->color.b, val->color.a);\n }\n case SASS_STRING: {\n return sass_string_is_quoted(val) ? sass_make_qstring(val->string.value) : sass_make_string(val->string.value);\n }\n case SASS_LIST: {\n union Sass_Value* list = sass_make_list(val->list.length, val->list.separator, val->list.is_bracketed);\n for (i = 0; i < list->list.length; i++) {\n list->list.values[i] = sass_clone_value(val->list.values[i]);\n }\n return list;\n }\n case SASS_MAP: {\n union Sass_Value* map = sass_make_map(val->map.length);\n for (i = 0; i < val->map.length; i++) {\n map->map.pairs[i].key = sass_clone_value(val->map.pairs[i].key);\n map->map.pairs[i].value = sass_clone_value(val->map.pairs[i].value);\n }\n return map;\n }\n case SASS_ERROR: {\n return sass_make_error(val->error.message);\n }\n case SASS_WARNING: {\n return sass_make_warning(val->warning.message);\n }\n default: break;\n }\n\n return 0;\n\n }\n\n union Sass_Value* ADDCALL sass_value_stringify (const union Sass_Value* v, bool compressed, int precision)\n {\n Value_Obj val = sass_value_to_ast_node(v);\n Sass_Inspect_Options options(compressed ? COMPRESSED : NESTED, precision);\n std::string str(val->to_string(options));\n return sass_make_qstring(str.c_str());\n }\n\n union Sass_Value* ADDCALL sass_value_op (enum Sass_OP op, const union Sass_Value* a, const union Sass_Value* b)\n {\n\n Sass::Value_Ptr rv;\n\n try {\n\n Value_Obj lhs = sass_value_to_ast_node(a);\n Value_Obj rhs = sass_value_to_ast_node(b);\n struct Sass_Inspect_Options options(NESTED, 5);\n\n // see if it's a relational expression\n switch(op) {\n case Sass_OP::EQ: return sass_make_boolean(Operators::eq(lhs, rhs));\n case Sass_OP::NEQ: return sass_make_boolean(Operators::neq(lhs, rhs));\n case Sass_OP::GT: return sass_make_boolean(Operators::gt(lhs, rhs));\n case Sass_OP::GTE: return sass_make_boolean(Operators::gte(lhs, rhs));\n case Sass_OP::LT: return sass_make_boolean(Operators::lt(lhs, rhs));\n case Sass_OP::LTE: return sass_make_boolean(Operators::lte(lhs, rhs));\n case Sass_OP::AND: return ast_node_to_sass_value(lhs->is_false() ? lhs : rhs);\n case Sass_OP::OR: return ast_node_to_sass_value(lhs->is_false() ? rhs : lhs);\n default: break;\n }\n\n if (sass_value_is_number(a) && sass_value_is_number(b)) {\n Number_Ptr_Const l_n = Cast(lhs);\n Number_Ptr_Const r_n = Cast(rhs);\n rv = Operators::op_numbers(op, *l_n, *r_n, options, l_n->pstate());\n }\n else if (sass_value_is_number(a) && sass_value_is_color(a)) {\n Number_Ptr_Const l_n = Cast(lhs);\n Color_Ptr_Const r_c = Cast(rhs);\n rv = Operators::op_number_color(op, *l_n, *r_c, options, l_n->pstate());\n }\n else if (sass_value_is_color(a) && sass_value_is_number(b)) {\n Color_Ptr_Const l_c = Cast(lhs);\n Number_Ptr_Const r_n = Cast(rhs);\n rv = Operators::op_color_number(op, *l_c, *r_n, options, l_c->pstate());\n }\n else if (sass_value_is_color(a) && sass_value_is_color(b)) {\n Color_Ptr_Const l_c = Cast(lhs);\n Color_Ptr_Const r_c = Cast(rhs);\n rv = Operators::op_colors(op, *l_c, *r_c, options, l_c->pstate());\n }\n else /* convert other stuff to string and apply operation */ {\n Value_Ptr l_v = Cast(lhs);\n Value_Ptr r_v = Cast(rhs);\n rv = Operators::op_strings(op, *l_v, *r_v, options, l_v->pstate());\n }\n\n // ToDo: maybe we should should return null value?\n if (!rv) return sass_make_error(\"invalid return value\");\n\n // convert result back to ast node\n return ast_node_to_sass_value(rv);\n\n }\n\n // simply pass the error message back to the caller for now\n catch (Exception::InvalidSass& e) { return sass_make_error(e.what()); }\n catch (std::bad_alloc&) { return sass_make_error(\"memory exhausted\"); }\n catch (std::exception& e) { return sass_make_error(e.what()); }\n catch (std::string& e) { return sass_make_error(e.c_str()); }\n catch (const char* e) { return sass_make_error(e); }\n catch (...) { return sass_make_error(\"unknown\"); }\n }\n\n}\n" }, { "path": "libsass-build/sass_values.hpp", "content": "#ifndef SASS_SASS_VALUES_H\n#define SASS_SASS_VALUES_H\n\n#include \"sass.h\"\n\nstruct Sass_Unknown {\n enum Sass_Tag tag;\n};\n\nstruct Sass_Boolean {\n enum Sass_Tag tag;\n bool value;\n};\n\nstruct Sass_Number {\n enum Sass_Tag tag;\n double value;\n char* unit;\n};\n\nstruct Sass_Color {\n enum Sass_Tag tag;\n double r;\n double g;\n double b;\n double a;\n};\n\nstruct Sass_String {\n enum Sass_Tag tag;\n bool quoted;\n char* value;\n};\n\nstruct Sass_List {\n enum Sass_Tag tag;\n enum Sass_Separator separator;\n bool is_bracketed;\n size_t length;\n // null terminated \"array\"\n union Sass_Value** values;\n};\n\nstruct Sass_Map {\n enum Sass_Tag tag;\n size_t length;\n struct Sass_MapPair* pairs;\n};\n\nstruct Sass_Null {\n enum Sass_Tag tag;\n};\n\nstruct Sass_Error {\n enum Sass_Tag tag;\n char* message;\n};\n\nstruct Sass_Warning {\n enum Sass_Tag tag;\n char* message;\n};\n\nunion Sass_Value {\n struct Sass_Unknown unknown;\n struct Sass_Boolean boolean;\n struct Sass_Number number;\n struct Sass_Color color;\n struct Sass_String string;\n struct Sass_List list;\n struct Sass_Map map;\n struct Sass_Null null;\n struct Sass_Error error;\n struct Sass_Warning warning;\n};\n\nstruct Sass_MapPair {\n union Sass_Value* key;\n union Sass_Value* value;\n};\n\n#endif\n" }, { "path": "libsass-build/source_map.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n#include \n#include \n\n#include \"ast.hpp\"\n#include \"json.hpp\"\n#include \"context.hpp\"\n#include \"position.hpp\"\n#include \"source_map.hpp\"\n\nnamespace Sass {\n SourceMap::SourceMap() : current_position(0, 0, 0), file(\"stdin\") { }\n SourceMap::SourceMap(const std::string& file) : current_position(0, 0, 0), file(file) { }\n\n std::string SourceMap::render_srcmap(Context &ctx) {\n\n const bool include_sources = ctx.c_options.source_map_contents;\n const std::vector links = ctx.srcmap_links;\n const std::vector& sources(ctx.resources);\n\n JsonNode* json_srcmap = json_mkobject();\n\n json_append_member(json_srcmap, \"version\", json_mknumber(3));\n\n const char *file_name = file.c_str();\n JsonNode *json_file_name = json_mkstring(file_name);\n json_append_member(json_srcmap, \"file\", json_file_name);\n\n // pass-through sourceRoot option\n if (!ctx.source_map_root.empty()) {\n JsonNode* root = json_mkstring(ctx.source_map_root.c_str());\n json_append_member(json_srcmap, \"sourceRoot\", root);\n }\n\n JsonNode *json_sources = json_mkarray();\n for (size_t i = 0; i < source_index.size(); ++i) {\n std::string source(links[source_index[i]]);\n if (ctx.c_options.source_map_file_urls) {\n source = File::rel2abs(source);\n // check for windows abs path\n if (source[0] == '/') {\n // ends up with three slashes\n source = \"file://\" + source;\n } else {\n // needs an additional slash\n source = \"file:///\" + source;\n }\n }\n const char* source_name = source.c_str();\n JsonNode *json_source_name = json_mkstring(source_name);\n json_append_element(json_sources, json_source_name);\n }\n json_append_member(json_srcmap, \"sources\", json_sources);\n\n if (include_sources && source_index.size()) {\n JsonNode *json_contents = json_mkarray();\n for (size_t i = 0; i < source_index.size(); ++i) {\n const Resource& resource(sources[source_index[i]]);\n JsonNode *json_content = json_mkstring(resource.contents);\n json_append_element(json_contents, json_content);\n }\n json_append_member(json_srcmap, \"sourcesContent\", json_contents);\n }\n\n JsonNode *json_names = json_mkarray();\n // so far we have no implementation for names\n // no problem as we do not alter any identifiers\n json_append_member(json_srcmap, \"names\", json_names);\n\n std::string mappings = serialize_mappings();\n JsonNode *json_mappings = json_mkstring(mappings.c_str());\n json_append_member(json_srcmap, \"mappings\", json_mappings);\n\n char *str = json_stringify(json_srcmap, \"\\t\");\n std::string result = std::string(str);\n free(str);\n json_delete(json_srcmap);\n return result;\n }\n\n std::string SourceMap::serialize_mappings() {\n std::string result = \"\";\n\n size_t previous_generated_line = 0;\n size_t previous_generated_column = 0;\n size_t previous_original_line = 0;\n size_t previous_original_column = 0;\n size_t previous_original_file = 0;\n for (size_t i = 0; i < mappings.size(); ++i) {\n const size_t generated_line = mappings[i].generated_position.line;\n const size_t generated_column = mappings[i].generated_position.column;\n const size_t original_line = mappings[i].original_position.line;\n const size_t original_column = mappings[i].original_position.column;\n const size_t original_file = mappings[i].original_position.file;\n\n if (generated_line != previous_generated_line) {\n previous_generated_column = 0;\n if (generated_line > previous_generated_line) {\n result += std::string(generated_line - previous_generated_line, ';');\n previous_generated_line = generated_line;\n }\n }\n else if (i > 0) {\n result += \",\";\n }\n\n // generated column\n result += base64vlq.encode(static_cast(generated_column) - static_cast(previous_generated_column));\n previous_generated_column = generated_column;\n // file\n result += base64vlq.encode(static_cast(original_file) - static_cast(previous_original_file));\n previous_original_file = original_file;\n // source line\n result += base64vlq.encode(static_cast(original_line) - static_cast(previous_original_line));\n previous_original_line = original_line;\n // source column\n result += base64vlq.encode(static_cast(original_column) - static_cast(previous_original_column));\n previous_original_column = original_column;\n }\n\n return result;\n }\n\n void SourceMap::prepend(const OutputBuffer& out)\n {\n Offset size(out.smap.current_position);\n for (Mapping mapping : out.smap.mappings) {\n if (mapping.generated_position.line > size.line) {\n throw(std::runtime_error(\"prepend sourcemap has illegal line\"));\n }\n if (mapping.generated_position.line == size.line) {\n if (mapping.generated_position.column > size.column) {\n throw(std::runtime_error(\"prepend sourcemap has illegal column\"));\n }\n }\n }\n // adjust the buffer offset\n prepend(Offset(out.buffer));\n // now add the new mappings\n VECTOR_UNSHIFT(mappings, out.smap.mappings);\n }\n\n void SourceMap::append(const OutputBuffer& out)\n {\n append(Offset(out.buffer));\n }\n\n void SourceMap::prepend(const Offset& offset)\n {\n if (offset.line != 0 || offset.column != 0) {\n for (Mapping& mapping : mappings) {\n // move stuff on the first old line\n if (mapping.generated_position.line == 0) {\n mapping.generated_position.column += offset.column;\n }\n // make place for the new lines\n mapping.generated_position.line += offset.line;\n }\n }\n if (current_position.line == 0) {\n current_position.column += offset.column;\n }\n current_position.line += offset.line;\n }\n\n void SourceMap::append(const Offset& offset)\n {\n current_position += offset;\n }\n\n void SourceMap::add_open_mapping(const AST_Node_Ptr node)\n {\n mappings.push_back(Mapping(node->pstate(), current_position));\n }\n\n void SourceMap::add_close_mapping(const AST_Node_Ptr node)\n {\n mappings.push_back(Mapping(node->pstate() + node->pstate().offset, current_position));\n }\n\n ParserState SourceMap::remap(const ParserState& pstate) {\n for (size_t i = 0; i < mappings.size(); ++i) {\n if (\n mappings[i].generated_position.file == pstate.file &&\n mappings[i].generated_position.line == pstate.line &&\n mappings[i].generated_position.column == pstate.column\n ) return ParserState(pstate.path, pstate.src, mappings[i].original_position, pstate.offset);\n }\n return ParserState(pstate.path, pstate.src, Position(-1, -1, -1), Offset(0, 0));\n\n }\n\n}\n" }, { "path": "libsass-build/source_map.hpp", "content": "#ifndef SASS_SOURCE_MAP_H\n#define SASS_SOURCE_MAP_H\n\n#include \n#include \n\n#include \"ast_fwd_decl.hpp\"\n#include \"base64vlq.hpp\"\n#include \"position.hpp\"\n#include \"mapping.hpp\"\n\n#define VECTOR_PUSH(vec, ins) vec.insert(vec.end(), ins.begin(), ins.end())\n#define VECTOR_UNSHIFT(vec, ins) vec.insert(vec.begin(), ins.begin(), ins.end())\n\nnamespace Sass {\n\n class Context;\n class OutputBuffer;\n\n class SourceMap {\n\n public:\n std::vector source_index;\n SourceMap();\n SourceMap(const std::string& file);\n\n void append(const Offset& offset);\n void prepend(const Offset& offset);\n void append(const OutputBuffer& out);\n void prepend(const OutputBuffer& out);\n void add_open_mapping(const AST_Node_Ptr node);\n void add_close_mapping(const AST_Node_Ptr node);\n\n std::string render_srcmap(Context &ctx);\n ParserState remap(const ParserState& pstate);\n\n private:\n\n std::string serialize_mappings();\n\n std::vector mappings;\n Position current_position;\npublic:\n std::string file;\nprivate:\n Base64VLQ base64vlq;\n };\n\n class OutputBuffer {\n public:\n OutputBuffer(void)\n : buffer(\"\"),\n smap()\n { }\n public:\n std::string buffer;\n SourceMap smap;\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/subset_map.cpp", "content": "#include \"sass.hpp\"\n#include \"ast.hpp\"\n#include \"subset_map.hpp\"\n\nnamespace Sass {\n\n void Subset_Map::put(const Compound_Selector_Obj& sel, const SubSetMapPair& value)\n {\n if (sel->empty()) throw std::runtime_error(\"internal error: subset map keys may not be empty\");\n size_t index = values_.size();\n values_.push_back(value);\n for (size_t i = 0, S = sel->length(); i < S; ++i)\n {\n hash_[(*sel)[i]].push_back(std::make_pair(sel, index));\n }\n }\n\n std::vector Subset_Map::get_kv(const Compound_Selector_Obj& sel)\n {\n SimpleSelectorDict dict(sel->begin(), sel->end()); // XXX Set\n std::vector indices;\n for (size_t i = 0, S = sel->length(); i < S; ++i) {\n if (!hash_.count((*sel)[i])) {\n continue;\n }\n const std::vector >& subsets = hash_[(*sel)[i]];\n for (const std::pair& item : subsets) {\n bool include = true;\n for (const Simple_Selector_Obj& it : item.first->elements()) {\n auto found = dict.find(it);\n if (found == dict.end()) {\n include = false;\n break;\n }\n }\n if (include) indices.push_back(item.second);\n }\n }\n sort(indices.begin(), indices.end());\n std::vector::iterator indices_end = unique(indices.begin(), indices.end());\n indices.resize(distance(indices.begin(), indices_end));\n\n std::vector results;\n for (size_t i = 0, S = indices.size(); i < S; ++i) {\n results.push_back(values_[indices[i]]);\n }\n return results;\n }\n\n std::vector Subset_Map::get_v(const Compound_Selector_Obj& sel)\n {\n return get_kv(sel);\n }\n\n}" }, { "path": "libsass-build/subset_map.hpp", "content": "#ifndef SASS_SUBSET_MAP_H\n#define SASS_SUBSET_MAP_H\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"ast_fwd_decl.hpp\"\n\n\n// #include \n// #include \n// template\n// std::string vector_to_string(std::vector v)\n// {\n// std::stringstream buffer;\n// buffer << \"[\";\n\n// if (!v.empty())\n// { buffer << v[0]; }\n// else\n// { buffer << \"]\"; }\n\n// if (v.size() == 1)\n// { buffer << \"]\"; }\n// else\n// {\n// for (size_t i = 1, S = v.size(); i < S; ++i) buffer << \", \" << v[i];\n// buffer << \"]\";\n// }\n\n// return buffer.str();\n// }\n\n// template\n// std::string set_to_string(set v)\n// {\n// std::stringstream buffer;\n// buffer << \"[\";\n// typename std::set::iterator i = v.begin();\n// if (!v.empty())\n// { buffer << *i; }\n// else\n// { buffer << \"]\"; }\n\n// if (v.size() == 1)\n// { buffer << \"]\"; }\n// else\n// {\n// for (++i; i != v.end(); ++i) buffer << \", \" << *i;\n// buffer << \"]\";\n// }\n\n// return buffer.str();\n// }\n\nnamespace Sass {\n\n class Subset_Map {\n private:\n std::vector values_;\n std::map >, OrderNodes > hash_;\n public:\n void put(const Compound_Selector_Obj& sel, const SubSetMapPair& value);\n std::vector get_kv(const Compound_Selector_Obj& s);\n std::vector get_v(const Compound_Selector_Obj& s);\n bool empty() { return values_.empty(); }\n void clear() { values_.clear(); hash_.clear(); }\n const std::vector values(void) { return values_; }\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/to_c.cpp", "content": "#include \"sass.hpp\"\n#include \"to_c.hpp\"\n#include \"ast.hpp\"\n\nnamespace Sass {\n\n union Sass_Value* To_C::fallback_impl(AST_Node_Ptr n)\n { return sass_make_error(\"unknown type for C-API\"); }\n\n union Sass_Value* To_C::operator()(Boolean_Ptr b)\n { return sass_make_boolean(b->value()); }\n\n union Sass_Value* To_C::operator()(Number_Ptr n)\n { return sass_make_number(n->value(), n->unit().c_str()); }\n\n union Sass_Value* To_C::operator()(Custom_Warning_Ptr w)\n { return sass_make_warning(w->message().c_str()); }\n\n union Sass_Value* To_C::operator()(Custom_Error_Ptr e)\n { return sass_make_error(e->message().c_str()); }\n\n union Sass_Value* To_C::operator()(Color_Ptr c)\n { return sass_make_color(c->r(), c->g(), c->b(), c->a()); }\n\n union Sass_Value* To_C::operator()(String_Constant_Ptr s)\n {\n if (s->quote_mark()) {\n return sass_make_qstring(s->value().c_str());\n } else {\n return sass_make_string(s->value().c_str());\n }\n }\n\n union Sass_Value* To_C::operator()(String_Quoted_Ptr s)\n { return sass_make_qstring(s->value().c_str()); }\n\n union Sass_Value* To_C::operator()(List_Ptr l)\n {\n union Sass_Value* v = sass_make_list(l->length(), l->separator(), l->is_bracketed());\n for (size_t i = 0, L = l->length(); i < L; ++i) {\n sass_list_set_value(v, i, (*l)[i]->perform(this));\n }\n return v;\n }\n\n union Sass_Value* To_C::operator()(Map_Ptr m)\n {\n union Sass_Value* v = sass_make_map(m->length());\n int i = 0;\n for (auto key : m->keys()) {\n sass_map_set_key(v, i, key->perform(this));\n sass_map_set_value(v, i, m->at(key)->perform(this));\n i++;\n }\n return v;\n }\n\n union Sass_Value* To_C::operator()(Arguments_Ptr a)\n {\n union Sass_Value* v = sass_make_list(a->length(), SASS_COMMA, false);\n for (size_t i = 0, L = a->length(); i < L; ++i) {\n sass_list_set_value(v, i, (*a)[i]->perform(this));\n }\n return v;\n }\n\n union Sass_Value* To_C::operator()(Argument_Ptr a)\n { return a->value()->perform(this); }\n\n // not strictly necessary because of the fallback\n union Sass_Value* To_C::operator()(Null_Ptr n)\n { return sass_make_null(); }\n\n};\n" }, { "path": "libsass-build/to_c.hpp", "content": "#ifndef SASS_TO_C_H\n#define SASS_TO_C_H\n\n#include \"ast_fwd_decl.hpp\"\n#include \"operation.hpp\"\n#include \"sass/values.h\"\n\nnamespace Sass {\n\n class To_C : public Operation_CRTP {\n // override this to define a catch-all\n union Sass_Value* fallback_impl(AST_Node_Ptr n);\n\n public:\n\n To_C() { }\n ~To_C() { }\n\n union Sass_Value* operator()(Boolean_Ptr);\n union Sass_Value* operator()(Number_Ptr);\n union Sass_Value* operator()(Color_Ptr);\n union Sass_Value* operator()(String_Constant_Ptr);\n union Sass_Value* operator()(String_Quoted_Ptr);\n union Sass_Value* operator()(Custom_Warning_Ptr);\n union Sass_Value* operator()(Custom_Error_Ptr);\n union Sass_Value* operator()(List_Ptr);\n union Sass_Value* operator()(Map_Ptr);\n union Sass_Value* operator()(Null_Ptr);\n union Sass_Value* operator()(Arguments_Ptr);\n union Sass_Value* operator()(Argument_Ptr);\n\n // dispatch to fallback implementation\n union Sass_Value* fallback(AST_Node_Ptr x)\n { return fallback_impl(x); }\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/to_value.cpp", "content": "#include \"sass.hpp\"\n#include \"ast.hpp\"\n#include \"to_value.hpp\"\n\nnamespace Sass {\n\n Value_Ptr To_Value::fallback_impl(AST_Node_Ptr n)\n {\n // throw a runtime error if this happens\n // we want a well defined set of possible nodes\n throw std::runtime_error(\"invalid node for to_value\");\n }\n\n // Custom_Error is a valid value\n Value_Ptr To_Value::operator()(Custom_Error_Ptr e)\n {\n return e;\n }\n\n // Custom_Warning is a valid value\n Value_Ptr To_Value::operator()(Custom_Warning_Ptr w)\n {\n return w;\n }\n\n // Boolean is a valid value\n Value_Ptr To_Value::operator()(Boolean_Ptr b)\n {\n return b;\n }\n\n // Number is a valid value\n Value_Ptr To_Value::operator()(Number_Ptr n)\n {\n return n;\n }\n\n // Color is a valid value\n Value_Ptr To_Value::operator()(Color_Ptr c)\n {\n return c;\n }\n\n // String_Constant is a valid value\n Value_Ptr To_Value::operator()(String_Constant_Ptr s)\n {\n return s;\n }\n\n // String_Quoted is a valid value\n Value_Ptr To_Value::operator()(String_Quoted_Ptr s)\n {\n return s;\n }\n\n // List is a valid value\n Value_Ptr To_Value::operator()(List_Ptr l)\n {\n List_Obj ll = SASS_MEMORY_NEW(List,\n l->pstate(),\n l->length(),\n l->separator(),\n l->is_arglist(),\n l->is_bracketed());\n for (size_t i = 0, L = l->length(); i < L; ++i) {\n ll->append((*l)[i]->perform(this));\n }\n return ll.detach();\n }\n\n // Map is a valid value\n Value_Ptr To_Value::operator()(Map_Ptr m)\n {\n return m;\n }\n\n // Null is a valid value\n Value_Ptr To_Value::operator()(Null_Ptr n)\n {\n return n;\n }\n\n // Function is a valid value\n Value_Ptr To_Value::operator()(Function_Ptr n)\n {\n return n;\n }\n\n // Argument returns its value\n Value_Ptr To_Value::operator()(Argument_Ptr arg)\n {\n if (!arg->name().empty()) return 0;\n return arg->value()->perform(this);\n }\n\n // Selector_List is converted to a string\n Value_Ptr To_Value::operator()(Selector_List_Ptr s)\n {\n return SASS_MEMORY_NEW(String_Quoted,\n s->pstate(),\n s->to_string(ctx.c_options));\n }\n\n // Binary_Expression is converted to a string\n Value_Ptr To_Value::operator()(Binary_Expression_Ptr s)\n {\n return SASS_MEMORY_NEW(String_Quoted,\n s->pstate(),\n s->to_string(ctx.c_options));\n }\n\n};\n" }, { "path": "libsass-build/to_value.hpp", "content": "#ifndef SASS_TO_VALUE_H\n#define SASS_TO_VALUE_H\n\n#include \"operation.hpp\"\n#include \"sass/values.h\"\n#include \"ast_fwd_decl.hpp\"\n\nnamespace Sass {\n\n class To_Value : public Operation_CRTP {\n\n Value_Ptr fallback_impl(AST_Node_Ptr n);\n\n private:\n\n Context& ctx;\n\n public:\n\n To_Value(Context& ctx)\n : ctx(ctx)\n { }\n ~To_Value() { }\n using Operation::operator();\n\n Value_Ptr operator()(Argument_Ptr);\n Value_Ptr operator()(Boolean_Ptr);\n Value_Ptr operator()(Number_Ptr);\n Value_Ptr operator()(Color_Ptr);\n Value_Ptr operator()(String_Constant_Ptr);\n Value_Ptr operator()(String_Quoted_Ptr);\n Value_Ptr operator()(Custom_Warning_Ptr);\n Value_Ptr operator()(Custom_Error_Ptr);\n Value_Ptr operator()(List_Ptr);\n Value_Ptr operator()(Map_Ptr);\n Value_Ptr operator()(Null_Ptr);\n Value_Ptr operator()(Function_Ptr);\n\n // convert to string via `To_String`\n Value_Ptr operator()(Selector_List_Ptr);\n Value_Ptr operator()(Binary_Expression_Ptr);\n\n // fallback throws error\n template \n Value_Ptr fallback(U x) { return fallback_impl(x); }\n };\n\n}\n\n#endif\n" }, { "path": "libsass-build/units.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \"units.hpp\"\n#include \"error_handling.hpp\"\n\nnamespace Sass {\n\n /* the conversion matrix can be readed the following way */\n /* if you go down, the factor is for the numerator (multiply) */\n /* if you go right, the factor is for the denominator (divide) */\n /* and yes, we actually use both, not sure why, but why not!? */\n\n const double size_conversion_factors[6][6] =\n {\n /* in cm pc mm pt px */\n /* in */ { 1, 2.54, 6, 25.4, 72, 96, },\n /* cm */ { 1.0/2.54, 1, 6.0/2.54, 10, 72.0/2.54, 96.0/2.54 },\n /* pc */ { 1.0/6.0, 2.54/6.0, 1, 25.4/6.0, 72.0/6.0, 96.0/6.0 },\n /* mm */ { 1.0/25.4, 1.0/10.0, 6.0/25.4, 1, 72.0/25.4, 96.0/25.4 },\n /* pt */ { 1.0/72.0, 2.54/72.0, 6.0/72.0, 25.4/72.0, 1, 96.0/72.0 },\n /* px */ { 1.0/96.0, 2.54/96.0, 6.0/96.0, 25.4/96.0, 72.0/96.0, 1, }\n };\n\n const double angle_conversion_factors[4][4] =\n {\n /* deg grad rad turn */\n /* deg */ { 1, 40.0/36.0, PI/180.0, 1.0/360.0 },\n /* grad */ { 36.0/40.0, 1, PI/200.0, 1.0/400.0 },\n /* rad */ { 180.0/PI, 200.0/PI, 1, 0.5/PI },\n /* turn */ { 360.0, 400.0, 2.0*PI, 1 }\n };\n\n const double time_conversion_factors[2][2] =\n {\n /* s ms */\n /* s */ { 1, 1000.0 },\n /* ms */ { 1/1000.0, 1 }\n };\n const double frequency_conversion_factors[2][2] =\n {\n /* Hz kHz */\n /* Hz */ { 1, 1/1000.0 },\n /* kHz */ { 1000.0, 1 }\n };\n const double resolution_conversion_factors[3][3] =\n {\n /* dpi dpcm dppx */\n /* dpi */ { 1, 1/2.54, 1/96.0 },\n /* dpcm */ { 2.54, 1, 2.54/96 },\n /* dppx */ { 96, 96/2.54, 1 }\n };\n\n UnitClass get_unit_type(UnitType unit)\n {\n switch (unit & 0xFF00)\n {\n case UnitClass::LENGTH: return UnitClass::LENGTH;\n case UnitClass::ANGLE: return UnitClass::ANGLE;\n case UnitClass::TIME: return UnitClass::TIME;\n case UnitClass::FREQUENCY: return UnitClass::FREQUENCY;\n case UnitClass::RESOLUTION: return UnitClass::RESOLUTION;\n default: return UnitClass::INCOMMENSURABLE;\n }\n };\n\n std::string get_unit_class(UnitType unit)\n {\n switch (unit & 0xFF00)\n {\n case UnitClass::LENGTH: return \"LENGTH\";\n case UnitClass::ANGLE: return \"ANGLE\";\n case UnitClass::TIME: return \"TIME\";\n case UnitClass::FREQUENCY: return \"FREQUENCY\";\n case UnitClass::RESOLUTION: return \"RESOLUTION\";\n default: return \"INCOMMENSURABLE\";\n }\n };\n\n UnitType get_main_unit(const UnitClass unit)\n {\n switch (unit)\n {\n case UnitClass::LENGTH: return UnitType::PX;\n case UnitClass::ANGLE: return UnitType::DEG;\n case UnitClass::TIME: return UnitType::SEC;\n case UnitClass::FREQUENCY: return UnitType::HERTZ;\n case UnitClass::RESOLUTION: return UnitType::DPI;\n default: return UnitType::UNKNOWN;\n }\n };\n\n UnitType string_to_unit(const std::string& s)\n {\n // size units\n if (s == \"px\") return UnitType::PX;\n else if (s == \"pt\") return UnitType::PT;\n else if (s == \"pc\") return UnitType::PC;\n else if (s == \"mm\") return UnitType::MM;\n else if (s == \"cm\") return UnitType::CM;\n else if (s == \"in\") return UnitType::IN;\n // angle units\n else if (s == \"deg\") return UnitType::DEG;\n else if (s == \"grad\") return UnitType::GRAD;\n else if (s == \"rad\") return UnitType::RAD;\n else if (s == \"turn\") return UnitType::TURN;\n // time units\n else if (s == \"s\") return UnitType::SEC;\n else if (s == \"ms\") return UnitType::MSEC;\n // frequency units\n else if (s == \"Hz\") return UnitType::HERTZ;\n else if (s == \"kHz\") return UnitType::KHERTZ;\n // resolutions units\n else if (s == \"dpi\") return UnitType::DPI;\n else if (s == \"dpcm\") return UnitType::DPCM;\n else if (s == \"dppx\") return UnitType::DPPX;\n // for unknown units\n else return UnitType::UNKNOWN;\n }\n\n const char* unit_to_string(UnitType unit)\n {\n switch (unit) {\n // size units\n case UnitType::PX: return \"px\";\n case UnitType::PT: return \"pt\";\n case UnitType::PC: return \"pc\";\n case UnitType::MM: return \"mm\";\n case UnitType::CM: return \"cm\";\n case UnitType::IN: return \"in\";\n // angle units\n case UnitType::DEG: return \"deg\";\n case UnitType::GRAD: return \"grad\";\n case UnitType::RAD: return \"rad\";\n case UnitType::TURN: return \"turn\";\n // time units\n case UnitType::SEC: return \"s\";\n case UnitType::MSEC: return \"ms\";\n // frequency units\n case UnitType::HERTZ: return \"Hz\";\n case UnitType::KHERTZ: return \"kHz\";\n // resolutions units\n case UnitType::DPI: return \"dpi\";\n case UnitType::DPCM: return \"dpcm\";\n case UnitType::DPPX: return \"dppx\";\n // for unknown units\n default: return \"\";\n }\n }\n\n std::string unit_to_class(const std::string& s)\n {\n if (s == \"px\") return \"LENGTH\";\n else if (s == \"pt\") return \"LENGTH\";\n else if (s == \"pc\") return \"LENGTH\";\n else if (s == \"mm\") return \"LENGTH\";\n else if (s == \"cm\") return \"LENGTH\";\n else if (s == \"in\") return \"LENGTH\";\n // angle units\n else if (s == \"deg\") return \"ANGLE\";\n else if (s == \"grad\") return \"ANGLE\";\n else if (s == \"rad\") return \"ANGLE\";\n else if (s == \"turn\") return \"ANGLE\";\n // time units\n else if (s == \"s\") return \"TIME\";\n else if (s == \"ms\") return \"TIME\";\n // frequency units\n else if (s == \"Hz\") return \"FREQUENCY\";\n else if (s == \"kHz\") return \"FREQUENCY\";\n // resolutions units\n else if (s == \"dpi\") return \"RESOLUTION\";\n else if (s == \"dpcm\") return \"RESOLUTION\";\n else if (s == \"dppx\") return \"RESOLUTION\";\n // for unknown units\n return \"CUSTOM:\" + s;\n }\n\n // throws incompatibleUnits exceptions\n double conversion_factor(const std::string& s1, const std::string& s2)\n {\n // assert for same units\n if (s1 == s2) return 1;\n // get unit enum from string\n UnitType u1 = string_to_unit(s1);\n UnitType u2 = string_to_unit(s2);\n // query unit group types\n UnitClass t1 = get_unit_type(u1);\n UnitClass t2 = get_unit_type(u2);\n // return the conversion factor\n return conversion_factor(u1, u2, t1, t2);\n }\n\n // throws incompatibleUnits exceptions\n double conversion_factor(UnitType u1, UnitType u2, UnitClass t1, UnitClass t2)\n {\n // can't convert between groups\n if (t1 != t2) return 0;\n // get absolute offset\n // used for array acces\n size_t i1 = u1 - t1;\n size_t i2 = u2 - t2;\n // process known units\n switch (t1) {\n case LENGTH:\n return size_conversion_factors[i1][i2];\n case ANGLE:\n return angle_conversion_factors[i1][i2];\n case TIME:\n return time_conversion_factors[i1][i2];\n case FREQUENCY:\n return frequency_conversion_factors[i1][i2];\n case RESOLUTION:\n return resolution_conversion_factors[i1][i2];\n case INCOMMENSURABLE:\n return 0;\n }\n // fallback\n return 0;\n }\n\n double convert_units(const std::string& lhs, const std::string& rhs, int& lhsexp, int& rhsexp)\n {\n double f = 0;\n // do not convert same ones\n if (lhs == rhs) return 0;\n // skip already canceled out unit\n if (lhsexp == 0) return 0;\n if (rhsexp == 0) return 0;\n // check if it can be converted\n UnitType ulhs = string_to_unit(lhs);\n UnitType urhs = string_to_unit(rhs);\n // skip units we cannot convert\n if (ulhs == UNKNOWN) return 0;\n if (urhs == UNKNOWN) return 0;\n // query unit group types\n UnitClass clhs = get_unit_type(ulhs);\n UnitClass crhs = get_unit_type(urhs);\n // skip units we cannot convert\n if (clhs != crhs) return 0;\n // if right denominator is bigger than lhs, we want to keep it in rhs unit\n if (rhsexp < 0 && lhsexp > 0 && - rhsexp > lhsexp) {\n // get the conversion factor for units\n f = conversion_factor(urhs, ulhs, clhs, crhs);\n // left hand side has been consumned\n f = std::pow(f, lhsexp);\n rhsexp += lhsexp;\n lhsexp = 0;\n }\n else {\n // get the conversion factor for units\n f = conversion_factor(ulhs, urhs, clhs, crhs);\n // right hand side has been consumned\n f = std::pow(f, rhsexp);\n lhsexp += rhsexp;\n rhsexp = 0;\n }\n return f;\n }\n\n bool Units::operator< (const Units& rhs) const\n {\n return (numerators < rhs.numerators) &&\n (denominators < rhs.denominators);\n }\n bool Units::operator== (const Units& rhs) const\n {\n return (numerators == rhs.numerators) &&\n (denominators == rhs.denominators);\n }\n\n double Units::normalize()\n {\n\n size_t iL = numerators.size();\n size_t nL = denominators.size();\n\n // the final conversion factor\n double factor = 1;\n\n for (size_t i = 0; i < iL; i++) {\n std::string &lhs = numerators[i];\n UnitType ulhs = string_to_unit(lhs);\n if (ulhs == UNKNOWN) continue;\n UnitClass clhs = get_unit_type(ulhs);\n UnitType umain = get_main_unit(clhs);\n if (ulhs == umain) continue;\n double f(conversion_factor(umain, ulhs, clhs, clhs));\n if (f == 0) throw std::runtime_error(\"INVALID\");\n numerators[i] = unit_to_string(umain);\n factor /= f;\n }\n\n for (size_t n = 0; n < nL; n++) {\n std::string &rhs = denominators[n];\n UnitType urhs = string_to_unit(rhs);\n if (urhs == UNKNOWN) continue;\n UnitClass crhs = get_unit_type(urhs);\n UnitType umain = get_main_unit(crhs);\n if (urhs == umain) continue;\n double f(conversion_factor(umain, urhs, crhs, crhs));\n if (f == 0) throw std::runtime_error(\"INVALID\");\n denominators[n] = unit_to_string(umain);\n factor /= f;\n }\n\n std::sort (numerators.begin(), numerators.end());\n std::sort (denominators.begin(), denominators.end());\n\n // return for conversion\n return factor;\n }\n\n double Units::reduce()\n {\n\n size_t iL = numerators.size();\n size_t nL = denominators.size();\n\n // have less than two units?\n if (iL + nL < 2) return 1;\n\n // first make sure same units cancel each other out\n // it seems that a map table will fit nicely to do this\n // we basically construct exponents for each unit\n // has the advantage that they will be pre-sorted\n std::map exponents;\n\n // initialize by summing up occurences in unit vectors\n // this will already cancel out equivalent units (e.q. px/px)\n for (size_t i = 0; i < iL; i ++) exponents[numerators[i]] += 1;\n for (size_t n = 0; n < nL; n ++) exponents[denominators[n]] -= 1;\n\n // the final conversion factor\n double factor = 1;\n\n // convert between compatible units\n for (size_t i = 0; i < iL; i++) {\n for (size_t n = 0; n < nL; n++) {\n std::string &lhs = numerators[i], &rhs = denominators[n];\n int &lhsexp = exponents[lhs], &rhsexp = exponents[rhs];\n double f(convert_units(lhs, rhs, lhsexp, rhsexp));\n if (f == 0) continue;\n factor /= f;\n }\n }\n\n // now we can build up the new unit arrays\n numerators.clear();\n denominators.clear();\n\n // recreate sorted units vectors\n for (auto exp : exponents) {\n int &exponent = exp.second;\n while (exponent > 0 && exponent --)\n numerators.push_back(exp.first);\n while (exponent < 0 && exponent ++)\n denominators.push_back(exp.first);\n }\n\n // return for conversion\n return factor;\n\n }\n\n std::string Units::unit() const\n {\n std::string u;\n size_t iL = numerators.size();\n size_t nL = denominators.size();\n for (size_t i = 0; i < iL; i += 1) {\n if (i) u += '*';\n u += numerators[i];\n }\n if (nL != 0) u += '/';\n for (size_t n = 0; n < nL; n += 1) {\n if (n) u += '*';\n u += denominators[n];\n }\n return u;\n }\n\n bool Units::is_unitless() const\n {\n return numerators.empty() &&\n denominators.empty();\n }\n\n bool Units::is_valid_css_unit() const\n {\n return numerators.size() <= 1 &&\n denominators.size() == 0;\n }\n\n // this does not cover all cases (multiple prefered units)\n double Units::convert_factor(const Units& r) const\n {\n\n std::vector miss_nums(0);\n std::vector miss_dens(0);\n // create copy since we need these for state keeping\n std::vector r_nums(r.numerators);\n std::vector r_dens(r.denominators);\n\n auto l_num_it = numerators.begin();\n auto l_num_end = numerators.end();\n\n bool l_unitless = is_unitless();\n auto r_unitless = r.is_unitless();\n\n // overall conversion\n double factor = 1;\n\n // process all left numerators\n while (l_num_it != l_num_end)\n {\n // get and increment afterwards\n const std::string l_num = *(l_num_it ++);\n\n auto r_num_it = r_nums.begin(), r_num_end = r_nums.end();\n\n bool found = false;\n // search for compatible numerator\n while (r_num_it != r_num_end)\n {\n // get and increment afterwards\n const std::string r_num = *(r_num_it);\n // get possible conversion factor for units\n double conversion = conversion_factor(l_num, r_num);\n // skip incompatible numerator\n if (conversion == 0) {\n ++ r_num_it;\n continue;\n }\n // apply to global factor\n factor *= conversion;\n // remove item from vector\n r_nums.erase(r_num_it);\n // found numerator\n found = true;\n break;\n }\n // maybe we did not find any\n // left numerator is leftover\n if (!found) miss_nums.push_back(l_num);\n }\n\n auto l_den_it = denominators.begin();\n auto l_den_end = denominators.end();\n\n // process all left denominators\n while (l_den_it != l_den_end)\n {\n // get and increment afterwards\n const std::string l_den = *(l_den_it ++);\n\n auto r_den_it = r_dens.begin();\n auto r_den_end = r_dens.end();\n\n bool found = false;\n // search for compatible denominator\n while (r_den_it != r_den_end)\n {\n // get and increment afterwards\n const std::string r_den = *(r_den_it);\n // get possible converstion factor for units\n double conversion = conversion_factor(l_den, r_den);\n // skip incompatible denominator\n if (conversion == 0) {\n ++ r_den_it;\n continue;\n }\n // apply to global factor\n factor /= conversion;\n // remove item from vector\n r_dens.erase(r_den_it);\n // found denominator\n found = true;\n break;\n }\n // maybe we did not find any\n // left denominator is leftover\n if (!found) miss_dens.push_back(l_den);\n }\n\n // check left-overs (ToDo: might cancel out?)\n if (miss_nums.size() > 0 && !r_unitless) {\n throw Exception::IncompatibleUnits(r, *this);\n }\n else if (miss_dens.size() > 0 && !r_unitless) {\n throw Exception::IncompatibleUnits(r, *this);\n }\n else if (r_nums.size() > 0 && !l_unitless) {\n throw Exception::IncompatibleUnits(r, *this);\n }\n else if (r_dens.size() > 0 && !l_unitless) {\n throw Exception::IncompatibleUnits(r, *this);\n }\n\n return factor;\n }\n\n}\n" }, { "path": "libsass-build/units.hpp", "content": "#ifndef SASS_UNITS_H\n#define SASS_UNITS_H\n\n#include \n#include \n#include \n#include \n\nnamespace Sass {\n\n const double PI = std::acos(-1);\n\n enum UnitClass {\n LENGTH = 0x000,\n ANGLE = 0x100,\n TIME = 0x200,\n FREQUENCY = 0x300,\n RESOLUTION = 0x400,\n INCOMMENSURABLE = 0x500\n };\n\n enum UnitType {\n\n // size units\n IN = UnitClass::LENGTH,\n CM,\n PC,\n MM,\n PT,\n PX,\n\n // angle units\n DEG = ANGLE,\n GRAD,\n RAD,\n TURN,\n\n // time units\n SEC = TIME,\n MSEC,\n\n // frequency units\n HERTZ = FREQUENCY,\n KHERTZ,\n\n // resolutions units\n DPI = RESOLUTION,\n DPCM,\n DPPX,\n\n // for unknown units\n UNKNOWN = INCOMMENSURABLE\n\n };\n\n class Units {\n public:\n std::vector numerators;\n std::vector denominators;\n public:\n // default constructor\n Units() :\n numerators(),\n denominators()\n { }\n // copy constructor\n Units(const Units* ptr) :\n numerators(ptr->numerators),\n denominators(ptr->denominators)\n { }\n // convert to string\n std::string unit() const;\n // get if units are empty\n bool is_unitless() const;\n // return if valid for css\n bool is_valid_css_unit() const;\n // reduce units for output\n // returns conversion factor\n double reduce();\n // normalize units for compare\n // returns conversion factor\n double normalize();\n // compare operations\n bool operator< (const Units& rhs) const;\n bool operator== (const Units& rhs) const;\n // factor to convert into given units\n double convert_factor(const Units&) const;\n };\n\n extern const double size_conversion_factors[6][6];\n extern const double angle_conversion_factors[4][4];\n extern const double time_conversion_factors[2][2];\n extern const double frequency_conversion_factors[2][2];\n extern const double resolution_conversion_factors[3][3];\n\n UnitType get_main_unit(const UnitClass unit);\n enum Sass::UnitType string_to_unit(const std::string&);\n const char* unit_to_string(Sass::UnitType unit);\n enum Sass::UnitClass get_unit_type(Sass::UnitType unit);\n std::string get_unit_class(Sass::UnitType unit);\n std::string unit_to_class(const std::string&);\n // throws incompatibleUnits exceptions\n double conversion_factor(const std::string&, const std::string&);\n double conversion_factor(UnitType, UnitType, UnitClass, UnitClass);\n double convert_units(const std::string&, const std::string&, int&, int&);\n\n}\n\n#endif\n" }, { "path": "libsass-build/utf8/checked.h", "content": "// Copyright 2006 Nemanja Trifunovic\n\n/*\nPermission is hereby granted, free of charge, to any person or organization\nobtaining a copy of the software and accompanying documentation covered by\nthis license (the \"Software\") to use, reproduce, display, distribute,\nexecute, and transmit the Software, and to prepare derivative works of the\nSoftware, and to permit third-parties to whom the Software is furnished to\ndo so, all subject to the following:\n\nThe copyright notices in the Software and this entire statement, including\nthe above license grant, this restriction and the following disclaimer,\nmust be included in all copies of the Software, in whole or in part, and\nall derivative works of the Software, unless such copies or derivative\nworks are solely in the form of machine-executable object code generated by\na source language processor.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT\nSHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE\nFOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,\nARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n*/\n\n\n#ifndef UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731\n#define UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731\n\n#include \"core.h\"\n#include \n\nnamespace utf8\n{\n // Base for the exceptions that may be thrown from the library\n class exception : public ::std::exception {\n };\n\n // Exceptions that may be thrown from the library functions.\n class invalid_code_point : public exception {\n uint32_t cp;\n public:\n invalid_code_point(uint32_t cp) : cp(cp) {}\n virtual const char* what() const throw() { return \"Invalid code point\"; }\n uint32_t code_point() const {return cp;}\n };\n\n class invalid_utf8 : public exception {\n uint8_t u8;\n public:\n invalid_utf8 (uint8_t u) : u8(u) {}\n virtual const char* what() const throw() { return \"Invalid UTF-8\"; }\n uint8_t utf8_octet() const {return u8;}\n };\n\n class invalid_utf16 : public exception {\n uint16_t u16;\n public:\n invalid_utf16 (uint16_t u) : u16(u) {}\n virtual const char* what() const throw() { return \"Invalid UTF-16\"; }\n uint16_t utf16_word() const {return u16;}\n };\n\n class not_enough_room : public exception {\n public:\n virtual const char* what() const throw() { return \"Not enough space\"; }\n };\n\n /// The library API - functions intended to be called by the users\n\n template \n octet_iterator append(uint32_t cp, octet_iterator result)\n {\n if (!utf8::internal::is_code_point_valid(cp))\n throw invalid_code_point(cp);\n\n if (cp < 0x80) // one octet\n *(result++) = static_cast(cp);\n else if (cp < 0x800) { // two octets\n *(result++) = static_cast((cp >> 6) | 0xc0);\n *(result++) = static_cast((cp & 0x3f) | 0x80);\n }\n else if (cp < 0x10000) { // three octets\n *(result++) = static_cast((cp >> 12) | 0xe0);\n *(result++) = static_cast(((cp >> 6) & 0x3f) | 0x80);\n *(result++) = static_cast((cp & 0x3f) | 0x80);\n }\n else { // four octets\n *(result++) = static_cast((cp >> 18) | 0xf0);\n *(result++) = static_cast(((cp >> 12) & 0x3f) | 0x80);\n *(result++) = static_cast(((cp >> 6) & 0x3f) | 0x80);\n *(result++) = static_cast((cp & 0x3f) | 0x80);\n }\n return result;\n }\n\n template \n output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, uint32_t replacement)\n {\n while (start != end) {\n octet_iterator sequence_start = start;\n internal::utf_error err_code = utf8::internal::validate_next(start, end);\n switch (err_code) {\n case internal::UTF8_OK :\n for (octet_iterator it = sequence_start; it != start; ++it)\n *out++ = *it;\n break;\n case internal::NOT_ENOUGH_ROOM:\n throw not_enough_room();\n case internal::INVALID_LEAD:\n out = utf8::append (replacement, out);\n ++start;\n break;\n case internal::INCOMPLETE_SEQUENCE:\n case internal::OVERLONG_SEQUENCE:\n case internal::INVALID_CODE_POINT:\n out = utf8::append (replacement, out);\n ++start;\n // just one replacement mark for the sequence\n while (start != end && utf8::internal::is_trail(*start))\n ++start;\n break;\n }\n }\n return out;\n }\n\n template \n inline output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out)\n {\n static const uint32_t replacement_marker = utf8::internal::mask16(0xfffd);\n return utf8::replace_invalid(start, end, out, replacement_marker);\n }\n\n template \n uint32_t next(octet_iterator& it, octet_iterator end)\n {\n uint32_t cp = 0;\n internal::utf_error err_code = utf8::internal::validate_next(it, end, cp);\n switch (err_code) {\n case internal::UTF8_OK :\n break;\n case internal::NOT_ENOUGH_ROOM :\n throw not_enough_room();\n case internal::INVALID_LEAD :\n case internal::INCOMPLETE_SEQUENCE :\n case internal::OVERLONG_SEQUENCE :\n throw invalid_utf8(*it);\n case internal::INVALID_CODE_POINT :\n throw invalid_code_point(cp);\n }\n return cp;\n }\n\n template \n uint32_t peek_next(octet_iterator it, octet_iterator end)\n {\n return utf8::next(it, end);\n }\n\n template \n uint32_t prior(octet_iterator& it, octet_iterator start)\n {\n // can't do much if it == start\n if (it == start)\n throw not_enough_room();\n\n octet_iterator end = it;\n // Go back until we hit either a lead octet or start\n while (utf8::internal::is_trail(*(--it)))\n if (it == start)\n throw invalid_utf8(*it); // error - no lead byte in the sequence\n return utf8::peek_next(it, end);\n }\n\n /// Deprecated in versions that include \"prior\"\n template \n uint32_t previous(octet_iterator& it, octet_iterator pass_start)\n {\n octet_iterator end = it;\n while (utf8::internal::is_trail(*(--it)))\n if (it == pass_start)\n throw invalid_utf8(*it); // error - no lead byte in the sequence\n octet_iterator temp = it;\n return utf8::next(temp, end);\n }\n\n template \n void advance (octet_iterator& it, distance_type n, octet_iterator end)\n {\n for (distance_type i = 0; i < n; ++i)\n utf8::next(it, end);\n }\n\n template \n void retreat (octet_iterator& it, distance_type n, octet_iterator start)\n {\n for (distance_type i = 0; i < n; ++i)\n utf8::prior(it, start);\n }\n\n template \n typename std::iterator_traits::difference_type\n distance (octet_iterator first, octet_iterator last)\n {\n typename std::iterator_traits::difference_type dist;\n for (dist = 0; first < last; ++dist)\n utf8::next(first, last);\n return dist;\n }\n\n template \n octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)\n {\n while (start != end) {\n uint32_t cp = utf8::internal::mask16(*start++);\n // Take care of surrogate pairs first\n if (utf8::internal::is_lead_surrogate(cp)) {\n if (start != end) {\n uint32_t trail_surrogate = utf8::internal::mask16(*start++);\n if (utf8::internal::is_trail_surrogate(trail_surrogate))\n cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;\n else\n throw invalid_utf16(static_cast(trail_surrogate));\n }\n else\n throw invalid_utf16(static_cast(cp));\n\n }\n // Lone trail surrogate\n else if (utf8::internal::is_trail_surrogate(cp))\n throw invalid_utf16(static_cast(cp));\n\n result = utf8::append(cp, result);\n }\n return result;\n }\n\n template \n u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)\n {\n while (start != end) {\n uint32_t cp = utf8::next(start, end);\n if (cp > 0xffff) { //make a surrogate pair\n *result++ = static_cast((cp >> 10) + internal::LEAD_OFFSET);\n *result++ = static_cast((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);\n }\n else\n *result++ = static_cast(cp);\n }\n return result;\n }\n\n template \n octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result)\n {\n while (start != end)\n result = utf8::append(*(start++), result);\n\n return result;\n }\n\n template \n u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)\n {\n while (start != end)\n (*result++) = utf8::next(start, end);\n\n return result;\n }\n\n // The iterator class\n template \n class iterator : public std::iterator {\n octet_iterator it;\n octet_iterator range_start;\n octet_iterator range_end;\n public:\n iterator () {}\n explicit iterator (const octet_iterator& octet_it,\n const octet_iterator& range_start,\n const octet_iterator& range_end) :\n it(octet_it), range_start(range_start), range_end(range_end)\n {\n if (it < range_start || it > range_end)\n throw std::out_of_range(\"Invalid utf-8 iterator position\");\n }\n // the default \"big three\" are OK\n octet_iterator base () const { return it; }\n uint32_t operator * () const\n {\n octet_iterator temp = it;\n return utf8::next(temp, range_end);\n }\n bool operator == (const iterator& rhs) const\n {\n if (range_start != rhs.range_start || range_end != rhs.range_end)\n throw std::logic_error(\"Comparing utf-8 iterators defined with different ranges\");\n return (it == rhs.it);\n }\n bool operator != (const iterator& rhs) const\n {\n return !(operator == (rhs));\n }\n iterator& operator ++ ()\n {\n utf8::next(it, range_end);\n return *this;\n }\n iterator operator ++ (int)\n {\n iterator temp = *this;\n utf8::next(it, range_end);\n return temp;\n }\n iterator& operator -- ()\n {\n utf8::prior(it, range_start);\n return *this;\n }\n iterator operator -- (int)\n {\n iterator temp = *this;\n utf8::prior(it, range_start);\n return temp;\n }\n }; // class iterator\n\n} // namespace utf8\n\n#endif //header guard\n\n\n" }, { "path": "libsass-build/utf8/core.h", "content": "// Copyright 2006 Nemanja Trifunovic\n\n/*\nPermission is hereby granted, free of charge, to any person or organization\nobtaining a copy of the software and accompanying documentation covered by\nthis license (the \"Software\") to use, reproduce, display, distribute,\nexecute, and transmit the Software, and to prepare derivative works of the\nSoftware, and to permit third-parties to whom the Software is furnished to\ndo so, all subject to the following:\n\nThe copyright notices in the Software and this entire statement, including\nthe above license grant, this restriction and the following disclaimer,\nmust be included in all copies of the Software, in whole or in part, and\nall derivative works of the Software, unless such copies or derivative\nworks are solely in the form of machine-executable object code generated by\na source language processor.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT\nSHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE\nFOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,\nARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n*/\n\n\n#ifndef UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731\n#define UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731\n\n#include \n\nnamespace utf8\n{\n // The typedefs for 8-bit, 16-bit and 32-bit unsigned integers\n // You may need to change them to match your system.\n // These typedefs have the same names as ones from cstdint, or boost/cstdint\n typedef unsigned char uint8_t;\n typedef unsigned short uint16_t;\n typedef unsigned int uint32_t;\n\n// Helper code - not intended to be directly called by the library users. May be changed at any time\nnamespace internal\n{\n // Unicode constants\n // Leading (high) surrogates: 0xd800 - 0xdbff\n // Trailing (low) surrogates: 0xdc00 - 0xdfff\n const uint16_t LEAD_SURROGATE_MIN = 0xd800u;\n const uint16_t LEAD_SURROGATE_MAX = 0xdbffu;\n const uint16_t TRAIL_SURROGATE_MIN = 0xdc00u;\n const uint16_t TRAIL_SURROGATE_MAX = 0xdfffu;\n const uint16_t LEAD_OFFSET = LEAD_SURROGATE_MIN - (0x10000 >> 10);\n const uint32_t SURROGATE_OFFSET = 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN;\n\n // Maximum valid value for a Unicode code point\n const uint32_t CODE_POINT_MAX = 0x0010ffffu;\n\n template\n inline uint8_t mask8(octet_type oc)\n {\n return static_cast(0xff & oc);\n }\n template\n inline uint16_t mask16(u16_type oc)\n {\n return static_cast(0xffff & oc);\n }\n template\n inline bool is_trail(octet_type oc)\n {\n return ((utf8::internal::mask8(oc) >> 6) == 0x2);\n }\n\n template \n inline bool is_lead_surrogate(u16 cp)\n {\n return (cp >= LEAD_SURROGATE_MIN && cp <= LEAD_SURROGATE_MAX);\n }\n\n template \n inline bool is_trail_surrogate(u16 cp)\n {\n return (cp >= TRAIL_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);\n }\n\n template \n inline bool is_surrogate(u16 cp)\n {\n return (cp >= LEAD_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);\n }\n\n template \n inline bool is_code_point_valid(u32 cp)\n {\n return (cp <= CODE_POINT_MAX && !utf8::internal::is_surrogate(cp));\n }\n\n template \n inline typename std::iterator_traits::difference_type\n sequence_length(octet_iterator lead_it)\n {\n uint8_t lead = utf8::internal::mask8(*lead_it);\n if (lead < 0x80)\n return 1;\n else if ((lead >> 5) == 0x6)\n return 2;\n else if ((lead >> 4) == 0xe)\n return 3;\n else if ((lead >> 3) == 0x1e)\n return 4;\n else\n return 0;\n }\n\n template \n inline bool is_overlong_sequence(uint32_t cp, octet_difference_type length)\n {\n if (cp < 0x80) {\n if (length != 1)\n return true;\n }\n else if (cp < 0x800) {\n if (length != 2)\n return true;\n }\n else if (cp < 0x10000) {\n if (length != 3)\n return true;\n }\n\n return false;\n }\n\n enum utf_error {UTF8_OK, NOT_ENOUGH_ROOM, INVALID_LEAD, INCOMPLETE_SEQUENCE, OVERLONG_SEQUENCE, INVALID_CODE_POINT};\n\n /// Helper for get_sequence_x\n template \n utf_error increase_safely(octet_iterator& it, octet_iterator end)\n {\n if (++it == end)\n return NOT_ENOUGH_ROOM;\n\n if (!utf8::internal::is_trail(*it))\n return INCOMPLETE_SEQUENCE;\n\n return UTF8_OK;\n }\n\n #define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;}\n\n /// get_sequence_x functions decode utf-8 sequences of the length x\n template \n utf_error get_sequence_1(octet_iterator& it, octet_iterator end, uint32_t& code_point)\n {\n if (it == end)\n return NOT_ENOUGH_ROOM;\n\n code_point = utf8::internal::mask8(*it);\n\n return UTF8_OK;\n }\n\n template \n utf_error get_sequence_2(octet_iterator& it, octet_iterator end, uint32_t& code_point)\n {\n if (it == end)\n return NOT_ENOUGH_ROOM;\n\n code_point = utf8::internal::mask8(*it);\n\n UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)\n\n code_point = ((code_point << 6) & 0x7ff) + ((*it) & 0x3f);\n\n return UTF8_OK;\n }\n\n template \n utf_error get_sequence_3(octet_iterator& it, octet_iterator end, uint32_t& code_point)\n {\n if (it == end)\n return NOT_ENOUGH_ROOM;\n\n code_point = utf8::internal::mask8(*it);\n\n UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)\n\n code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);\n\n UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)\n\n code_point += (*it) & 0x3f;\n\n return UTF8_OK;\n }\n\n template \n utf_error get_sequence_4(octet_iterator& it, octet_iterator end, uint32_t& code_point)\n {\n if (it == end)\n return NOT_ENOUGH_ROOM;\n\n code_point = utf8::internal::mask8(*it);\n\n UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)\n\n code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);\n\n UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)\n\n code_point += (utf8::internal::mask8(*it) << 6) & 0xfff;\n\n UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)\n\n code_point += (*it) & 0x3f;\n\n return UTF8_OK;\n }\n\n #undef UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR\n\n template \n utf_error validate_next(octet_iterator& it, octet_iterator end, uint32_t& code_point)\n {\n // Save the original value of it so we can go back in case of failure\n // Of course, it does not make much sense with i.e. stream iterators\n octet_iterator original_it = it;\n\n uint32_t cp = 0;\n // Determine the sequence length based on the lead octet\n typedef typename std::iterator_traits::difference_type octet_difference_type;\n const octet_difference_type length = utf8::internal::sequence_length(it);\n\n // Get trail octets and calculate the code point\n utf_error err = UTF8_OK;\n switch (length) {\n case 0:\n return INVALID_LEAD;\n case 1:\n err = utf8::internal::get_sequence_1(it, end, cp);\n break;\n case 2:\n err = utf8::internal::get_sequence_2(it, end, cp);\n break;\n case 3:\n err = utf8::internal::get_sequence_3(it, end, cp);\n break;\n case 4:\n err = utf8::internal::get_sequence_4(it, end, cp);\n break;\n }\n\n if (err == UTF8_OK) {\n // Decoding succeeded. Now, security checks...\n if (utf8::internal::is_code_point_valid(cp)) {\n if (!utf8::internal::is_overlong_sequence(cp, length)){\n // Passed! Return here.\n code_point = cp;\n ++it;\n return UTF8_OK;\n }\n else\n err = OVERLONG_SEQUENCE;\n }\n else\n err = INVALID_CODE_POINT;\n }\n\n // Failure branch - restore the original value of the iterator\n it = original_it;\n return err;\n }\n\n template \n inline utf_error validate_next(octet_iterator& it, octet_iterator end) {\n uint32_t ignored;\n return utf8::internal::validate_next(it, end, ignored);\n }\n\n} // namespace internal\n\n /// The library API - functions intended to be called by the users\n\n // Byte order mark\n const uint8_t bom[] = {0xef, 0xbb, 0xbf};\n\n template \n octet_iterator find_invalid(octet_iterator start, octet_iterator end)\n {\n octet_iterator result = start;\n while (result != end) {\n utf8::internal::utf_error err_code = utf8::internal::validate_next(result, end);\n if (err_code != internal::UTF8_OK)\n return result;\n }\n return result;\n }\n\n template \n inline bool is_valid(octet_iterator start, octet_iterator end)\n {\n return (utf8::find_invalid(start, end) == end);\n }\n\n template \n inline bool starts_with_bom (octet_iterator it, octet_iterator end)\n {\n return (\n ((it != end) && (utf8::internal::mask8(*it++)) == bom[0]) &&\n ((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) &&\n ((it != end) && (utf8::internal::mask8(*it)) == bom[2])\n );\n }\n\n //Deprecated in release 2.3\n template \n inline bool is_bom (octet_iterator it)\n {\n return (\n (utf8::internal::mask8(*it++)) == bom[0] &&\n (utf8::internal::mask8(*it++)) == bom[1] &&\n (utf8::internal::mask8(*it)) == bom[2]\n );\n }\n} // namespace utf8\n\n#endif // header guard\n\n\n" }, { "path": "libsass-build/utf8/unchecked.h", "content": "// Copyright 2006 Nemanja Trifunovic\n\n/*\nPermission is hereby granted, free of charge, to any person or organization\nobtaining a copy of the software and accompanying documentation covered by\nthis license (the \"Software\") to use, reproduce, display, distribute,\nexecute, and transmit the Software, and to prepare derivative works of the\nSoftware, and to permit third-parties to whom the Software is furnished to\ndo so, all subject to the following:\n\nThe copyright notices in the Software and this entire statement, including\nthe above license grant, this restriction and the following disclaimer,\nmust be included in all copies of the Software, in whole or in part, and\nall derivative works of the Software, unless such copies or derivative\nworks are solely in the form of machine-executable object code generated by\na source language processor.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT\nSHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE\nFOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,\nARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n*/\n\n\n#ifndef UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731\n#define UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731\n\n#include \"core.h\"\n\nnamespace utf8\n{\n namespace unchecked\n {\n template \n octet_iterator append(uint32_t cp, octet_iterator result)\n {\n if (cp < 0x80) // one octet\n *(result++) = static_cast(cp);\n else if (cp < 0x800) { // two octets\n *(result++) = static_cast((cp >> 6) | 0xc0);\n *(result++) = static_cast((cp & 0x3f) | 0x80);\n }\n else if (cp < 0x10000) { // three octets\n *(result++) = static_cast((cp >> 12) | 0xe0);\n *(result++) = static_cast(((cp >> 6) & 0x3f) | 0x80);\n *(result++) = static_cast((cp & 0x3f) | 0x80);\n }\n else { // four octets\n *(result++) = static_cast((cp >> 18) | 0xf0);\n *(result++) = static_cast(((cp >> 12) & 0x3f)| 0x80);\n *(result++) = static_cast(((cp >> 6) & 0x3f) | 0x80);\n *(result++) = static_cast((cp & 0x3f) | 0x80);\n }\n return result;\n }\n\n template \n uint32_t next(octet_iterator& it)\n {\n uint32_t cp = utf8::internal::mask8(*it);\n typename std::iterator_traits::difference_type length = utf8::internal::sequence_length(it);\n switch (length) {\n case 1:\n break;\n case 2:\n it++;\n cp = ((cp << 6) & 0x7ff) + ((*it) & 0x3f);\n break;\n case 3:\n ++it;\n cp = ((cp << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);\n ++it;\n cp += (*it) & 0x3f;\n break;\n case 4:\n ++it;\n cp = ((cp << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);\n ++it;\n cp += (utf8::internal::mask8(*it) << 6) & 0xfff;\n ++it;\n cp += (*it) & 0x3f;\n break;\n }\n ++it;\n return cp;\n }\n\n template \n uint32_t peek_next(octet_iterator it)\n {\n return utf8::unchecked::next(it);\n }\n\n template \n uint32_t prior(octet_iterator& it)\n {\n while (utf8::internal::is_trail(*(--it))) ;\n octet_iterator temp = it;\n return utf8::unchecked::next(temp);\n }\n\n // Deprecated in versions that include prior, but only for the sake of consistency (see utf8::previous)\n template \n inline uint32_t previous(octet_iterator& it)\n {\n return utf8::unchecked::prior(it);\n }\n\n template \n void advance (octet_iterator& it, distance_type n)\n {\n for (distance_type i = 0; i < n; ++i)\n utf8::unchecked::next(it);\n }\n\n template \n void retreat (octet_iterator& it, distance_type n)\n {\n for (distance_type i = 0; i < n; ++i)\n utf8::unchecked::prior(it);\n }\n\n template \n typename std::iterator_traits::difference_type\n distance (octet_iterator first, octet_iterator last)\n {\n typename std::iterator_traits::difference_type dist;\n for (dist = 0; first < last; ++dist)\n utf8::unchecked::next(first);\n return dist;\n }\n\n template \n octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)\n {\n while (start != end) {\n uint32_t cp = utf8::internal::mask16(*start++);\n // Take care of surrogate pairs first\n if (utf8::internal::is_lead_surrogate(cp)) {\n uint32_t trail_surrogate = utf8::internal::mask16(*start++);\n cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;\n }\n result = utf8::unchecked::append(cp, result);\n }\n return result;\n }\n\n template \n u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)\n {\n while (start < end) {\n uint32_t cp = utf8::unchecked::next(start);\n if (cp > 0xffff) { //make a surrogate pair\n *result++ = static_cast((cp >> 10) + internal::LEAD_OFFSET);\n *result++ = static_cast((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);\n }\n else\n *result++ = static_cast(cp);\n }\n return result;\n }\n\n template \n octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result)\n {\n while (start != end)\n result = utf8::unchecked::append(*(start++), result);\n\n return result;\n }\n\n template \n u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)\n {\n while (start < end)\n (*result++) = utf8::unchecked::next(start);\n\n return result;\n }\n\n // The iterator class\n template \n class iterator : public std::iterator {\n octet_iterator it;\n public:\n iterator () {}\n explicit iterator (const octet_iterator& octet_it): it(octet_it) {}\n // the default \"big three\" are OK\n octet_iterator base () const { return it; }\n uint32_t operator * () const\n {\n octet_iterator temp = it;\n return utf8::unchecked::next(temp);\n }\n bool operator == (const iterator& rhs) const\n {\n return (it == rhs.it);\n }\n bool operator != (const iterator& rhs) const\n {\n return !(operator == (rhs));\n }\n iterator& operator ++ ()\n {\n ::std::advance(it, utf8::internal::sequence_length(it));\n return *this;\n }\n iterator operator ++ (int)\n {\n iterator temp = *this;\n ::std::advance(it, utf8::internal::sequence_length(it));\n return temp;\n }\n iterator& operator -- ()\n {\n utf8::unchecked::prior(it);\n return *this;\n }\n iterator operator -- (int)\n {\n iterator temp = *this;\n utf8::unchecked::prior(it);\n return temp;\n }\n }; // class iterator\n\n } // namespace utf8::unchecked\n} // namespace utf8\n\n\n#endif // header guard\n\n" }, { "path": "libsass-build/utf8.h", "content": "// Copyright 2006 Nemanja Trifunovic\n\n/*\nPermission is hereby granted, free of charge, to any person or organization\nobtaining a copy of the software and accompanying documentation covered by\nthis license (the \"Software\") to use, reproduce, display, distribute,\nexecute, and transmit the Software, and to prepare derivative works of the\nSoftware, and to permit third-parties to whom the Software is furnished to\ndo so, all subject to the following:\n\nThe copyright notices in the Software and this entire statement, including\nthe above license grant, this restriction and the following disclaimer,\nmust be included in all copies of the Software, in whole or in part, and\nall derivative works of the Software, unless such copies or derivative\nworks are solely in the form of machine-executable object code generated by\na source language processor.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT\nSHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE\nFOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,\nARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n*/\n\n\n#ifndef UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731\n#define UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731\n\n#include \"utf8/checked.h\"\n#include \"utf8/unchecked.h\"\n\n#endif // header guard\n" }, { "path": "libsass-build/utf8_string.cpp", "content": "#include \"sass.hpp\"\n#include \n#include \n#include \n#include \n\n#include \"utf8.h\"\n\nnamespace Sass {\n namespace UTF_8 {\n using std::string;\n\n // naming conventions:\n // offset: raw byte offset (0 based)\n // position: code point offset (0 based)\n // index: code point offset (1 based or negative)\n\n // function that will count the number of code points (utf-8 characters) from the given beginning to the given end\n size_t code_point_count(const string& str, size_t start, size_t end) {\n return utf8::distance(str.begin() + start, str.begin() + end);\n }\n\n size_t code_point_count(const string& str) {\n return utf8::distance(str.begin(), str.end());\n }\n\n // function that will return the byte offset at a code point position\n size_t offset_at_position(const string& str, size_t position) {\n string::const_iterator it = str.begin();\n utf8::advance(it, position, str.end());\n return std::distance(str.begin(), it);\n }\n\n // function that returns number of bytes in a character at offset\n size_t code_point_size_at_offset(const string& str, size_t offset) {\n // get iterator from string and forward by offset\n string::const_iterator stop = str.begin() + offset;\n // check if beyond boundary\n if (stop == str.end()) return 0;\n // advance by one code point\n utf8::advance(stop, 1, str.end());\n // calculate offset for code point\n return stop - str.begin() - offset;\n }\n\n // function that will return a normalized index, given a crazy one\n size_t normalize_index(int index, size_t len) {\n long signed_len = static_cast(len);\n // assuming the index is 1-based\n // we are returning a 0-based index\n if (index > 0 && index <= signed_len) {\n // positive and within string length\n return index-1;\n }\n else if (index > signed_len) {\n // positive and past string length\n return len;\n }\n else if (index == 0) {\n return 0;\n }\n else if (std::abs((double)index) <= signed_len) {\n // negative and within string length\n return index + signed_len;\n }\n else {\n // negative and past string length\n return 0;\n }\n }\n\n #ifdef _WIN32\n\n // utf16 functions\n using std::wstring;\n\n // convert from utf16/wide string to utf8 string\n string convert_from_utf16(const wstring& utf16)\n {\n string utf8;\n // pre-allocate expected memory\n utf8.reserve(sizeof(utf16)/2);\n utf8::utf16to8(utf16.begin(), utf16.end(),\n back_inserter(utf8));\n return utf8;\n }\n\n // convert from utf8 string to utf16/wide string\n wstring convert_to_utf16(const string& utf8)\n {\n wstring utf16;\n // pre-allocate expected memory\n utf16.reserve(code_point_count(utf8)*2);\n utf8::utf8to16(utf8.begin(), utf8.end(),\n back_inserter(utf16));\n return utf16;\n }\n\n #endif\n\n }\n}\n" }, { "path": "libsass-build/utf8_string.hpp", "content": "#ifndef SASS_UTF8_STRING_H\n#define SASS_UTF8_STRING_H\n\n#include \n#include \"utf8.h\"\n\nnamespace Sass {\n namespace UTF_8 {\n\n // naming conventions:\n // offset: raw byte offset (0 based)\n // position: code point offset (0 based)\n // index: code point offset (1 based or negative)\n\n // function that will count the number of code points (utf-8 characters) from the beginning to the given end\n size_t code_point_count(const std::string& str, size_t start, size_t end);\n size_t code_point_count(const std::string& str);\n\n // function that will return the byte offset of a code point in a\n size_t offset_at_position(const std::string& str, size_t position);\n\n // function that returns number of bytes in a character in a string\n size_t code_point_size_at_offset(const std::string& str, size_t offset);\n\n // function that will return a normalized index, given a crazy one\n size_t normalize_index(int index, size_t len);\n\n #ifdef _WIN32\n // functions to handle unicode paths on windows\n std::string convert_from_utf16(const std::wstring& wstr);\n std::wstring convert_to_utf16(const std::string& str);\n #endif\n\n }\n}\n\n#endif\n" }, { "path": "libsass-build/util.cpp", "content": "#include \"sass.hpp\"\n#include \"sass.h\"\n#include \"ast.hpp\"\n#include \"util.hpp\"\n#include \"lexer.hpp\"\n#include \"prelexer.hpp\"\n#include \"constants.hpp\"\n#include \"utf8/checked.h\"\n\n#include \n#include \n#if defined(_MSC_VER) && _MSC_VER >= 1800 && _MSC_VER < 1900 && defined(_M_X64)\n#include \n#endif\n\nnamespace Sass {\n\n double round(double val, size_t precision)\n {\n // Disable FMA3-optimized implementation when compiling with VS2013 for x64 targets\n // See https://github.com/sass/node-sass/issues/1854 for details\n // FIXME: Remove this workaround when we switch to VS2015+\n #if defined(_MSC_VER) && _MSC_VER >= 1800 && _MSC_VER < 1900 && defined(_M_X64)\n static std::once_flag flag;\n std::call_once(flag, []() { _set_FMA3_enable(0); });\n #endif\n\n // https://github.com/sass/sass/commit/4e3e1d5684cc29073a507578fc977434ff488c93\n if (fmod(val, 1) - 0.5 > - std::pow(0.1, precision + 1)) return std::ceil(val);\n else if (fmod(val, 1) - 0.5 > std::pow(0.1, precision)) return std::floor(val);\n // work around some compiler issue\n // cygwin has it not defined in std\n using namespace std;\n return ::round(val);\n }\n\n /* Locale unspecific atof function. */\n double sass_strtod(const char *str)\n {\n char separator = *(localeconv()->decimal_point);\n if(separator != '.'){\n // The current locale specifies another\n // separator. convert the separator to the\n // one understood by the locale if needed\n const char *found = strchr(str, '.');\n if(found != NULL){\n // substitution is required. perform the substitution on a copy\n // of the string. This is slower but it is thread safe.\n char *copy = sass_copy_c_string(str);\n *(copy + (found - str)) = separator;\n double res = strtod(copy, NULL);\n free(copy);\n return res;\n }\n }\n\n return strtod(str, NULL);\n }\n\n // helper for safe access to c_ctx\n const char* safe_str (const char* str, const char* alt) {\n return str == NULL ? alt : str;\n }\n\n void free_string_array(char ** arr) {\n if(!arr)\n return;\n\n char **it = arr;\n while (it && (*it)) {\n free(*it);\n ++it;\n }\n\n free(arr);\n }\n\n char **copy_strings(const std::vector& strings, char*** array, int skip) {\n int num = static_cast(strings.size()) - skip;\n char** arr = (char**) calloc(num + 1, sizeof(char*));\n if (arr == 0)\n return *array = (char **)NULL;\n\n for(int i = 0; i < num; i++) {\n arr[i] = (char*) malloc(sizeof(char) * (strings[i + skip].size() + 1));\n if (arr[i] == 0) {\n free_string_array(arr);\n return *array = (char **)NULL;\n }\n std::copy(strings[i + skip].begin(), strings[i + skip].end(), arr[i]);\n arr[i][strings[i + skip].size()] = '\\0';\n }\n\n arr[num] = 0;\n return *array = arr;\n }\n\n // read css string (handle multiline DELIM)\n std::string read_css_string(const std::string& str, bool css)\n {\n if (!css) return str;\n std::string out(\"\");\n bool esc = false;\n for (auto i : str) {\n if (i == '\\\\') {\n esc = ! esc;\n } else if (esc && i == '\\r') {\n continue;\n } else if (esc && i == '\\n') {\n out.resize (out.size () - 1);\n esc = false;\n continue;\n } else {\n esc = false;\n }\n out.push_back(i);\n }\n // happens when parsing does not correctly skip\n // over escaped sequences for ie. interpolations\n // one example: foo\\#{interpolate}\n // if (esc) out += '\\\\';\n return out;\n }\n\n // double escape all escape sequences\n // keep unescaped quotes and backslashes\n std::string evacuate_escapes(const std::string& str)\n {\n std::string out(\"\");\n bool esc = false;\n for (auto i : str) {\n if (i == '\\\\' && !esc) {\n out += '\\\\';\n out += '\\\\';\n esc = true;\n } else if (esc && i == '\"') {\n out += '\\\\';\n out += i;\n esc = false;\n } else if (esc && i == '\\'') {\n out += '\\\\';\n out += i;\n esc = false;\n } else if (esc && i == '\\\\') {\n out += '\\\\';\n out += i;\n esc = false;\n } else {\n esc = false;\n out += i;\n }\n }\n // happens when parsing does not correctly skip\n // over escaped sequences for ie. interpolations\n // one example: foo\\#{interpolate}\n // if (esc) out += '\\\\';\n return out;\n }\n\n // bell characters are replaced with spaces\n void newline_to_space(std::string& str)\n {\n std::replace(str.begin(), str.end(), '\\n', ' ');\n }\n\n // bell characters are replaced with spaces\n // also eats spaces after line-feeds (ltrim)\n std::string string_to_output(const std::string& str)\n {\n std::string out(\"\");\n bool lf = false;\n for (auto i : str) {\n if (i == '\\n') {\n out += ' ';\n lf = true;\n } else if (!(lf && isspace(i))) {\n out += i;\n lf = false;\n }\n }\n return out;\n }\n\n std::string escape_string(const std::string& str)\n {\n std::string out(\"\");\n for (auto i : str) {\n if (i == '\\n') {\n out += \"\\\\n\";\n } else if (i == '\\r') {\n out += \"\\\\r\";\n } else if (i == '\\t') {\n out += \"\\\\t\";\n } else {\n out += i;\n }\n }\n return out;\n }\n\n std::string comment_to_string(const std::string& text)\n {\n std::string str = \"\";\n size_t has = 0;\n char prev = 0;\n bool clean = false;\n for (auto i : text) {\n if (clean) {\n if (i == '\\n') { has = 0; }\n else if (i == '\\r') { has = 0; }\n else if (i == '\\t') { ++ has; }\n else if (i == ' ') { ++ has; }\n else if (i == '*') {}\n else {\n clean = false;\n str += ' ';\n if (prev == '*' && i == '/') str += \"*/\";\n else str += i;\n }\n } else if (i == '\\n') {\n clean = true;\n } else if (i == '\\r') {\n clean = true;\n } else {\n str += i;\n }\n prev = i;\n }\n if (has) return str;\n else return text;\n }\n\n // find best quote_mark by detecting if the string contains any single\n // or double quotes. When a single quote is found, we not we want a double\n // quote as quote_mark. Otherwise we check if the string cotains any double\n // quotes, which will trigger the use of single quotes as best quote_mark.\n char detect_best_quotemark(const char* s, char qm)\n {\n // ensure valid fallback quote_mark\n char quote_mark = qm && qm != '*' ? qm : '\"';\n while (*s) {\n // force double quotes as soon\n // as one single quote is found\n if (*s == '\\'') { return '\"'; }\n // a single does not force quote_mark\n // maybe we see a double quote later\n else if (*s == '\"') { quote_mark = '\\''; }\n ++ s;\n }\n return quote_mark;\n }\n\n std::string read_hex_escapes(const std::string& s)\n {\n\n std::string result;\n bool skipped = false;\n\n for (size_t i = 0, L = s.length(); i < L; ++i) {\n\n // implement the same strange ruby sass behavior\n // an escape sequence can also mean a unicode char\n if (s[i] == '\\\\' && !skipped) {\n\n // remember\n skipped = true;\n\n // escape length\n size_t len = 1;\n\n // parse as many sequence chars as possible\n // ToDo: Check if ruby aborts after possible max\n while (i + len < L && s[i + len] && isxdigit(s[i + len])) ++ len;\n\n if (len > 1) {\n\n // convert the extracted hex string to code point value\n // ToDo: Maybe we could do this without creating a substring\n uint32_t cp = strtol(s.substr (i + 1, len - 1).c_str(), NULL, 16);\n\n if (s[i + len] == ' ') ++ len;\n\n // assert invalid code points\n if (cp == 0) cp = 0xFFFD;\n // replace bell character\n // if (cp == '\\n') cp = 32;\n\n // use a very simple approach to convert via utf8 lib\n // maybe there is a more elegant way; maybe we shoud\n // convert the whole output from string to a stream!?\n // allocate memory for utf8 char and convert to utf8\n unsigned char u[5] = {0,0,0,0,0}; utf8::append(cp, u);\n for(size_t m = 0; m < 5 && u[m]; m++) result.push_back(u[m]);\n\n // skip some more chars?\n i += len - 1; skipped = false;\n\n }\n\n else {\n\n skipped = false;\n\n result.push_back(s[i]);\n\n }\n\n }\n\n else {\n\n result.push_back(s[i]);\n\n }\n\n }\n\n return result;\n\n }\n\n std::string unquote(const std::string& s, char* qd, bool keep_utf8_sequences, bool strict)\n {\n\n // not enough room for quotes\n // no possibility to unquote\n if (s.length() < 2) return s;\n\n char q;\n bool skipped = false;\n\n // this is no guarantee that the unquoting will work\n // what about whitespace before/after the quote_mark?\n if (*s.begin() == '\"' && *s.rbegin() == '\"') q = '\"';\n else if (*s.begin() == '\\'' && *s.rbegin() == '\\'') q = '\\'';\n else return s;\n\n std::string unq;\n unq.reserve(s.length()-2);\n\n for (size_t i = 1, L = s.length() - 1; i < L; ++i) {\n\n // implement the same strange ruby sass behavior\n // an escape sequence can also mean a unicode char\n if (s[i] == '\\\\' && !skipped) {\n // remember\n skipped = true;\n\n // skip it\n // ++ i;\n\n // if (i == L) break;\n\n // escape length\n size_t len = 1;\n\n // parse as many sequence chars as possible\n // ToDo: Check if ruby aborts after possible max\n while (i + len < L && s[i + len] && isxdigit(s[i + len])) ++ len;\n\n // hex string?\n if (keep_utf8_sequences) {\n unq.push_back(s[i]);\n } else if (len > 1) {\n\n // convert the extracted hex string to code point value\n // ToDo: Maybe we could do this without creating a substring\n uint32_t cp = strtol(s.substr (i + 1, len - 1).c_str(), NULL, 16);\n\n if (s[i + len] == ' ') ++ len;\n\n // assert invalid code points\n if (cp == 0) cp = 0xFFFD;\n // replace bell character\n // if (cp == '\\n') cp = 32;\n\n // use a very simple approach to convert via utf8 lib\n // maybe there is a more elegant way; maybe we shoud\n // convert the whole output from string to a stream!?\n // allocate memory for utf8 char and convert to utf8\n unsigned char u[5] = {0,0,0,0,0}; utf8::append(cp, u);\n for(size_t m = 0; m < 5 && u[m]; m++) unq.push_back(u[m]);\n\n // skip some more chars?\n i += len - 1; skipped = false;\n\n }\n\n\n }\n // check for unexpected delimiter\n // be strict and throw error back\n // else if (!skipped && q == s[i]) {\n // // don't be that strict\n // return s;\n // // this basically always means an internal error and not users fault\n // error(\"Unescaped delimiter in string to unquote found. [\" + s + \"]\", ParserState(\"[UNQUOTE]\"));\n // }\n else {\n if (strict && !skipped) {\n if (s[i] == q) return s;\n }\n skipped = false;\n unq.push_back(s[i]);\n }\n\n }\n if (skipped) { return s; }\n if (qd) *qd = q;\n return unq;\n\n }\n\n std::string quote(const std::string& s, char q)\n {\n\n // autodetect with fallback to given quote\n q = detect_best_quotemark(s.c_str(), q);\n\n // return an empty quoted string\n if (s.empty()) return std::string(2, q ? q : '\"');\n\n std::string quoted;\n quoted.reserve(s.length()+2);\n quoted.push_back(q);\n\n const char* it = s.c_str();\n const char* end = it + strlen(it) + 1;\n while (*it && it < end) {\n const char* now = it;\n\n if (*it == q) {\n quoted.push_back('\\\\');\n } else if (*it == '\\\\') {\n quoted.push_back('\\\\');\n }\n\n int cp = utf8::next(it, end);\n\n // in case of \\r, check if the next in sequence\n // is \\n and then advance the iterator and skip \\r\n if (cp == '\\r' && it < end && utf8::peek_next(it, end) == '\\n') {\n cp = utf8::next(it, end);\n }\n\n if (cp == '\\n') {\n quoted.push_back('\\\\');\n quoted.push_back('a');\n // we hope we can remove this flag once we figure out\n // why ruby sass has these different output behaviors\n // gsub(/\\n(?![a-fA-F0-9\\s])/, \"\\\\a\").gsub(\"\\n\", \"\\\\a \")\n using namespace Prelexer;\n if (alternatives <\n Prelexer::char_range<'a', 'f'>,\n Prelexer::char_range<'A', 'F'>,\n Prelexer::char_range<'0', '9'>,\n space\n >(it) != NULL) {\n quoted.push_back(' ');\n }\n } else if (cp < 127) {\n quoted.push_back((char) cp);\n } else {\n while (now < it) {\n quoted.push_back(*now);\n ++ now;\n }\n }\n }\n\n quoted.push_back(q);\n return quoted;\n }\n\n bool is_hex_doublet(double n)\n {\n return n == 0x00 || n == 0x11 || n == 0x22 || n == 0x33 ||\n n == 0x44 || n == 0x55 || n == 0x66 || n == 0x77 ||\n n == 0x88 || n == 0x99 || n == 0xAA || n == 0xBB ||\n n == 0xCC || n == 0xDD || n == 0xEE || n == 0xFF ;\n }\n\n bool is_color_doublet(double r, double g, double b)\n {\n return is_hex_doublet(r) && is_hex_doublet(g) && is_hex_doublet(b);\n }\n\n bool peek_linefeed(const char* start)\n {\n using namespace Prelexer;\n using namespace Constants;\n return sequence <\n zero_plus <\n alternatives <\n exactly <' '>,\n exactly <'\\t'>,\n line_comment,\n block_comment,\n delimited_by <\n slash_star,\n star_slash,\n false\n >\n >\n >,\n re_linebreak\n >(start) != 0;\n }\n\n namespace Util {\n using std::string;\n\n std::string rtrim(const std::string &str) {\n std::string trimmed = str;\n size_t pos_ws = trimmed.find_last_not_of(\" \\t\\n\\v\\f\\r\");\n if (pos_ws != std::string::npos)\n { trimmed.erase(pos_ws + 1); }\n else { trimmed.clear(); }\n return trimmed;\n }\n\n std::string normalize_underscores(const std::string& str) {\n std::string normalized = str;\n for(size_t i = 0, L = normalized.length(); i < L; ++i) {\n if(normalized[i] == '_') {\n normalized[i] = '-';\n }\n }\n return normalized;\n }\n\n std::string normalize_decimals(const std::string& str) {\n std::string prefix = \"0\";\n std::string normalized = str;\n\n return normalized[0] == '.' ? normalized.insert(0, prefix) : normalized;\n }\n\n bool isPrintable(Ruleset_Ptr r, Sass_Output_Style style) {\n if (r == NULL) {\n return false;\n }\n\n Block_Obj b = r->block();\n\n Selector_List_Ptr sl = Cast(r->selector());\n bool hasSelectors = sl ? sl->length() > 0 : false;\n\n if (!hasSelectors) {\n return false;\n }\n\n bool hasDeclarations = false;\n bool hasPrintableChildBlocks = false;\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj stm = b->at(i);\n if (Cast(stm)) {\n return true;\n } else if (Declaration_Ptr d = Cast(stm)) {\n return isPrintable(d, style);\n } else if (Has_Block_Ptr p = Cast(stm)) {\n Block_Obj pChildBlock = p->block();\n if (isPrintable(pChildBlock, style)) {\n hasPrintableChildBlocks = true;\n }\n } else if (Comment_Ptr c = Cast(stm)) {\n // keep for uncompressed\n if (style != COMPRESSED) {\n hasDeclarations = true;\n }\n // output style compressed\n if (c->is_important()) {\n hasDeclarations = c->is_important();\n }\n } else {\n hasDeclarations = true;\n }\n\n if (hasDeclarations || hasPrintableChildBlocks) {\n return true;\n }\n }\n\n return false;\n }\n\n bool isPrintable(String_Constant_Ptr s, Sass_Output_Style style)\n {\n return ! s->value().empty();\n }\n\n bool isPrintable(String_Quoted_Ptr s, Sass_Output_Style style)\n {\n return true;\n }\n\n bool isPrintable(Declaration_Ptr d, Sass_Output_Style style)\n {\n Expression_Obj val = d->value();\n if (String_Quoted_Obj sq = Cast(val)) return isPrintable(sq.ptr(), style);\n if (String_Constant_Obj sc = Cast(val)) return isPrintable(sc.ptr(), style);\n return true;\n }\n\n bool isPrintable(Supports_Block_Ptr f, Sass_Output_Style style) {\n if (f == NULL) {\n return false;\n }\n\n Block_Obj b = f->block();\n\n bool hasDeclarations = false;\n bool hasPrintableChildBlocks = false;\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj stm = b->at(i);\n if (Cast(stm) || Cast(stm)) {\n hasDeclarations = true;\n }\n else if (Has_Block_Ptr b = Cast(stm)) {\n Block_Obj pChildBlock = b->block();\n if (!b->is_invisible()) {\n if (isPrintable(pChildBlock, style)) {\n hasPrintableChildBlocks = true;\n }\n }\n }\n\n if (hasDeclarations || hasPrintableChildBlocks) {\n return true;\n }\n }\n\n return false;\n }\n\n bool isPrintable(Media_Block_Ptr m, Sass_Output_Style style)\n {\n if (m == 0) return false;\n Block_Obj b = m->block();\n if (b == 0) return false;\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj stm = b->at(i);\n if (Cast(stm)) return true;\n else if (Cast(stm)) return true;\n else if (Comment_Ptr c = Cast(stm)) {\n if (isPrintable(c, style)) {\n return true;\n }\n }\n else if (Ruleset_Ptr r = Cast(stm)) {\n if (isPrintable(r, style)) {\n return true;\n }\n }\n else if (Supports_Block_Ptr f = Cast(stm)) {\n if (isPrintable(f, style)) {\n return true;\n }\n }\n else if (Media_Block_Ptr mb = Cast(stm)) {\n if (isPrintable(mb, style)) {\n return true;\n }\n }\n else if (Has_Block_Ptr b = Cast(stm)) {\n if (isPrintable(b->block(), style)) {\n return true;\n }\n }\n }\n return false;\n }\n\n bool isPrintable(Comment_Ptr c, Sass_Output_Style style)\n {\n // keep for uncompressed\n if (style != COMPRESSED) {\n return true;\n }\n // output style compressed\n if (c->is_important()) {\n return true;\n }\n // not printable\n return false;\n };\n\n bool isPrintable(Block_Obj b, Sass_Output_Style style) {\n if (!b) {\n return false;\n }\n\n for (size_t i = 0, L = b->length(); i < L; ++i) {\n Statement_Obj stm = b->at(i);\n if (Cast(stm) || Cast(stm)) {\n return true;\n }\n else if (Comment_Ptr c = Cast(stm)) {\n if (isPrintable(c, style)) {\n return true;\n }\n }\n else if (Ruleset_Ptr r = Cast(stm)) {\n if (isPrintable(r, style)) {\n return true;\n }\n }\n else if (Supports_Block_Ptr f = Cast(stm)) {\n if (isPrintable(f, style)) {\n return true;\n }\n }\n else if (Media_Block_Ptr m = Cast(stm)) {\n if (isPrintable(m, style)) {\n return true;\n }\n }\n else if (Has_Block_Ptr b = Cast(stm)) {\n if (isPrintable(b->block(), style)) {\n return true;\n }\n }\n }\n\n return false;\n }\n\n bool isAscii(const char chr) {\n return unsigned(chr) < 128;\n }\n\n }\n}\n" }, { "path": "libsass-build/util.hpp", "content": "#ifndef SASS_UTIL_H\n#define SASS_UTIL_H\n\n#include \n#include \n#include \n#include \"sass.hpp\"\n#include \"sass/base.h\"\n#include \"ast_fwd_decl.hpp\"\n\n#define SASS_ASSERT(cond, msg) assert(cond && msg)\n\nnamespace Sass {\n\n double round(double val, size_t precision = 0);\n double sass_strtod(const char* str);\n const char* safe_str(const char *, const char* = \"\");\n void free_string_array(char **);\n char **copy_strings(const std::vector&, char ***, int = 0);\n std::string read_css_string(const std::string& str, bool css = true);\n std::string evacuate_escapes(const std::string& str);\n std::string string_to_output(const std::string& str);\n std::string comment_to_string(const std::string& text);\n std::string read_hex_escapes(const std::string& str);\n std::string escape_string(const std::string& str);\n void newline_to_space(std::string& str);\n\n std::string quote(const std::string&, char q = 0);\n std::string unquote(const std::string&, char* q = 0, bool keep_utf8_sequences = false, bool strict = true);\n char detect_best_quotemark(const char* s, char qm = '\"');\n\n bool is_hex_doublet(double n);\n bool is_color_doublet(double r, double g, double b);\n\n bool peek_linefeed(const char* start);\n\n namespace Util {\n\n std::string rtrim(const std::string& str);\n\n std::string normalize_underscores(const std::string& str);\n std::string normalize_decimals(const std::string& str);\n\n bool isPrintable(Ruleset_Ptr r, Sass_Output_Style style = NESTED);\n bool isPrintable(Supports_Block_Ptr r, Sass_Output_Style style = NESTED);\n bool isPrintable(Media_Block_Ptr r, Sass_Output_Style style = NESTED);\n bool isPrintable(Comment_Ptr b, Sass_Output_Style style = NESTED);\n bool isPrintable(Block_Obj b, Sass_Output_Style style = NESTED);\n bool isPrintable(String_Constant_Ptr s, Sass_Output_Style style = NESTED);\n bool isPrintable(String_Quoted_Ptr s, Sass_Output_Style style = NESTED);\n bool isPrintable(Declaration_Ptr d, Sass_Output_Style style = NESTED);\n bool isAscii(const char chr);\n\n }\n}\n#endif\n" }, { "path": "libsass-build/values.cpp", "content": "#include \"sass.hpp\"\n#include \"sass.h\"\n#include \"values.hpp\"\n\n#include \n\nnamespace Sass {\n\n // convert value from C++ side to C-API\n union Sass_Value* ast_node_to_sass_value (const Expression_Ptr val)\n {\n if (val->concrete_type() == Expression::NUMBER)\n {\n Number_Ptr_Const res = Cast(val);\n return sass_make_number(res->value(), res->unit().c_str());\n }\n else if (val->concrete_type() == Expression::COLOR)\n {\n Color_Ptr_Const col = Cast(val);\n return sass_make_color(col->r(), col->g(), col->b(), col->a());\n }\n else if (val->concrete_type() == Expression::LIST)\n {\n List_Ptr_Const l = Cast(val);\n union Sass_Value* list = sass_make_list(l->size(), l->separator(), l->is_bracketed());\n for (size_t i = 0, L = l->length(); i < L; ++i) {\n Expression_Obj obj = l->at(i);\n auto val = ast_node_to_sass_value(obj);\n sass_list_set_value(list, i, val);\n }\n return list;\n }\n else if (val->concrete_type() == Expression::MAP)\n {\n Map_Ptr_Const m = Cast(val);\n union Sass_Value* map = sass_make_map(m->length());\n size_t i = 0; for (Expression_Obj key : m->keys()) {\n sass_map_set_key(map, i, ast_node_to_sass_value(key));\n sass_map_set_value(map, i, ast_node_to_sass_value(m->at(key)));\n ++ i;\n }\n return map;\n }\n else if (val->concrete_type() == Expression::NULL_VAL)\n {\n return sass_make_null();\n }\n else if (val->concrete_type() == Expression::BOOLEAN)\n {\n Boolean_Ptr_Const res = Cast(val);\n return sass_make_boolean(res->value());\n }\n else if (val->concrete_type() == Expression::STRING)\n {\n if (String_Quoted_Ptr_Const qstr = Cast(val))\n {\n return sass_make_qstring(qstr->value().c_str());\n }\n else if (String_Constant_Ptr_Const cstr = Cast(val))\n {\n return sass_make_string(cstr->value().c_str());\n }\n }\n return sass_make_error(\"unknown sass value type\");\n }\n\n // convert value from C-API to C++ side\n Value_Ptr sass_value_to_ast_node (const union Sass_Value* val)\n {\n switch (sass_value_get_tag(val)) {\n case SASS_NUMBER:\n return SASS_MEMORY_NEW(Number,\n ParserState(\"[C-VALUE]\"),\n sass_number_get_value(val),\n sass_number_get_unit(val));\n case SASS_BOOLEAN:\n return SASS_MEMORY_NEW(Boolean,\n ParserState(\"[C-VALUE]\"),\n sass_boolean_get_value(val));\n case SASS_COLOR:\n return SASS_MEMORY_NEW(Color,\n ParserState(\"[C-VALUE]\"),\n sass_color_get_r(val),\n sass_color_get_g(val),\n sass_color_get_b(val),\n sass_color_get_a(val));\n case SASS_STRING:\n if (sass_string_is_quoted(val)) {\n return SASS_MEMORY_NEW(String_Quoted,\n ParserState(\"[C-VALUE]\"),\n sass_string_get_value(val));\n }\n return SASS_MEMORY_NEW(String_Constant,\n ParserState(\"[C-VALUE]\"),\n sass_string_get_value(val));\n case SASS_LIST: {\n List_Ptr l = SASS_MEMORY_NEW(List,\n ParserState(\"[C-VALUE]\"),\n sass_list_get_length(val),\n sass_list_get_separator(val));\n for (size_t i = 0, L = sass_list_get_length(val); i < L; ++i) {\n l->append(sass_value_to_ast_node(sass_list_get_value(val, i)));\n }\n l->is_bracketed(sass_list_get_is_bracketed(val));\n return l;\n }\n case SASS_MAP: {\n Map_Ptr m = SASS_MEMORY_NEW(Map, ParserState(\"[C-VALUE]\"));\n for (size_t i = 0, L = sass_map_get_length(val); i < L; ++i) {\n *m << std::make_pair(\n sass_value_to_ast_node(sass_map_get_key(val, i)),\n sass_value_to_ast_node(sass_map_get_value(val, i)));\n }\n return m;\n }\n case SASS_NULL:\n return SASS_MEMORY_NEW(Null, ParserState(\"[C-VALUE]\"));\n case SASS_ERROR:\n return SASS_MEMORY_NEW(Custom_Error,\n ParserState(\"[C-VALUE]\"),\n sass_error_get_message(val));\n case SASS_WARNING:\n return SASS_MEMORY_NEW(Custom_Warning,\n ParserState(\"[C-VALUE]\"),\n sass_warning_get_message(val));\n default: break;\n }\n return 0;\n }\n\n}\n" }, { "path": "libsass-build/values.hpp", "content": "#ifndef SASS_VALUES_H\n#define SASS_VALUES_H\n\n#include \"ast.hpp\"\n\nnamespace Sass {\n\n union Sass_Value* ast_node_to_sass_value (const Expression_Ptr val);\n Value_Ptr sass_value_to_ast_node (const union Sass_Value* val);\n\n}\n#endif\n" }, { "path": "mixins.go", "content": "package libsass\n\n// Mixins registers the default list of supported mixins\nfunc init() {\n\tRegisterHeader(`@mixin sprite-dimensions($map, $name) {\n $file: sprite-file($map, $name);\n height: image-height($file);\n width: image-width($file);\n}`)\n}\n" }, { "path": "options.go", "content": "package libsass\n\nimport \"context\"\n\n// FuncOpt enables configuration of compiler initialization\ntype FuncOpt func(*sass) error\n\n// Option allows the modifying of internal compiler state\nfunc (c *sass) Option(opts ...FuncOpt) error {\n\tfor _, opt := range opts {\n\t\terr := opt(c)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\treturn nil\n}\n\n// BasePath sets the internal path provided to handlers requiring\n// a base path for http calls. This is useful for hosted solutions\n// that need to provided absolute paths to assets.\nfunc BasePath(basePath string) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.httpPath = basePath\n\t\t// FIXME: remove from context\n\t\tc.ctx.HTTPPath = basePath\n\t\treturn nil\n\t}\n}\n\n// BuildDir only used for spriting, how terrible!\nfunc BuildDir(path string) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.ctx.BuildDir = path\n\t\treturn nil\n\t}\n}\n\n// CacheBust append timestamps to static assets to prevent caching\nfunc CacheBust(t string) FuncOpt {\n\treturn func(c *sass) error {\n\t\tif t == \"ts\" {\n\t\t\tt = \"timestamp\"\n\t\t}\n\t\tc.cachebust = t\n\t\treturn nil\n\t}\n}\n\n// Comments toggles whether comments should be included in the output\nfunc Comments(b bool) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.ctx.Comments = b\n\t\treturn nil\n\t}\n}\n\n// FontDir specifies where to find fonts\nfunc FontDir(path string) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.ctx.FontDir = path\n\t\treturn nil\n\t}\n}\n\n// HTTPPath prefixes all sprites and generated images with this uri.\n// Enabling wellington to serve images when used in HTTP mode\nfunc HTTPPath(u string) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.httpPath = u\n\t\tc.ctx.HTTPPath = u\n\t\treturn nil\n\t}\n}\n\n// ImgBuildDir specifies the destination directory for images\nfunc ImgBuildDir(path string) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.ctx.GenImgDir = path\n\t\treturn nil\n\t}\n}\n\n// ImgDir specifies where to locate images for spriting\nfunc ImgDir(path string) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.ctx.ImageDir = path\n\t\treturn nil\n\t}\n}\n\n// ImportsOption specifies configuration for import resolution\nfunc ImportsOption(imports *Imports) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.ctx.Imports = imports\n\t\treturn nil\n\t}\n}\n\n// IncludePaths adds additional directories to search for Sass files\nfunc IncludePaths(includes []string) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.includePaths = includes\n\t\tc.ctx.IncludePaths = includes\n\t\treturn nil\n\t}\n}\n\n// LineComments removes the line by line playby of the Sass compiler\nfunc LineComments(b bool) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.cmt = b\n\t\treturn nil\n\t}\n}\n\n// OutputStyle controls the presentation of the CSS available\n// option: nested, expanded, compact, compressed\nfunc OutputStyle(style int) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.ctx.OutputStyle = style\n\t\treturn nil\n\t}\n}\n\n// Precision specifies the number of points beyond the decimal\n// place is preserved during math calculations.\nfunc Precision(prec int) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.ctx.Precision = prec\n\t\treturn nil\n\t}\n}\n\n// SourceMap behaves differently depending on compiler used. For\n// compile, it will embed sourcemap into the source. For file\n// compile, it will include a separate file with the source map.\nfunc SourceMap(b bool, path, sourceMapRoot string) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.ctx.includeMap = b\n\t\tc.mappath = path\n\t\tif len(sourceMapRoot) > 0 {\n\t\t\tc.sourceMapRoot = sourceMapRoot\n\t\t}\n\t\treturn nil\n\t}\n}\n\n// Path specifies a file to read instead of using the provided\n// io.Reader. This activates file compiling that includes line numbers\n// in the resulting output.\nfunc Path(path string) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.srcFile = path\n\t\tc.ctx.MainFile = path\n\t\treturn nil\n\t}\n}\n\n// Payload gives access to sprite and image information for handlers\n// to perform spriting functions.\nfunc Payload(load context.Context) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.ctx.Payload = load\n\t\treturn nil\n\t}\n}\n\n// Syntax lists that available syntaxes for the compiler\ntype Syntax int\n\nconst (\n\tSCSSSyntax Syntax = iota\n\tSassSyntax\n)\n\nfunc WithSyntax(mode Syntax) FuncOpt {\n\treturn func(c *sass) error {\n\t\tc.syntax = mode\n\t\treturn nil\n\t}\n}\n" }, { "path": "options_test.go", "content": "package libsass\n\nimport (\n\t\"bytes\"\n\t\"testing\"\n)\n\nfunc TestOption_precision(t *testing.T) {\n\n\tin := bytes.NewBufferString(`a { height: (1/3)px; }`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.Precision = 3\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te := `a {\n height: 0.333 px; }\n`\n\tif e != out.String() {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\\n\", out.String(), e)\n\t}\n\n\tin = bytes.NewBufferString(`a { height: (1/3)px; }`)\n\tout.Reset()\n\tctx = newContext()\n\tctx.Precision = 6\n\terr = ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te = `a {\n height: 0.333333 px; }\n`\n\tif e != out.String() {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\\n\", out.String(), e)\n\t}\n\n}\n\nfunc TestOption_style(t *testing.T) {\n\tin := bytes.NewBufferString(`div { p { color: red; } }`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.OutputStyle = 0\n\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te := `div p {\n color: red; }\n`\n\tif e != out.String() {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\\n\", out.String(), e)\n\t}\n\n\tin = bytes.NewBufferString(`div { p { color: red; } }`)\n\tout.Reset()\n\tctx.OutputStyle = 1\n\terr = ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te = `div p {\n color: red;\n}\n`\n\tif e != out.String() {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\\n\", out.String(), e)\n\t}\n\n\tin = bytes.NewBufferString(`div { p { color: red; } }`)\n\tout.Reset()\n\tctx.OutputStyle = 2\n\terr = ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te = `div p { color: red; }\n`\n\tif e != out.String() {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\\n\", out.String(), e)\n\t}\n\n\tin = bytes.NewBufferString(`div { p { color: red; } }`)\n\tout.Reset()\n\tctx.OutputStyle = 3\n\terr = ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te = `div p{color:red}\n`\n\tif e != out.String() {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\\n\", out.String(), e)\n\t}\n\n}\n\nfunc TestOption_comment(t *testing.T) {\n\tin := bytes.NewBufferString(`div { p { color: red; } }`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.Comments = false\n\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te := `div p {\n color: red; }\n`\n\tif e != out.String() {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\\n\", out.String(), e)\n\t}\n\n\tin = bytes.NewBufferString(`div { p { color: red; } }`)\n\tout.Reset()\n\tctx.Comments = true\n\terr = ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te = `/* line 1, stdin */\ndiv p {\n color: red; }\n`\n\tif e != out.String() {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\\n\", out.String(), e)\n\t}\n\n}\n\nfunc TestOption_include(t *testing.T) {\n\tin := bytes.NewBufferString(`@import \"include\";`)\n\n\tvar out bytes.Buffer\n\tctx := newContext()\n\tctx.IncludePaths = []string{\"test/scss\"}\n\terr := ctx.compile(&out, in)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te := `a {\n color: blue; }\n`\n\tif e != out.String() {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\\n\", out.String(), e)\n\t}\n\n}\n\nfunc TestOption_new(t *testing.T) {\n\n\topts := []FuncOpt{Path(\"\")}\n\n\tNew(nil, nil, opts...)\n}\n" }, { "path": "test/scss/_include.scss", "content": "a { color: blue; }\n" }, { "path": "test/scss/basic.scss", "content": "div { p { color: red; } }\n" }, { "path": "test/scss/file.scss", "content": "@import \"a\";\n" }, { "path": "test/scss/main.scss", "content": "" }, { "path": "test/scss/sprite.scss", "content": "$sprites: sprite-map(\"../img/*.png\");\n$width: sprite-width($sprites, 139);\ndiv {\n height: image-height(sprite-file($sprites, \"139\"));\n width: image-width(sprite-file($sprites, \"139\"));\n\tbackground: sprite($sprites, \"139\");\n}\n" }, { "path": "toscss.go", "content": "package libsass\n\nimport (\n\t\"io\"\n\n\t\"github.com/wellington/go-libsass/libs\"\n)\n\n// ToScss converts Sass to Scss with libsass sass2scss.h\nfunc ToScss(r io.Reader, w io.Writer) error {\n\treturn libs.ToScss(r, w)\n}\n" }, { "path": "toscss_test.go", "content": "package libsass\n\nimport (\n\t\"bytes\"\n\t\"testing\"\n)\n\nfunc TestToScss(t *testing.T) {\n\tin := bytes.NewBufferString(`html,\nbody,\nul,\nol\n margin: 0\n padding: 0\n`)\n\n\tvar b bytes.Buffer\n\terr := ToScss(in, &b)\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\te := `html,\nbody,\nul,\nol {\n margin: 0;\n padding: 0; }\n`\n\tif b.String() != e {\n\t\tt.Errorf(\"got:\\n%s\\nwanted:\\n%s\", b.String(), e)\n\t}\n\n}\n" }, { "path": "unicode_test.go", "content": "package libsass\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"strings\"\n\t\"testing\"\n)\n\nfunc TestUnicode(t *testing.T) {\n\tt.Skip(\"unicode can not be stored in variables\")\n\tvar dst bytes.Buffer\n\n\tsrc := bytes.NewBufferString(`\n$test: \"\\f00d\";\n\np {\n\ta {\n\t\tcontent: $test;\n\t}\n\n\tb {\n\t\tcontent: \"\\f00c\";\n\t}\n}\n`)\n\n\tcomp, err := New(&dst, src)\n\tif err != nil {\n\t\tt.Error(\"Expected to create compiler successfully\")\n\t}\n\n\terr = comp.Run()\n\tif err != nil {\n\t\tt.Error(\"Expected to run the compiler successfully\")\n\t}\n\n\tcss := dst.String()\n\n\tif !strings.Contains(css, \"\\\\f00c\") { // This one is passing\n\t\tt.Errorf(\"Expected to find `%s` in compiled css\", \"\\\\f00c\")\n\t}\n\n\tif !strings.Contains(css, \"\\\\f00d\") { // This one isn't\n\t\tt.Errorf(\"Expected to find `%s` in compiled css\", \"\\\\f00d\")\n\t}\n\n\tfmt.Println(dst.String())\n}\n" }, { "path": "version.go", "content": "package libsass\n\nimport \"github.com/wellington/go-libsass/libs\"\n\n// Version reports libsass version information\nfunc Version() string {\n\treturn libs.Version()\n}\n" }, { "path": "version_test.go", "content": "package libsass\n\nimport \"testing\"\n\nfunc TestVersion(t *testing.T) {\n\tif len(Version()) == 0 {\n\t\tt.Fatal(\"No version reported\")\n\t}\n\tif Version() == \"[NA]\" {\n\t\tt.Fatalf(\"got: %s wanted: versioned lib\", Version())\n\t}\n}\n" } ]